PixelClusterCalibrationToolBase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ACTSTRACKRECONSTRUCTION_PIXELCLUSTERCALIBRATIONTOOLBASE_H
#define ACTSTRACKRECONSTRUCTION_PIXELCLUSTERCALIBRATIONTOOLBASE_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "InDetIdentifier/PixelID.h"
#include "InDetReadoutGeometry/SiDetectorElement.h"
#include "PixelConditionsData/ITkPixelOfflineCalibData.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "InDetCondTools/ISiLorentzAngleTool.h"
 
#include "ActsToolInterfaces/IPixelOnTrackCalibratorTool.h"
 
namespace ActsTrk::detail {
   struct PixelClusterCalibratorOptionsBase {
      const ISiLorentzAngleTool *m_lorentzAngleTool;
      const PixelID* m_pixelID;
   };

   template <typename traj_t>
   class PixelClusterCalibratorCommon :  public ActsTrk::PixelOnTrackCalibratorBase<traj_t>
   {
   public:
      explicit PixelClusterCalibratorCommon(PixelClusterCalibratorOptionsBase &&base_options)
         : m_baseOptions(std::move(base_options))
      {
         assert(m_baseOptions.m_pixelID);
         assert(m_baseOptions.m_lorentzAngleTool);
      }
 
   protected:
      using Pos = xAOD::MeasVector<2>; // the coordinates of a pixel cluster
      using Cov = xAOD::MeasMatrix<2>; // the corresponding covariance

      const InDetDD::SiDetectorElement& getDetectorElement(const Acts::Surface &surface) const;

      const PixelID &pixelID() const { return *m_baseOptions.m_pixelID; }

      double getLorentzShift(const IdentifierHash& elementHash, const EventContext& ctx) const {
         return m_baseOptions.m_lorentzAngleTool->getLorentzShift(elementHash, ctx);
      }

      std::pair<typename PixelClusterCalibratorCommon<traj_t>::Pos,
                typename PixelClusterCalibratorCommon<traj_t>::Cov>
      calibrate([[maybe_unused]] const EventContext &ctx,
                [[maybe_unused]] const Acts::GeometryContext& gctx,
                [[maybe_unused]] const Acts::CalibrationContext& cctx,
                const xAOD::PixelCluster& cluster,
                [[maybe_unused]] const InDetDD::SiDetectorElement& detElement,
                [[maybe_unused]] const std::pair<float, float>& tan_incident_angles) const {
         return std::make_pair(cluster.template localPosition<2>(),
                               cluster.template localCovariance<2>());
      }

      std::pair<float, float>
      tanAnglesOfIncidence(const EventContext& ctx,
                           const Acts::GeometryContext& gctx,
                           const Acts::Surface &surface,
                           const InDetDD::SiDetectorElement& element,
                           const Acts::Vector3& direction) const;
 
   protected:
      PixelClusterCalibratorOptionsBase m_baseOptions; // the common options of a pixel calibrator
   };
 
   template <typename derived_t, typename traj_t>
   class PixelClusterCalibratorBase : public PixelClusterCalibratorCommon<traj_t>
   {
   public:
      using BASE=PixelClusterCalibratorCommon<traj_t>;
      using BASE::BASE;
      using OnTrackCalibrator=OnTrackCalibratorBase<xAOD::PixelCluster,2,traj_t>::OnTrackCalibrator;
      using TrackStateProxy = OnTrackCalibratorBase<xAOD::PixelCluster,2,traj_t>::TrackStateProxy;
      using Calibrator=OnBoundStateCalibratorBase<xAOD::PixelCluster,2>::Calibrator;
      using Pos = BASE::Pos;
      using Cov = BASE::Cov;
 
      const derived_t &derived() const
         requires(std::is_base_of_v<std::remove_cvref_t<decltype( *this )>, derived_t >)
      {
         return *static_cast<const derived_t *>(this);
      }
 
      std::pair<Pos, Cov> calibrate(const Acts::GeometryContext&,
                                    const Acts::CalibrationContext&,
                                    const xAOD::PixelCluster&,
                                    const TrackStateProxy&) const;
 
      std::pair<Pos, Cov> calibrate(const Acts::GeometryContext&,
                                    const Acts::CalibrationContext&,
                                    const Acts::Surface&,
                                    const xAOD::PixelCluster&,
                                    const Acts::BoundTrackParameters&) const;

      virtual void connectOnTrackCalibrator(OnTrackCalibrator& calibrator) const override;

      virtual void connectCalibrator(Calibrator& calibrator) const override;
 
   };

   template <typename traj_t>
   class PixelClusterCalibrationToolBase
      : public extends<AthAlgTool, ActsTrk::IPixelOnTrackCalibratorTool<traj_t>> {
   public:
      using base_class = typename extends<AthAlgTool, ActsTrk::IPixelOnTrackCalibratorTool<traj_t>>::base_class;
      using base_class::base_class;

      virtual StatusCode initialize() override;

      virtual std::unique_ptr<PixelOnBoundStateCalibratorBase > create(const EventContext &ctx) const override {
         return this->createOnTrackCalibrator(ctx);
      }

      virtual bool calibrateAfterMeasurementSelection() const override;
 
   protected:
      PixelClusterCalibratorOptionsBase createBaseOptions(const EventContext &/*ctx*/) const {
         return PixelClusterCalibratorOptionsBase{
            .m_lorentzAngleTool=&(*m_lorentzAngleTool),
            .m_pixelID=m_pixelID,
         };
      }
 
      // @TODO should use the Lorentz angle conditions data directly
      ToolHandle<ISiLorentzAngleTool> m_lorentzAngleTool {this, "PixelLorentzAngleTool", "",
                                                          "Tool to retreive Lorentz angle"
      };
 
      Gaudi::Property<bool> m_postCalibration{this, "CalibrateAfterMeasurementSelection", true};
 
      const PixelID *m_pixelID{}; // The helper object to interpret identifiers
   };
 
} // namespace ActsTrk::detail
 
#include "src/detail/PixelClusterCalibrationToolBase.icc"
 
#endif