PixelClusterOnTrackTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef PixelClusterOnTrackTool_H
#define PixelClusterOnTrackTool_H
 
#include "GaudiKernel/ToolHandle.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 override;
 
  // Private methods:
 
protected:
  void correctBow(const Identifier&, Amg::Vector2D& locpos, const double tanphi, const double taneta) const;
 
  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 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 retreive 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."};
 
  bool                               m_disableDistortions;
  int                                m_positionStrategy  ;
  mutable std::atomic_int            m_errorStrategy{2};
  IntegerProperty                    m_errorStrategyProperty{this, "ErrorStrategy", 2, "Which calibration of cluster position errors"};
  
  
  const PixelID*                     m_pixelid;
  
  bool                              m_applyNNcorrection{false};
  BooleanProperty                   m_applyNNcorrectionProperty{this, "applyNNcorrection", false};
  bool                              m_NNIBLcorrection;
  bool                              m_IBLAbsent;
  
  ToolHandle<NnClusterizationFactory>                   m_NnClusterizationFactory;
  ServiceHandle<IIBLParameterSvc>                       m_IBLParameterSvc;
 
  bool                                                  m_doNotRecalibrateNN;
  bool                                                  m_noNNandBroadErrors;
  bool                      m_usingTIDE_Ambi;
  SG::ReadHandleKey<InDet::PixelGangedClusterAmbiguities>    m_splitClusterMapKey;
 
  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