PixelClusterOnTrackTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef PixelClusterOnTrackTool_H
#define PixelClusterOnTrackTool_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 "InDetPrepRawData/PixelGangedClusterAmbiguities.h"
#include "TrkParameters/TrackParameters.h"
#include "GeoPrimitives/GeoPrimitives.h"
 
#include "Identifier/Identifier.h"
#include "InDetIdentifier/PixelID.h"
 
#include "PixelConditionsData/PixelOfflineCalibData.h"
#include "PixelConditionsData/PixelDistortionData.h"
#include "InDetCondTools/ISiLorentzAngleTool.h"
#include "AthenaPoolUtilities/CondAttrListCollection.h"
#include "StoreGate/ReadCondHandleKey.h"
 
#include "PixelGeoModel/IIBLParameterSvc.h"
 
#include "TrkEventUtils/ClusterSplitProbabilityContainer.h"
 
#include <atomic>
#include <mutex>
 
namespace InDet {

 
  class NnClusterizationFactory;
 
  enum PixelClusterStrategy {
    PIXELCLUSTER_DEFAULT=0,
    PIXELCLUSTER_OUTLIER=1,
    PIXELCLUSTER_SHARED =2,
    PIXELCLUSTER_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 ();
  virtual StatusCode initialize() override;
  virtual StatusCode finalize  () override;

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

  // Private methods:
 
protected:
  void correctBow(const Identifier&, Amg::Vector2D& locpos, const double tanphi, const double taneta, const EventContext& ctx) const;
 
  InDet::PixelClusterOnTrack* correctDefault(const Trk::PrepRawData&,
                                             const Trk::TrackParameters&,
                                             const EventContext& ctx) const;
 
  InDet::PixelClusterOnTrack* correctNN(const Trk::PrepRawData&,
                                        const Trk::TrackParameters&,
                                        const EventContext& ctx) 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 InDet::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:
 
  SG::ReadCondHandleKey<PixelDistortionData> m_distortionKey
  {this, "PixelDistortionData", "PixelDistortionData", "Output readout distortion data"};
 
  ToolHandle<ISiLorentzAngleTool> m_lorentzAngleTool
    {this, "LorentzAngleTool", "SiLorentzAngleTool", "Tool to retrieve Lorentz angle"};
 
  SG::ReadCondHandleKey<PixelCalib::PixelOfflineCalibData> m_clusterErrorKey
    {this, "PixelOfflineCalibData", "PixelOfflineCalibData", "Output key of pixel cluster"};
  SG::ReadCondHandleKey<RIO_OnTrackErrorScaling> m_pixelErrorScalingKey
    {this,"PixelErrorScalingKey", "/Indet/TrkErrorScalingPixel", "Key for pixel error scaling conditions data."};

  BooleanProperty m_disableDistortions{this, "DisableDistortions", false,
    "Disable simulation of module distortions"};
  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;
  
  BooleanProperty m_applyNNcorrectionProperty{this, "applyNNcorrection", false};
  bool m_applyNNcorrection = false; // Updated depending on other configs
  BooleanProperty m_NNIBLcorrection{this, "NNIBLcorrection", false};
  bool m_IBLAbsent = true;
  
  ToolHandle<NnClusterizationFactory> m_NnClusterizationFactory
    {this, "NnClusterizationFactory",
     "InDet::NnClusterizationFactory/NnClusterizationFactory"};
  ServiceHandle<IIBLParameterSvc> m_IBLParameterSvc
    {this, "IBLParameterSvc", "IBLParameterSvc"};
 
  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", "",""};
 
  //moved from static to member variable
  static constexpr int s_nbinphi=9;
  static constexpr int s_nbineta=6;
  double m_calphi[s_nbinphi]{};
  double m_caleta[s_nbineta][3]{};
  double m_calerrphi[s_nbinphi][3]{};
  double m_calerreta[s_nbineta][3]{};
  double m_phix[s_nbinphi+1]{};
  double m_etax[s_nbineta+1]{};
};
 
} // end of namespace InDet
 
#endif // PixelClusterOnTrackTool_H