OnTrackCalibrator.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#include "ActsCalibrators/xAODUncalibMeasCalibrator.h"
#include <utility> // for declval
 
 
namespace ActsTrk::detail {
  
  template <typename traj_t>
  template <typename T_CalibratorToolHandle, typename T_Delegate>
  void OnTrackCalibrator<traj_t>::connectPassThrough(T_Delegate &delegate) {
     using CalibratorBase_t = typename decltype( std::declval<T_CalibratorToolHandle>()->createOnTrackCalibrator(std::declval<EventContext>()) )::element_type;
     delegate.template connect<&OnTrackCalibrator<traj_t>::passthrough<CalibratorBase_t::ClusterDIM,
                                                                       typename CalibratorBase_t::ClusterType>>(this);
  }
  template <typename traj_t>
  template <typename T_CalibratorToolHandle, typename T_Delegate>
  void OnTrackCalibrator<traj_t>::connect(const EventContext &ctx,
                                          const T_CalibratorToolHandle &calibrator_tool,
                                          T_Delegate &delegate ) {
     if (calibrator_tool.isEnabled()) {
        auto calibrator = calibrator_tool->createOnTrackCalibrator(ctx);
        calibrator->connectOnTrackCalibrator(delegate);
        m_calibrators.push_back(std::move(calibrator));
     } else {
        connectPassThrough<T_CalibratorToolHandle>(delegate);
     }
  }
 
  template <typename traj_t>
  OnTrackCalibrator<traj_t>::OnTrackCalibrator(const ActsTrk::ITrackingGeometryTool* trackGeoTool)
    : m_surfAcc{trackGeoTool} {
    connectPassThrough<ToolHandle<ActsTrk::IPixelOnTrackCalibratorTool<traj_t> > >(pixelCalibrator);
    connectPassThrough<ToolHandle<ActsTrk::IStripOnTrackCalibratorTool<traj_t> > >(stripCalibrator);
    connectPassThrough<ToolHandle<ActsTrk::IHGTDOnTrackCalibratorTool<traj_t> >  >(hgtdCalibrator);
  }
 
  template <typename traj_t>
  OnTrackCalibrator<traj_t>::OnTrackCalibrator(const EventContext &ctx,
                 const ActsTrk::ITrackingGeometryTool* trackGeoTool,
                 const ToolHandle<IPixelOnTrackCalibratorTool<traj_t>>& pixelTool,
                 const ToolHandle<IStripOnTrackCalibratorTool<traj_t>>& stripTool,
                 const ToolHandle<IHGTDOnTrackCalibratorTool<traj_t>>& hgtdTool)
    : m_surfAcc{trackGeoTool} {
    assert( m_calibrators.capacity() >= 3); // if capacity was constexpr should turn into static_assert
    connect(ctx,pixelTool,pixelCalibrator);
    connect(ctx,stripTool,stripCalibrator);
    connect(ctx,hgtdTool,hgtdCalibrator);
  }
 
  template <typename traj_t>
  void OnTrackCalibrator<traj_t>::calibrate(const Acts::GeometryContext& geoctx,
                                            const Acts::CalibrationContext& cctx,
                                            const Acts::SourceLink& link,
                                            TrackStateProxy state) const {
    
    const xAOD::UncalibratedMeasurement& measurement{*xAODUncalibMeasCalibrator::unpack(link)};
    // @TODO in principle only need to lookup surface for strips
    switch (measurement.type()) {
        using enum xAOD::UncalibMeasType;
        using enum ProjectorType;
        case PixelClusterType: {
          assert(pixelCalibrator.connected());
          prepareCalibratedState<2>(e2DimNoTime, link, state);
          pixelCalibrator(geoctx, cctx,static_cast<const xAOD::PixelCluster&>(measurement), state);
          break;
        } case StripClusterType: {
          assert(stripCalibrator.connected());
          const Acts::Surface *surface = m_surfAcc.get(&measurement);
          if (!surface) {
            throw std::runtime_error("OnTrackCalibrator<traj_t>::calibrate() -- No surface for measurement.");
          }
          prepareCalibratedState<1>(surface->bounds().type() == Acts::SurfaceBounds::eAnnulus ? e1DimRotNoTime : e1DimNoTime,
                      link, state);
          stripCalibrator(geoctx, cctx,static_cast<const xAOD::StripCluster&>(measurement), state);
          break;
        } case HGTDClusterType: {
          assert(hgtdCalibrator.connected());
          prepareCalibratedState<3>(e2DimWithTime, link, state);
          hgtdCalibrator(geoctx, cctx,static_cast<const xAOD::HGTDCluster&>(measurement), state);
          break;
        } default:
            throw std::domain_error("OnTrackCalibrator can only handle Pixel or Strip measurements");
      }
  }
  
  template <typename traj_t>
  template <std::size_t Dim, typename Cluster>
  void
  OnTrackCalibrator<traj_t>::passthrough(const Acts::GeometryContext& /*gctx*/,
                                         const Acts::CalibrationContext& /*cctx*/,
                                         const Cluster& cluster,
                                         TrackStateProxy& trackState) const {
    trackState.allocateCalibrated(Dim);
    auto pos = trackState.template calibrated<Dim>();
    auto cov  = trackState.template calibratedCovariance<Dim>();
    pos = cluster.template localPosition<Dim>().template cast<double>();
    cov = cluster.template localCovariance<Dim>().template cast<double>();
    if constexpr(std::is_same_v<xAOD::HGTDCluster, std::remove_cvref_t<Cluster> >) {
       pos(2,0)  = ActsTrk::timeToActs(pos(2,0));
       assert(cov(2,1)==0. && cov(2,0)==0.);
       cov(2,2) = ActsTrk::timeCovToActs(cov(2,2));
       assert( ActsTrk::timeToActs( cluster.template localPosition<Dim>().template cast<double>()(2,0) ) == trackState.template calibrated<Dim>()(2,0) );
       assert( ActsTrk::timeToActs( cluster.template localCovariance<Dim>().template cast<double>()(2,0) ) == trackState.template calibratedCovariance<Dim>()(2,0) );
    }
  }
} // namespace ActsTrk