ITkPixelClusterOnTrackTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ITkPixelClusterOnTrackTool_H
#define ITkPixelClusterOnTrackTool_H
 
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ThreadLocalContext.h"
#include "AthenaBaseComps/AthAlgTool.h"
 
#include "TrkToolInterfaces/IRIO_OnTrackCreator.h"
#include "InDetRIO_OnTrack/PixelClusterOnTrack.h"
#include "InDetRIO_OnTrack/PixelRIO_OnTrackErrorScaling.h"
#include "SiClusterizationTool/NnClusterizationFactory.h"
 
#include "InDetPrepRawData/PixelGangedClusterAmbiguities.h"
#include "TrkParameters/TrackParameters.h"
#include "GeoPrimitives/GeoPrimitives.h"
 
#include "Identifier/Identifier.h"
#include "InDetIdentifier/PixelID.h"
 
#include "PixelConditionsData/ITkPixelOfflineCalibData.h"
#include "PixelConditionsData/PixelDistortionData.h"
#include "InDetCondTools/ISiLorentzAngleTool.h"
#include "AthenaPoolUtilities/CondAttrListCollection.h"
#include "StoreGate/ReadCondHandleKey.h"
 
#include "TrkEventUtils/ClusterSplitProbabilityContainer.h"
 
#include <atomic>
#include <mutex>
 
namespace ITk
{

 
  enum class PixelClusterStrategy {
    DEFAULT=0,
    OUTLIER=1,
    SHARED =2,
    SPLIT  =3
  };
 
  class PixelClusterOnTrackTool final: 
        public AthAlgTool, virtual public Trk::IRIO_OnTrackCreator
{
  // Public methods:
 
public:

  PixelClusterOnTrackTool(const std::string&,const std::string&,
                          const IInterface*);
  virtual ~PixelClusterOnTrackTool () = default;
  virtual StatusCode initialize() override;

  virtual InDet::PixelClusterOnTrack* correct(
      const Trk::PrepRawData&, const Trk::TrackParameters&, const EventContext& ctx = Gaudi::Hive::currentContext()) const override;

  // Private methods:
 
protected:
 InDet::PixelClusterOnTrack* correctDefault(const Trk::PrepRawData&,
                                            const Trk::TrackParameters&) const;
 
 InDet::PixelClusterOnTrack* correctNN(const Trk::PrepRawData&,
                                       const Trk::TrackParameters&) const;
 
 bool getErrorsDefaultAmbi(const InDet::PixelCluster*,
                           const Trk::TrackParameters&, Amg::Vector2D&,
                           Amg::MatrixX&) const;
 
 bool getErrorsTIDE_Ambi(const InDet::PixelCluster*,
                         const Trk::TrackParameters&, Amg::Vector2D&,
                         Amg::MatrixX&) const;
 
 InDet::PixelClusterOnTrack* correct(const Trk::PrepRawData&,
                                     const Trk::TrackParameters&,
                                     const ITk::PixelClusterStrategy) const;
 
 const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo&
 getClusterSplittingProbability(const InDet::PixelCluster* pix) const {
   if (!pix || m_clusterSplitProbContainer.key().empty())
     return Trk::ClusterSplitProbabilityContainer::getNoSplitProbability();
 
   SG::ReadHandle<Trk::ClusterSplitProbabilityContainer> splitProbContainer(
       m_clusterSplitProbContainer);
   if (!splitProbContainer.isValid()) {
     ATH_MSG_FATAL("Failed to get cluster splitting probability container "
                   << m_clusterSplitProbContainer);
   }
   return splitProbContainer->splitProbability(pix);
  }
 
private:

  // Private data:
 
  ToolHandle<ISiLorentzAngleTool> m_lorentzAngleTool{this, "LorentzAngleTool", "SiLorentzAngleTool", "Tool to retreive Lorentz angle"};
 
  SG::ReadCondHandleKey<ITk::PixelOfflineCalibData> m_clusterITkErrorKey{this, "ITkPixelOfflineCalibData", "ITkPixelOfflineCalibData", "Output key of ITk pixel cluster"};
 
  SG::ReadCondHandleKey<RIO_OnTrackErrorScaling> m_pixelErrorScalingKey
    {this,"PixelErrorScalingKey", "/Indet/TrkErrorScalingPixel", "Key for pixel error scaling conditions data."};

  IntegerProperty m_positionStrategy{this, "PositionStrategy", 1,
      "Which calibration of cluster positions"};
  mutable std::atomic_int            m_errorStrategy{2};
  IntegerProperty m_errorStrategyProperty{this, "ErrorStrategy", 2,
      "Which calibration of cluster position errors"};
  
  
  const PixelID*                     m_pixelid = nullptr;
  
  bool                              m_applyNNcorrection{false};
  BooleanProperty                   m_applyNNcorrectionProperty{this, "applyNNcorrection", false};
  
  ToolHandle<InDet::NnClusterizationFactory> m_NnClusterizationFactory
    {this, "NnClusterizationFactory",
    "InDet::NnClusterizationFactory/NnClusterizationFactory"};
 
  BooleanProperty m_doNotRecalibrateNN{this, "doNotRecalibrateNN", false};
  BooleanProperty m_noNNandBroadErrors{this, "noNNandBroadErrors", false};
  BooleanProperty m_usingTIDE_Ambi{this, "RunningTIDE_Ambi", false};
  SG::ReadHandleKey<InDet::PixelGangedClusterAmbiguities> m_splitClusterMapKey
    {this, "SplitClusterAmbiguityMap", ""};
 
  SG::ReadHandleKey<Trk::ClusterSplitProbabilityContainer> m_clusterSplitProbContainer
    {this, "ClusterSplitProbabilityName", "",""};
 
};
 
} // end of namespace ITk
 
#endif // ITkPixelClusterOnTrackTool_H