MdtCalibInput.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#include "MdtCalibInterfaces/MdtCalibInput.h"
 
#include "GaudiKernel/PhysicalConstants.h"
#include "GeoPrimitives/GeoPrimitivesToStringConverter.h"
 
#include <MuonReadoutGeometry/MdtReadoutElement.h>
#include <MuonReadoutGeometry/MuonDetectorManager.h>
#include <MuonReadoutGeometryR4/MdtReadoutElement.h>
#include <MuonReadoutGeometryR4/MuonDetectorManager.h>
#include <xAODMuonPrepData/MdtDriftCircle.h>
#include <MuonDigitContainer/MdtDigit.h>
#include <MuonPrepRawData/MdtPrepData.h>
#include <TrkSurfaces/StraightLineSurface.h>
#include <GeoModelKernel/throwExcept.h>
 
#include <cassert>
 
namespace {
   static constexpr double s_inverseSpeed{1. / Gaudi::Units::c_light};
}
 
void MdtCalibInput::print(std::ostream& ostr) const {
   ostr<<"adc: "<<adc()<<", ";
   ostr<<"tdc: "<<tdc()<<", ";
   if (m_approach.isValid()) {
      ostr<<"closest approach: "<<Amg::toString(closestApproach(), 2)<<", ";
   }
   ostr<<"global direction: "<<Amg::toString(trackDirection(), 2)<<", ";
   ostr<<"prop distance: "<<signalPropagationDistance()<<", ";
   if (m_ToF.isValid()) {
      ostr<<"ToF: "<<timeOfFlight()<<", ";
   }
   ostr<<"trigger time: "<<triggerTime();
 
}
MdtCalibInput::~MdtCalibInput() = default;
MdtCalibInput::MdtCalibInput(const Identifier& id,
                             const int16_t adc,
                             const int16_t tdc,
                             const MuonGMR4::MdtReadoutElement* reEle,
                             const ActsTrk::GeometryContext& gctx):
   m_id{id},
   m_adc{adc},
   m_tdc{tdc},
   m_gctx{&gctx},
   m_RE{reEle},
   m_hash{reEle->measurementHash(m_id)}  {}
 
MdtCalibInput::MdtCalibInput(const MdtDigit& digit,
                             const MuonGMR4::MuonDetectorManager& detMgr,
                             const ActsTrk::GeometryContext& gctx):
   MdtCalibInput{digit.identify(), digit.adc(), digit.tdc(), 
                 detMgr.getMdtReadoutElement(digit.identify()), gctx} {}
 
MdtCalibInput::MdtCalibInput(const Identifier& id,
                             const int16_t adc,
                             const int16_t tdc,
                             const MuonGM::MdtReadoutElement* reEle):
   m_id{id},
   m_adc{adc},
   m_tdc{tdc},
   m_RE{reEle} {}
 
MdtCalibInput::MdtCalibInput(const MdtDigit& digit,
                             const MuonGM::MuonDetectorManager& detMgr):
   MdtCalibInput{digit.identify(), digit.adc(), digit.tdc(), 
                 detMgr.getMdtReadoutElement(digit.identify())} {}
 
 
MdtCalibInput::MdtCalibInput(const xAOD::MdtDriftCircle& prd,
                             const ActsTrk::GeometryContext& gctx):
   m_id{prd.identify()},
   m_adc{prd.adc()},
   m_tdc{prd.tdc()},
   m_gctx{&gctx},
   m_RE{prd.readoutElement()},
   m_hash{prd.measurementHash()},  
   m_approach{localToGlobal()* prd.localMeasurementPos()} {}
   
   
MdtCalibInput::MdtCalibInput(const Muon::MdtPrepData& prd):
   m_id{prd.identify()},
   m_adc{static_cast<int16_t>(prd.adc())},
   m_tdc{static_cast<int16_t>(prd.tdc())},
   m_RE{prd.detectorElement()},  
   m_approach{prd.globalPosition()} {
}
 
const Identifier& MdtCalibInput::identify() const { return m_id; }
int16_t MdtCalibInput::tdc() const{ return m_tdc; }
int16_t MdtCalibInput::adc() const{ return m_adc; }
const MuonGM::MdtReadoutElement* MdtCalibInput::legacyDescriptor() const { 
   if (std::holds_alternative<const MuonGM::MdtReadoutElement*>(m_RE)) {
      return std::get<const MuonGM::MdtReadoutElement*>(m_RE);
   }
   return nullptr;
}
const MuonGMR4::MdtReadoutElement* MdtCalibInput::decriptor() const { 
   if (std::holds_alternative<const MuonGMR4::MdtReadoutElement*>(m_RE)) {
      return std::get<const MuonGMR4::MdtReadoutElement*>(m_RE);
   }
   return nullptr;
}
const Amg::Vector3D& MdtCalibInput::closestApproach() const { 
   if (!m_approach.isValid()) {
      m_approach.set(localToGlobal().translation());
   }
   assert(m_approach.ptr() != nullptr);
   return *m_approach.ptr(); 
}
void MdtCalibInput::setClosestApproach(const Amg::Vector3D& approach) {
   m_approach.store(approach);
}
const Amg::Vector3D& MdtCalibInput::trackDirection() const { return m_trackDir; }
void MdtCalibInput::setTrackDirection(const Amg::Vector3D& trackDir, bool hasPhi) { 
   m_trackDir = trackDir;
   m_trackHasPhi = hasPhi;
}
bool MdtCalibInput::trackDirHasPhi() const { return m_trackHasPhi; }
double MdtCalibInput::timeOfFlight() const { 
   if (!m_ToF.isValid()) {
      m_ToF.set(closestApproach().mag() * s_inverseSpeed);
   }
   assert(m_ToF.ptr() != nullptr);
   return *m_ToF.ptr(); 
}
void MdtCalibInput::setTimeOfFlight(const double toF) { m_ToF.store(toF); }
 
double MdtCalibInput::triggerTime() const { return m_trigTime; }
void MdtCalibInput::setTriggerTime(const double trigTime) { m_trigTime = trigTime; }
 
Amg::Vector2D MdtCalibInput::projectMagneticField(const Amg::Vector3D& fieldInGlob) const {
   const Amg::Transform3D trf{localToGlobal().inverse()};
   const Amg::Vector3D locBField = trf.linear() * fieldInGlob;
   const Amg::Vector3D locTrkDir = trf.linear() * trackDirection();
 
   const double perpendComp = locTrkDir.block<2,1>(0,0).dot(locBField.block<2,1>(0,0)) 
                            / locTrkDir.perp();
   const double paralelComp = locBField.z();
   return 1000. * Amg::Vector2D{paralelComp, perpendComp};
}
const Trk::StraightLineSurface& MdtCalibInput::legacySurface() const {
   const MuonGM::MdtReadoutElement* re = legacyDescriptor();
   assert(re != nullptr);
   return re->surface(identify());
}
double MdtCalibInput::signalPropagationDistance() const {
   const double propDist = std::visit([this](const auto& re) ->double {
         using REType = std::decay_t<decltype(re)>;
         if constexpr(std::is_same_v<REType, const MuonGMR4::MdtReadoutElement*>){
            assert(m_gctx != nullptr);
            return re->distanceToReadout(*m_gctx, m_hash, closestApproach());
         } else if (std::is_same_v<REType, const MuonGM::MdtReadoutElement*>) {
            return re->distanceFromRO(closestApproach(), identify()) -
                     re->RODistanceFromTubeCentre(identify());
         }
      }, m_RE); 
   return propDist;
}
double MdtCalibInput::distanceToTrack() const { return m_distToTrack; }
 
double MdtCalibInput::tubeLength() const {
   const double tubeLength  = std::visit([this](const auto& re) ->double{
         using REType = std::decay_t<decltype(re)>;
         if constexpr(std::is_same_v<REType, const MuonGMR4::MdtReadoutElement*>){
            return re->tubeLength(m_hash);
         } else if (std::is_same_v<REType, const MuonGM::MdtReadoutElement*>) {
            return re->tubeLength(identify());
         }
      }, m_RE);
    return tubeLength;
 }
 double MdtCalibInput::innerTubeR() const {
   const double tubeR = std::visit([](const auto& re) -> double {
       using REType = std::decay_t<decltype(re)>;
      if constexpr(std::is_same_v<REType, const MuonGMR4::MdtReadoutElement*>){
         return re->innerTubeRadius();
      } else if (std::is_same_v<REType, const MuonGM::MdtReadoutElement*>) {
         return re->innerTubeRadius();
      }
   }, m_RE);
   return tubeR;
 }
double MdtCalibInput::readOutSide() const {
   const double roSide = std::visit([this](const auto& re) ->double{
         using REType = std::decay_t<decltype(re)>;
         if constexpr(std::is_same_v<REType, const MuonGMR4::MdtReadoutElement*>){
            return re->getParameters().readoutSide;
         } else if (std::is_same_v<REType, const MuonGM::MdtReadoutElement*>) {
            return re->tubeFrame_localROPos(identify()).z() > 0. ? 1. : -1.;
         }
      }, m_RE);
   return roSide;
}
const Amg::Transform3D& MdtCalibInput::localToGlobal() const {
   return std::visit([this](const auto& re) ->const Amg::Transform3D&{
         using REType = std::decay_t<decltype(re)>;
         if constexpr(std::is_same_v<REType, const MuonGMR4::MdtReadoutElement*>){
            assert(m_gctx != nullptr);
            return re->localToGlobalTransform(*m_gctx, m_hash);
         } else if (std::is_same_v<REType, const MuonGM::MdtReadoutElement*>) {
            return re->localToGlobalTransf(identify());
         }
   }, m_RE);
}