MuonR4::SpacePointCalibrator Class Reference

#include <SpacePointCalibrator.h>

Inheritance diagram for MuonR4::SpacePointCalibrator:

Collaboration diagram for MuonR4::SpacePointCalibrator:

Public Types
enum	ProjectorType {   ProjectorType::e1DimNoTime = 0, ProjectorType::e1DimRotNoTime = 1, ProjectorType::e2DimNoTime = 2, ProjectorType::e1DimWithTime = 3,   ProjectorType::e1DimRotWithTime = 4, ProjectorType::e2DimWithTime = 5 }
	Enum encoding the possible projectors used in ATLAS. More...
template<typename trajectory_t >
using	TrackState_t = typename Acts::MultiTrajectory< trajectory_t >::TrackStateProxy
	Abbrivation of the track state proxy type. More...
template<typename trajectory_t >
using	ConstTrackState_t = typename Acts::MultiTrajectory< trajectory_t >::ConstTrackStateProxy
	Abbrivation of the const track state proxy type. More...

Public Member Functions
StatusCode	initialize () override final
CalibSpacePointPtr	calibrate (const EventContext &ctx, const SpacePoint *spacePoint, const Amg::Vector3D &seedPosInChamb, const Amg::Vector3D &seedDirInChamb, const double timeDelay) const override final
CalibSpacePointPtr	calibrate (const EventContext &ctx, const CalibratedSpacePoint &spacePoint, const Amg::Vector3D &seedPosInChamb, const Amg::Vector3D &seedDirInChamb, const double timeDelay) const override final
CalibSpacePointVec	calibrate (const EventContext &ctx, const std::vector< const SpacePoint * > &spacePoints, const Amg::Vector3D &seedPosInChamb, const Amg::Vector3D &seedDirInChamb, const double timeDelay) const override final
CalibSpacePointVec	calibrate (const EventContext &ctx, CalibSpacePointVec &&spacePoints, const Amg::Vector3D &seedPosInChamb, const Amg::Vector3D &seedDirInChamb, const double timeDelay) const override final
double	driftVelocity (const EventContext &ctx, const CalibratedSpacePoint &spacePoint) const override final
double	driftAcceleration (const EventContext &ctx, const CalibratedSpacePoint &spacePoint) const override final
void	calibrateSourceLink (const Acts::GeometryContext &geoctx, const Acts::CalibrationContext &cctx, const Acts::SourceLink &link, ActsTrk::MutableTrackContainer::TrackStateProxy state) const override final
template<std::size_t Dim, typename trajectory_t , typename pos_t , typename cov_t >
void	setState (const ProjectorType projector, const pos_t &locpos, const cov_t &cov, Acts::SourceLink link, TrackState_t< trajectory_t > &trackState) const
	Copy the local position & covariance into the Acts track state proxy. More...

Private Attributes
SG::ReadHandleKey< ActsGeometryContext >	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
	access to the ACTS geometry context More...
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ToolHandle< IMdtCalibrationTool >	m_mdtCalibrationTool {this, "MdtCalibrationTool", ""}
ToolHandle< Muon::INSWCalibTool >	m_nswCalibTool {this, "NSWCalibTool", ""}
ToolHandle< Muon::IMMClusterBuilderTool >	m_clusterBuilderToolMM {this, "MMClusterBuilder", ""}
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
Gaudi::Property< double >	m_muonPropSpeed {this, "PropagationSpeed", 1./ Gaudi::Units::c_light }
	Assumed propagation velocity of the muon through the detector. More...
Gaudi::Property< double >	m_rpcSignalVelocity
	How fast does an electron signal travel along an rpc strip More...
Gaudi::Property< double >	m_rpcTimeResolution
Gaudi::Property< bool >	m_useRpcTime {this, "useRpcTime", false}
	Load the Rpc time on the track states for the track fit. More...
Gaudi::Property< bool >	m_useTgcTime
	Load the Tgc bunch crossing ID on the track states. More...

Static Private Attributes
constexpr static std::array< Acts::BoundSubspaceIndices, 6 >	s_boundSpaceIndices
	Array to map the Projector types to the bound index configurations used by the ATLAS detector measurements. More...

Detailed Description

Definition at line 26 of file SpacePointCalibrator.h.

Member Typedef Documentation

ConstTrackState_t

template<typename trajectory_t >

using ActsTrk::detail::MeasurementCalibratorBase::ConstTrackState_t = typename Acts::MultiTrajectory<trajectory_t>::ConstTrackStateProxy

inherited

Abbrivation of the const track state proxy type.

Definition at line 44 of file MeasurementCalibratorBase.h.

TrackState_t

template<typename trajectory_t >

using ActsTrk::detail::MeasurementCalibratorBase::TrackState_t = typename Acts::MultiTrajectory<trajectory_t>::TrackStateProxy

inherited

Abbrivation of the track state proxy type.

Definition at line 41 of file MeasurementCalibratorBase.h.

Member Enumeration Documentation

ProjectorType

enum ActsTrk::detail::MeasurementCalibratorBase::ProjectorType

stronginherited

Enum encoding the possible projectors used in ATLAS.

Their integer representations correspond to the element index in the s_boundSpaceIndices member

Enumerator
e1DimNoTime
e1DimRotNoTime	Project out solely the locX (Applies to Itk strips, Rpc, Tgc, sTgc, Mm)
e2DimNoTime	Project out solely the locY - Complementary projector if the strip plane is rotated (Applies to Itk endcap strips, Rpc, Tgc, sTgc)
e1DimWithTime	Project out the two spatial coordinates - (Applies to ITk pixel, BI-Rpc, sTgc pad)
e1DimRotWithTime	Project out the locX & time coordinate - (Applies to Rpc, Tgc, Mm, sTgc)
e2DimWithTime	Project out the locY & time coordinate - (Applies to Rpc, Tgc, sTgc)

Definition at line 29 of file MeasurementCalibratorBase.h.

                            {
        e1DimNoTime = 0,      
        e1DimRotNoTime = 1,   
        e2DimNoTime = 2,      
        e1DimWithTime = 3,    
        e1DimRotWithTime = 4, 
        e2DimWithTime = 5,    
    };

Member Function Documentation

calibrate() [1/4]

CalibSpacePointVec MuonR4::SpacePointCalibrator::calibrate ( const EventContext &  ctx, CalibSpacePointVec &&  spacePoints, const Amg::Vector3D &  seedPosInChamb, const Amg::Vector3D &  seedDirInChamb, const double  timeDelay  ) const

finaloverride

Definition at line 62 of file SpacePointCalibrator.cxx.

                                                                                     {
        for (CalibSpacePointPtr& sp : spacePoints){
            sp = calibrate(ctx, *sp, segPos, segDir, timeDelay);
        }
        return spacePoints;
    }

calibrate() [2/4]

CalibSpacePointPtr MuonR4::SpacePointCalibrator::calibrate ( const EventContext &  ctx, const CalibratedSpacePoint &  spacePoint, const Amg::Vector3D &  seedPosInChamb, const Amg::Vector3D &  seedDirInChamb, const double  timeDelay  ) const

finaloverride

Definition at line 45 of file SpacePointCalibrator.cxx.

                                                                                     {
        CalibSpacePointPtr calibSP{};
        if (spacePoint.type() != xAOD::UncalibMeasType::Other){
            calibSP = calibrate(ctx, spacePoint.spacePoint(), segPos, segDir, timeDelay);
        } else {
            calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint);
        }
        if (spacePoint.fitState() == State::Outlier) {
            calibSP->setFitState(State::Outlier);
        }
        return calibSP;
    }

calibrate() [3/4]

CalibSpacePointPtr MuonR4::SpacePointCalibrator::calibrate ( const EventContext &  ctx, const SpacePoint *  spacePoint, const Amg::Vector3D &  seedPosInChamb, const Amg::Vector3D &  seedDirInChamb, const double  timeDelay  ) const

finaloverride

In valid drift radius has been created

Transform the space point into the local frame to calculate the propagation time towards the readout

Average the time

Add the difference to the covariance though

TODO: Use also the time of the secondary measurement...

Reminder to myself, we should modify the covariance if the space point is 1D? Probably... dunno

Definition at line 73 of file SpacePointCalibrator.cxx.

                                                                                      {
        
        const ActsGeometryContext* gctx{nullptr};
        if (!SG::get(gctx, m_geoCtxKey, ctx).isSuccess()) {
            return nullptr;
        }
        const Amg::Vector3D& spPos{spacePoint->positionInChamber()};
        const Amg::Transform3D& locToGlob{spacePoint->msSector()->localToGlobalTrans(*gctx)};
        Amg::Vector3D chDir{spacePoint->directionInChamber()};
 
        // Adjust the space point position according to the external seed. But only if the space point
        // is a 1D strip
        Amg::Vector3D calibSpPos = spacePoint->dimension() == 2 ? spPos
                                 : spPos + Amg::intersect<3>(posInChamb, dirInChamb, spPos, chDir).value_or(0) * chDir;               
 
        CalibSpacePointPtr calibSP{};
        switch (spacePoint->type()) {
            case xAOD::UncalibMeasType::MdtDriftCircleType: {
                const Amg::Vector3D locClosestApproach = posInChamb 
                                                       + Amg::intersect<3>(spPos, chDir,
                                                                           posInChamb, dirInChamb).value_or(0) * dirInChamb;
 
                Amg::Vector3D closestApproach{locToGlob* locClosestApproach};
                const double timeOfArrival = closestApproach.mag() * c_inv  + timeOffset;
                AmgSymMatrix(2) jac{AmgSymMatrix(2)::Identity()};
                jac.col(0) = spacePoint->normalInChamber().block<2,1>(0,0).unit();
                jac.col(1) = spacePoint->directionInChamber().block<2,1>(0,0).unit();
 
                if (spacePoint->dimension() == 1) {
                    auto* dc = static_cast<const xAOD::MdtDriftCircle*>(spacePoint->primaryMeasurement());
                    MdtCalibInput calibInput{*dc, *gctx};
                    calibInput.setTrackDirection(locToGlob.linear() * dirInChamb,
                                                 dirInChamb.phi() || posInChamb[toInt(AxisDefs::phi)] );
                    calibInput.setTimeOfFlight(timeOfArrival);
                    calibInput.setClosestApproach(std::move(closestApproach));
                    ATH_MSG_VERBOSE("Parse hit calibration "<<m_idHelperSvc->toString(dc->identify())<<", "<<calibInput);
                    MdtCalibOutput calibOutput = m_mdtCalibrationTool->calibrate(ctx, calibInput);
                    ATH_MSG_VERBOSE("Returned calibration object "<<calibOutput);
                    State fitState{State::Valid};
                    AmgSymMatrix(2) diagCov{AmgSymMatrix(2)::Identity()};
                    diagCov(toInt(AxisDefs::eta), toInt(AxisDefs::eta)) = std::pow(0.5* dc->readoutElement()->activeTubeLength(dc->measurementHash()),2);
                    if (calibOutput.status() != Muon::MdtDriftCircleStatus::MdtStatusDriftTime) {
                        ATH_MSG_DEBUG("Failed to create a valid hit from "<<m_idHelperSvc->toString(dc->identify())
                                        <<std::endl<<calibInput<<std::endl<<calibOutput);
                        fitState =  State::FailedCalib;
                        diagCov(toInt(AxisDefs::phi), toInt(AxisDefs::phi)) = std::pow(dc->readoutElement()->innerTubeRadius(), 2);
                    } else {
                        diagCov(toInt(AxisDefs::phi), toInt(AxisDefs::phi)) = std::pow(calibOutput.driftRadiusUncert(), 2);
                    }
                    calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos), std::move(chDir), fitState);
                    calibSP->setCovariance<2>(jac.inverse()*diagCov*jac);
                    calibSP->setDriftRadius(calibOutput.driftRadius());
                } else {
                    auto* dc = static_cast<const xAOD::MdtTwinDriftCircle*>(spacePoint->primaryMeasurement());
                    MdtCalibInput calibInput{*dc, *gctx};
                    calibInput.setClosestApproach(closestApproach);
                    calibInput.setTimeOfFlight(timeOfArrival);
 
                    MdtCalibInput twinInput{dc->twinIdentify(), dc->twinAdc(),  dc->twinTdc(), dc->readoutElement(), *gctx};
                    twinInput.setClosestApproach(closestApproach);
                    twinInput.setTimeOfFlight(timeOfArrival);
 
                    MdtCalibTwinOutput calibOutput = m_mdtCalibrationTool->calibrateTwinTubes(ctx,
                                                                                              std::move(calibInput),
                                                                                              std::move(twinInput)); 
 
                    AmgSymMatrix(2) diagCov{AmgSymMatrix(2)::Identity()};
                    State fitState{State::Valid};
                    if (calibOutput.primaryStatus() != Muon::MdtDriftCircleStatus::MdtStatusDriftTime) {
                        ATH_MSG_DEBUG("Failed to create a valid hit from "<<m_idHelperSvc->toString(dc->identify())
                                     <<std::endl<<calibOutput);
                        diagCov(toInt(AxisDefs::phi), toInt(AxisDefs::phi)) = std::pow(dc->readoutElement()->innerTubeRadius(), 2);
                        diagCov(toInt(AxisDefs::eta), toInt(AxisDefs::eta)) = std::pow(0.5* dc->readoutElement()->activeTubeLength(dc->measurementHash()), 2);
                        fitState = State::FailedCalib;
                    } else {
                        diagCov(toInt(AxisDefs::phi), toInt(AxisDefs::phi)) = std::pow(calibOutput.uncertPrimaryR(), 2);
                        diagCov(toInt(AxisDefs::eta), toInt(AxisDefs::eta)) = std::pow(calibOutput.sigmaZ(), 2);
                    }
                    calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos), std::move(chDir), fitState);
                    calibSP->setCovariance<2>(jac.inverse()*diagCov*jac);
                    calibSP->setDriftRadius(calibOutput.primaryDriftR());
                }
                break;
           }
           case xAOD::UncalibMeasType::RpcStripType: {
                auto* strip = static_cast<const xAOD::RpcMeasurement*>(spacePoint->primaryMeasurement());
 
                const Amg::Transform3D toGasGap{strip->readoutElement()->globalToLocalTrans(*gctx, strip->layerHash()) * locToGlob};
                const Amg::Vector3D lPos = toGasGap * calibSpPos;
                using EdgeSide = MuonGMR4::RpcReadoutElement::EdgeSide;
                calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos), std::move(chDir));
                AmgSymMatrix(3) cov{AmgSymMatrix(3)::Identity()};
                cov.block<2,2>(0, 0) = spacePoint->covariance();
 
                cov(2, 2) = m_rpcTimeResolution * m_rpcTimeResolution;
 
                const double time1 = strip->time() 
                                   - strip->readoutElement()->distanceToEdge(strip->layerHash(),
                                                                             lPos.block<2,1>(0,0),
                                                                             EdgeSide::readOut)  /m_rpcSignalVelocity;
 
                if (spacePoint->dimension() == 2) {                   
                    auto* strip2 = static_cast<const xAOD::RpcMeasurement*>(spacePoint->secondaryMeasurement());
 
                    const double time2 = strip2->time() -
                                         strip2->readoutElement()->distanceToEdge(strip2->layerHash(),
                                                                                  Eigen::Rotation2D{M_PI_2}*lPos.block<2,1>(0,0),
                                                                                  EdgeSide::readOut)/m_rpcSignalVelocity;
                    calibSP->setTimeMeasurement(0.5*(time1 + time2));
                    cov(2,2) += std::pow(0.5*(time1 - time2), 2);
                    cov(2,1) = cov(1,2) = - strip->readoutElement()->stripPhiPitch() /m_rpcSignalVelocity / std::sqrt(12.)* std::sqrt(cov(2, 2));
                    cov(2,0) = cov(0,2) = - strip->readoutElement()->stripEtaPitch() /m_rpcSignalVelocity / std::sqrt(12.)* std::sqrt(cov(2, 2));
 
                } else {
                    calibSP->setTimeMeasurement(time1);
                    if (strip->measuresPhi()) {
                        cov(2,1) = cov(1,2) = - 0.5 *strip->readoutElement()->stripPhiLength() /m_rpcSignalVelocity * std::sqrt(cov(2, 2));
                    } else {
                        cov(2,0) = cov(0,2) = - 0.5 *strip->readoutElement()->stripEtaLength() /m_rpcSignalVelocity * std::sqrt(cov(2, 2));
                    }
                }
                calibSP->setCovariance<3>(std::move(cov));
                ATH_MSG_VERBOSE("Create rpc space point "<<m_idHelperSvc->toString(strip->identify())<<", dimension "<<spacePoint->dimension()
                                << ", at "<<Amg::toString(calibSP->positionInChamber())<<", uncalib time: "
                             <<strip->time()<<", calib time: "<<calibSP->time()<<" cov " <<toString(calibSP->covariance()));
                break;
           }
           case xAOD::UncalibMeasType::TgcStripType: {
                calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos), std::move(chDir));
                calibSP->setCovariance<2>(spacePoint->covariance());
                break;
           }
           case xAOD::UncalibMeasType::MMClusterType: {
                const xAOD::MMCluster* cluster = static_cast<const xAOD::MMCluster*>(spacePoint->primaryMeasurement());
 
                std::vector<NSWCalib::CalibratedStrip> calibClus;
                StatusCode sc =  m_nswCalibTool->calibrateClus(ctx, *gctx, cluster, locToGlob * posInChamb, calibClus);
                if(sc.isFailure()) {
                    ATH_MSG_WARNING("Failed to calibrate MM cluster "<<m_idHelperSvc->toString(cluster->identify()));
                    return nullptr;
                }
 
                Amg::Vector2D locPos{cluster->localPosition<1>()[0] * Amg::Vector2D::UnitX()};
                Amg::MatrixX loce = spacePoint->covariance();
 
                Amg::Vector3D globalTrackDir{locToGlob.linear() * dirInChamb};
                Amg::Vector3D locDir = Muon::NswClustering::toLocal(cluster->readoutElement()->globalToLocalTrans(*gctx, cluster->layerHash()), globalTrackDir);
 
                Muon::IMMClusterBuilderTool::RIO_Author rotAuthor = m_clusterBuilderToolMM->getCalibratedClusterPosition(ctx, calibClus, locDir ,locPos, loce);
                if(rotAuthor == Muon::IMMClusterBuilderTool::RIO_Author::unKnownAuthor){
                    ATH_MSG_ERROR("Failed to calibrate MM cluster "<<m_idHelperSvc->toString(cluster->identify()));
                    return nullptr;
                }
 
                Amg::Transform3D toChamberTrans{ locToGlob.inverse() * cluster->readoutElement()->localToGlobalTrans(*gctx, cluster->layerHash())};
 
                Amg::Vector3D calibSpPosInLayer = toChamberTrans.inverse() * calibSpPos;
                calibSpPosInLayer.x() = locPos.x();
 
                calibSpPos = toChamberTrans * calibSpPosInLayer;
 
                calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos), std::move(chDir));
                calibSP->setCovariance<2>(spacePoint->covariance());
                ATH_MSG_DEBUG("calibrated MM cluster "<<m_idHelperSvc->toString(cluster->identify()) << " loc x old " << cluster->localPosition<1>()[0] << " new loc x " << locPos.x());
                                
                break;
           }
           default:
                ATH_MSG_WARNING("Do not know how to calibrate "<<m_idHelperSvc->toString(spacePoint->identify()));        
        }
        return calibSP;
    }

calibrate() [4/4]

CalibSpacePointVec MuonR4::SpacePointCalibrator::calibrate ( const EventContext &  ctx, const std::vector< const SpacePoint * > &  spacePoints, const Amg::Vector3D &  seedPosInChamb, const Amg::Vector3D &  seedDirInChamb, const double  timeDelay  ) const

finaloverride

Definition at line 256 of file SpacePointCalibrator.cxx.

                                                                                      {
        CalibSpacePointVec calibSpacePoints{};
        calibSpacePoints.reserve(spacePoints.size());
        for(const SpacePoint* spacePoint : spacePoints) {
            CalibSpacePointPtr hit = calibrate(ctx, spacePoint, posInChamb, dirInChamb, timeOffset);
            if (hit) calibSpacePoints.push_back(std::move(hit));
        }
        return calibSpacePoints;
    }

calibrateSourceLink()

void MuonR4::SpacePointCalibrator::calibrateSourceLink ( const Acts::GeometryContext &  geoctx, const Acts::CalibrationContext &  cctx, const Acts::SourceLink &  link, ActsTrk::MutableTrackContainer::TrackStateProxy  state  ) const

finaloverride

Construct bound track parameters to fetch the global track position

Vast majority of the measurements are ordinary drift tubes

Invalid drift radius has been created

Twin tube case

Legacy BM / BO chambers

BI clusters

Definition at line 288 of file SpacePointCalibrator.cxx.

                                                                                                                 {
        
        const Acts::BoundTrackParameters trackPars{trackState.referenceSurface().getSharedPtr(), 
                                                   trackState.parameters(), trackState.covariance(), 
                                                   Acts::ParticleHypothesis::muon()};
        
        const Amg::Vector3D trackPos{trackPars.position(geoctx)};
        const Amg::Vector3D trackDir{trackPars.direction()};
        const ActsGeometryContext* gctx = geoctx.get<const ActsGeometryContext*>();
        const EventContext* ctx = cctx.get<const EventContext*>();
        const auto* muonMeas = ActsTrk::detail::xAODUncalibMeasCalibrator::unpack(link);
        ATH_MSG_VERBOSE("Calibrate measurement "<<m_idHelperSvc->toString(xAOD::identify(muonMeas))
                     <<" @ surface "<<trackState.referenceSurface().geometryId());
        switch (muonMeas->type()){
            using enum xAOD::UncalibMeasType;
            case MdtDriftCircleType: {
                const auto* dc = static_cast<const xAOD::MdtDriftCircle*>(muonMeas);
                MdtCalibInput calibInput{*dc, *gctx};
                calibInput.setClosestApproach(trackPos);
                //calibInput.setTimeOfFlight(trackPars.parameters()[Acts::eBoundTime]);
                calibInput.setTrackDirection(trackDir, true);
                const double driftSign = sign(trackPars.parameters()[Acts::eBoundLoc0]);
 
                if (ATH_LIKELY(muonMeas->numDimensions() == 1)) {
                    MdtCalibOutput calibOutput = m_mdtCalibrationTool->calibrate(*ctx, calibInput);
                    ATH_MSG_VERBOSE("Returned calibration object "<<calibOutput);
                    AmgVector(1) pos{AmgVector(1)::Zero()};
                    AmgSymMatrix(1) cov{AmgSymMatrix(1)::Identity()};
                    if (calibOutput.status() != Muon::MdtDriftCircleStatus::MdtStatusDriftTime) {
                        ATH_MSG_DEBUG("Failed to create a valid hit from "<<m_idHelperSvc->toString(dc->identify())
                                        <<std::endl<<calibInput<<std::endl<<calibOutput);
                        cov(Acts::eBoundLoc0,Acts::eBoundLoc0) = std::pow(dc->readoutElement()->innerTubeRadius(), 2);
                    } else {
                        pos[Acts::eBoundLoc0] = driftSign*calibOutput.driftRadius();
                        cov(Acts::eBoundLoc0, Acts::eBoundLoc0) = std::pow(calibOutput.driftRadiusUncert(), 2);
                    }
                    setState<1, ActsTrk::MutableTrackStateBackend>(ProjectorType::e1DimNoTime, pos, cov, link, trackState);
                } 
                else {
                    const auto* twinDC = static_cast<const xAOD::MdtTwinDriftCircle*>(muonMeas);
                    MdtCalibInput twinInput{twinDC->twinIdentify(), twinDC->twinAdc(),  twinDC->twinTdc(), twinDC->readoutElement(), *gctx};
                    twinInput.setClosestApproach(trackPos);
                    twinInput.setTimeOfFlight(trackPars.parameters()[Acts::eBoundTime]);
 
                    MdtCalibTwinOutput calibOutput = m_mdtCalibrationTool->calibrateTwinTubes(*ctx,
                                                                                              std::move(calibInput),
                                                                                              std::move(twinInput)); 
                    Amg::Vector2D locPos{Amg::Vector2D::Zero()};
                    AmgSymMatrix(2) locCov{AmgSymMatrix(2)::Identity()};
                    if (calibOutput.primaryStatus() != Muon::MdtDriftCircleStatus::MdtStatusDriftTime) {
                        ATH_MSG_DEBUG("Failed to create a valid hit from "<<m_idHelperSvc->toString(dc->identify())
                                     <<std::endl<<calibOutput);
                        locCov(Acts::eBoundLoc0, Acts::eBoundLoc0) = std::pow(dc->readoutElement()->innerTubeRadius(), 2);
                        locCov(Acts::eBoundLoc1, Acts::eBoundLoc1) = std::pow(0.5* dc->readoutElement()->activeTubeLength(dc->measurementHash()), 2);
                    } else {
                        locCov(Acts::eBoundLoc0, Acts::eBoundLoc0) = std::pow(calibOutput.uncertPrimaryR(), 2);
                        locCov(Acts::eBoundLoc1, Acts::eBoundLoc1) = std::pow(calibOutput.sigmaZ(), 2);
                        locPos[Acts::eBoundLoc0] = driftSign*calibOutput.primaryDriftR();
                        locPos[Acts::eBoundLoc1] = calibOutput.locZ();
                    }
                    setState<2, ActsTrk::MutableTrackStateBackend>(ProjectorType::e2DimNoTime, locPos, locCov, link, trackState);
                }
                break;
            } case RpcStripType: {
                const auto* rpcClust = static_cast<const xAOD::RpcMeasurement*>(muonMeas);
                if (ATH_LIKELY(rpcClust->numDimensions() == 1)) {
                    if (!m_useRpcTime) {
                        setState<1, ActsTrk::MutableTrackStateBackend>(ProjectorType::e1DimNoTime, 
                                                                       rpcClust->localPosition<1>(), 
                                                                       rpcClust->localCovariance<1>(), link, trackState);
                    } else {
                        AmgVector(2) measPars{AmgVector(2)::Zero()};
                        AmgSymMatrix(2) measCov{AmgSymMatrix(2)::Identity()};
                        measPars[0] = rpcClust->localPosition<1>()[0];
                        measCov(0,0) = rpcClust->localCovariance<1>()(0, 0);
                        measCov(1,1) = std::pow(m_rpcTimeResolution, 2);
                        setState<2, ActsTrk::MutableTrackStateBackend>(ProjectorType::e1DimWithTime, 
                                                                       measPars, measCov, link, trackState);
                    }
                } 
                else {
                    if (!m_useRpcTime) {
                        setState<2, ActsTrk::MutableTrackStateBackend>(ProjectorType::e1DimNoTime, 
                                                                       rpcClust->localPosition<2>(), 
                                                                       rpcClust->localCovariance<2>(), link, trackState);
                    } else {
                        AmgVector(3) measPars{AmgVector(3)::Zero()};
                        AmgSymMatrix(3) measCov{AmgSymMatrix(3)::Identity()};
                        measPars.block<2,1>(0,0) = xAOD::toEigen(rpcClust->localPosition<2>());
                        measCov.block<2,2>(0,0) = xAOD::toEigen(rpcClust->localCovariance<2>());
                        measCov(2,2) = std::pow(m_rpcTimeResolution, 2);
                        setState<3, ActsTrk::MutableTrackStateBackend>(ProjectorType::e2DimWithTime, 
                                                                       measPars, measCov, link, trackState);
                    }
                }
                break;
            } case TgcStripType: {
                if (!m_useTgcTime) {
                    setState<1, ActsTrk::MutableTrackStateBackend>(ProjectorType::e1DimRotNoTime, 
                                                                   muonMeas->localPosition<1>(), 
                                                                   muonMeas->localCovariance<1>(), link, trackState);
                    } else {
                        ATH_MSG_WARNING("Tgc time calibration to be implemented...");
                    }
                break;
            } 
            case MMClusterType: {
                THROW_EXCEPTION("Micromega measurements are not yet implemented");
                break;
            } case sTgcStripType: {
                THROW_EXCEPTION("sTGC measurements are not yet implemented");
                break;
            } default: {
                THROW_EXCEPTION("The parsed measurement is not a muon measurement. Please check.");
            }
 
        }
 
    }

driftAcceleration()

double MuonR4::SpacePointCalibrator::driftAcceleration ( const EventContext &  ctx, const CalibratedSpacePoint &  spacePoint  ) const

finaloverride

Definition at line 278 of file SpacePointCalibrator.cxx.

                                                                                                  {
        if(spacePoint.type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
            const MuonCalib::MdtFullCalibData* calibConsts = m_mdtCalibrationTool->getCalibConstants(ctx, spacePoint.spacePoint()->identify());
            const std::optional<double> driftTime = calibConsts->rtRelation->tr()->driftTime(spacePoint.driftRadius());
            return calibConsts->rtRelation->rt()->driftAcceleration(driftTime.value_or(0.));
        }
        return 0.;
    }

driftVelocity()

double MuonR4::SpacePointCalibrator::driftVelocity ( const EventContext &  ctx, const CalibratedSpacePoint &  spacePoint  ) const

finaloverride

Definition at line 269 of file SpacePointCalibrator.cxx.

                                                                                             {
        if(spacePoint.type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
            const MuonCalib::MdtFullCalibData* calibConsts = m_mdtCalibrationTool->getCalibConstants(ctx, spacePoint.spacePoint()->identify());
            const std::optional<double> driftTime = calibConsts->rtRelation->tr()->driftTime(spacePoint.driftRadius());
            return calibConsts->rtRelation->rt()->driftVelocity(driftTime.value_or(0.));
        }
        return 0.;
    }

initialize()

StatusCode MuonR4::SpacePointCalibrator::initialize ( )

finaloverride

Definition at line 36 of file SpacePointCalibrator.cxx.

                                                {
        ATH_CHECK(m_geoCtxKey.initialize());
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_mdtCalibrationTool.retrieve(EnableTool{m_idHelperSvc->hasMDT()}));
        ATH_CHECK(m_nswCalibTool.retrieve(EnableTool{m_idHelperSvc->hasMM() || m_idHelperSvc->hasSTGC()}));
        ATH_CHECK(detStore()->retrieve(m_detMgr));
        return StatusCode::SUCCESS;
    }

setState()

template<std::size_t Dim, typename trajectory_t , typename pos_t , typename cov_t >

void ActsTrk::detail::MeasurementCalibratorBase::setState ( const ProjectorType  projector, const pos_t &  locpos, const cov_t &  cov, Acts::SourceLink  link, TrackState_t< trajectory_t > &  trackState  ) const

inherited

Copy the local position & covariance into the Acts track state proxy.

Template Parameters

Dim	Dimension of the measurement
trajectory_t	Data type of the track state proxy backend
pos_t	Data type of the [Dim x 1] position vector
cov_t	Data type of the [Dim x Dim] covariance matrix

Parameters

projector	Projector configuration of the measurement
locpos	Calibrated local postion
cov	Calibrated local covariance
link	Source link to associate with the state
trackState	Refrence to the track state proxy to write.

Member Data Documentation

m_clusterBuilderToolMM

ToolHandle<Muon::IMMClusterBuilderTool> MuonR4::SpacePointCalibrator::m_clusterBuilderToolMM {this, "MMClusterBuilder", ""}

private

Definition at line 79 of file SpacePointCalibrator.h.

m_detMgr

const MuonGMR4::MuonDetectorManager* MuonR4::SpacePointCalibrator::m_detMgr {nullptr}

private

Definition at line 81 of file SpacePointCalibrator.h.

m_geoCtxKey

SG::ReadHandleKey<ActsGeometryContext> MuonR4::SpacePointCalibrator::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}

private

access to the ACTS geometry context

Definition at line 71 of file SpacePointCalibrator.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonR4::SpacePointCalibrator::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 73 of file SpacePointCalibrator.h.

m_mdtCalibrationTool

ToolHandle<IMdtCalibrationTool> MuonR4::SpacePointCalibrator::m_mdtCalibrationTool {this, "MdtCalibrationTool", ""}

private

Definition at line 75 of file SpacePointCalibrator.h.

m_muonPropSpeed

Gaudi::Property<double> MuonR4::SpacePointCalibrator::m_muonPropSpeed {this, "PropagationSpeed", 1./ Gaudi::Units::c_light }

private

Assumed propagation velocity of the muon through the detector.

Needs to be replaced by the proper time estimate once the calibrator is exposed to the Acts propagator

Definition at line 86 of file SpacePointCalibrator.h.

m_nswCalibTool

ToolHandle<Muon::INSWCalibTool> MuonR4::SpacePointCalibrator::m_nswCalibTool {this, "NSWCalibTool", ""}

private

Definition at line 77 of file SpacePointCalibrator.h.

m_rpcSignalVelocity

Gaudi::Property<double> MuonR4::SpacePointCalibrator::m_rpcSignalVelocity

private

Initial value:

{this, "rpcSignalVelocity", 0.5 * Gaudi::Units::c_light,
                                                         "Propagation speed of the signal inside the rpc strip"}

How fast does an electron signal travel along an rpc strip

Definition at line 89 of file SpacePointCalibrator.h.

m_rpcTimeResolution

Gaudi::Property<double> MuonR4::SpacePointCalibrator::m_rpcTimeResolution

private

Initial value:

{this, "rpcTimeResolution", 0.6 * Gaudi::Units::nanosecond,
                                                          "Estimated time resolution of the strip readout"}

Definition at line 92 of file SpacePointCalibrator.h.

m_useRpcTime

Gaudi::Property<bool> MuonR4::SpacePointCalibrator::m_useRpcTime {this, "useRpcTime", false}

private

Load the Rpc time on the track states for the track fit.

Definition at line 96 of file SpacePointCalibrator.h.

m_useTgcTime

Gaudi::Property<bool> MuonR4::SpacePointCalibrator::m_useTgcTime

private

Initial value:

{this, "useTgcTime", false,
                                               "Load the Tgc BC-ID on the track states for the fit"}

Load the Tgc bunch crossing ID on the track states.

Definition at line 98 of file SpacePointCalibrator.h.

s_boundSpaceIndices

constexpr static std::array<Acts::BoundSubspaceIndices, 6> ActsTrk::detail::MeasurementCalibratorBase::s_boundSpaceIndices

staticconstexprprivateinherited

Initial value:

{
        Acts::BoundSubspaceIndices{Acts::eBoundLoc0}, 
        Acts::BoundSubspaceIndices{Acts::eBoundLoc1}, 
        Acts::BoundSubspaceIndices{Acts::eBoundLoc0, Acts::eBoundLoc1}, 
        Acts::BoundSubspaceIndices{Acts::eBoundLoc0, Acts::eBoundTime}, 
        Acts::BoundSubspaceIndices{Acts::eBoundLoc1, Acts::eBoundTime}, 
        Acts::BoundSubspaceIndices{Acts::eBoundLoc0, Acts::eBoundLoc1, Acts::eBoundTime} 
    }

Array to map the Projector types to the bound index configurations used by the ATLAS detector measurements.

Definition at line 66 of file MeasurementCalibratorBase.h.

---

The documentation for this class was generated from the following files:

• SpacePointCalibrator.h
• SpacePointCalibrator.cxx