MuonR4::SpacePointCalibrator Class Reference

#include <SpacePointCalibrator.h>

Inheritance diagram for MuonR4::SpacePointCalibrator:

Collaboration diagram for MuonR4::SpacePointCalibrator:

Public Types
enum class	ProjectorType {   e1DimNoTime = 0 , e1DimRotNoTime = 1 , e2DimNoTime = 2 , e1DimWithTime = 3 ,   e1DimRotWithTime = 4 , e2DimWithTime = 5 }
	Enum encoding the possible projectors used in ATLAS. More...
using	SourceLink_t
	Encode the source links supported by the Calibrator class as a variant of the measurement class type pointer used within Athena.

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 Acts::CalibrationContext &ctx, const Amg::Vector3D &seedPosInChamb, const Amg::Vector3D &seedDirInChamb, const double timeDelay, const CalibSpacePointVec &spacePoints) const override final
void	updateSigns (const Amg::Vector3D &trackPos, const Amg::Vector3D &trackDir, CalibSpacePointVec &hitsToCalib) const override final
double	driftVelocity (const Acts::CalibrationContext &ctx, const CalibratedSpacePoint &spacePoint) const override final
double	driftAcceleration (const Acts::CalibrationContext &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
void	stampSignsOnMeasurements (const xAOD::MuonSegment &segment) const override final
double	driftRadius (const Acts::CalibrationContext &cctx, const CalibratedSpacePoint &spacePoint, const double timeDelay) const override final
double	driftVelocity (const Acts::CalibrationContext &cctx, const CalibratedSpacePoint &spacePoint, const double timeDelay) const override final
double	driftAcceleration (const Acts::CalibrationContext &cctx, const CalibratedSpacePoint &spacePoint, const double timeDelay) const override final
template<std::size_t Dim, Acts::TrackStateProxyConcept proxy_t, typename pos_t, typename cov_t>
void	setState (const ProjectorType projector, const pos_t &locpos, const cov_t &cov, Acts::SourceLink link, proxy_t &trackState) const
	Copy the local position & covariance into the Acts track state proxy.

Static Public Member Functions
static SourceLinkType	getType (const Acts::SourceLink &sl)
	Returns the enumeration corresponding to the object type cached within the Acts::SourceLink.
static SourceLink_t	unpackBase (const Acts::SourceLink &sl)
	Unpack the SourceLink_t from the passed Acts source link.
template<Acts::PointerConcept Ptr_t>
static Acts::SourceLink	pack (const Ptr_t &measurement)
	Pack the measurement type pointer to an Acts::SourceLink including the intermediate conversion into a SourceLink_t.
template<Acts::PointerConcept Ptr_t>
static void	pack (const std::vector< Ptr_t > &measList, std::vector< Acts::SourceLink > &targetSL)
	Converts a vector measurement pointers to Acts::SourceLinks.

Protected Member Functions
template<std::size_t Dim, Acts::TrackStateProxyConcept proxy_t>
void	prepareCalibratedState (const ProjectorType projector, Acts::SourceLink link, proxy_t &trackState) const
	Queries the track proxy to allocate memory for the incoming calibration object.

Private Member Functions
void	calibrateCombinedPrd (const EventContext &ctx, const ActsTrk::GeometryContext &gctx, const xAOD::CombinedMuonStrip *combinedPrd, ActsTrk::MutableTrackContainer::TrackStateProxy state) const
	Calibrates the track states from a combined muon strip.
std::pair< double, double >	calibrateMM (const EventContext &ctx, const ActsTrk::GeometryContext &gctx, const xAOD::MMCluster &cluster, const Amg::Vector3D &globalPos, const Amg::Vector3D &globalDir) const
	Calibrates the position and covariance of a MicroMegas (MM) cluster.
std::pair< double, double >	calibratesTGC (const EventContext &ctx, const ActsTrk::GeometryContext &gctx, const xAOD::sTgcStripCluster &cluster, std::optional< double > posAlongTheStrip, const Amg::Vector3D &globalPos, const Amg::Vector3D &globalDir) const
	Calibrates the position and covariance of an sTGC (small-strip Thin Gap Chamber) cluster.

Private Attributes
ActsTrk::GeoContextReadKey_t	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
	access to the ACTS geometry context
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.
Gaudi::Property< double >	m_rpcSignalVelocity
	How fast does an electron signal travel along an rpc strip.
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.
Gaudi::Property< bool >	m_useTgcTime
	Load the Tgc bunch crossing ID on the track states.
Gaudi::Property< bool >	m_usesTgcTime
Gaudi::Property< bool >	m_MdtSignFromSegment

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

Detailed Description

Definition at line 30 of file SpacePointCalibrator.h.

Member Typedef Documentation

SourceLink_t

using ActsTrk::detail::MeasurementCalibratorBase::SourceLink_t

inherited

Initial value:

std::variant<std::monostate,
                                     const xAOD::UncalibratedMeasurement*,
                                     const Trk::PrepRawData*,
                                     const Trk::MeasurementBase*>

Encode the source links supported by the Calibrator class as a variant of the measurement class type pointer used within Athena.

The std::monostate is used to encode nullptrs or not yet supported types

Definition at line 53 of file MeasurementCalibratorBase.h.

Member Enumeration Documentation

ProjectorType

enum class 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 41 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 Acts::CalibrationContext & ctx, const Amg::Vector3D & seedPosInChamb, const Amg::Vector3D & seedDirInChamb, const double timeDelay, const CalibSpacePointVec & spacePoints ) const

finaloverride

Definition at line 88 of file SpacePointCalibrator.cxx.

                                                                                                    {
        CalibSpacePointVec newCalib{};
        const EventContext* ctx = cctx.get<const EventContext*>();
        newCalib.reserve(spacePoints.size());
        for (const CalibSpacePointPtr& sp : spacePoints){
            newCalib.emplace_back(calibrate(*ctx, *sp, segPos, segDir, timeDelay));
        }
        return newCalib;
    }

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 69 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);
        } else if (spacePoint.fitState() == State::Duplicate) {
            calibSP->setFitState(State::Duplicate);
        }
        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

Set time measurement used by the fast fitter, corrected by the tube T0 and a fast estimate of the time of flight

Set time measurement used by the fast fitter, corrected by the tube T0 and a fast estimate of the time of flight

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

Update the covariance of the strip measurements along the strip

Definition at line 102 of file SpacePointCalibrator.cxx.

                                                                                     {
        const ActsTrk::GeometryContext* gctx{nullptr};
        if (!SG::get(gctx, m_geoCtxKey, ctx).isSuccess()) {
            return CalibSpacePointPtr{};
        }
        const Amg::Vector3D& spPos{spacePoint->localPosition()};
        const Amg::Transform3D& locToGlob{spacePoint->msSector()->localToGlobalTransform(*gctx)};
        const Amg::Vector3D& chDir{spacePoint->sensorDirection()};
 
        // 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;               
 
        SpacePoint::Cov_t cov = spacePoint->covariance();
        CalibSpacePointPtr calibSP{};
        ATH_MSG_VERBOSE("Calibrate "<<(*spacePoint) <<" -> updated pos "<<Amg::toString(calibSpPos));
        switch (spacePoint->type()) {
           using enum xAOD::UncalibMeasType;
           case 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  + ActsTrk::timeToAthena(timeDelay);
 
                if (ATH_LIKELY(spacePoint->dimension() == 1)) {
                    auto* dc = static_cast<const xAOD::MdtDriftCircle*>(spacePoint->primaryMeasurement());
                    MdtCalibInput calibInput{*dc, *gctx};
                    calibInput.setTrackDirection(locToGlob.linear() * dirInChamb,
                                                 std::abs(dirInChamb.phi() - 90._degree) > 1.e-7 );
                    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};
                    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;
                        cov[Acts::toUnderlying(AxisDefs::etaCov)] = dc->readoutElement()->innerTubeRadius();
                    } else {
                        cov[Acts::toUnderlying(AxisDefs::etaCov)] = Acts::square(calibOutput.driftRadiusUncert());
                    }
                    calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos), fitState);
                    calibSP->setCovariance(cov);
                    calibSP->setDriftRadius(calibOutput.driftRadius());
                    double fastToF {(locToGlob * calibSP->localPosition()).norm() * c_inv};
                    calibSP->setTimeMeasurement(ActsTrk::timeToActs(dc->tdc() * IMdtCalibrationTool::tdcBinSize - 
                                                                    calibOutput.tubeT0() - fastToF - calibOutput.signalPropagationTime()));
                    ATH_MSG_VERBOSE("Mdt time Meas: " << ActsTrk::timeToAthena(calibSP->time()) 
                                  << ", ToF / fastToF: " << fastToF << " / " << closestApproach.mag() * c_inv
                                  << ", tubeT0: " << calibOutput.tubeT0() << ", Signal Prop Time: " << calibOutput.signalPropagationTime());
                } 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)); 
 
                    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);
                        cov[Acts::toUnderlying(AxisDefs::etaCov)] = Acts::square(dc->readoutElement()->innerTubeRadius());
                        cov[Acts::toUnderlying(AxisDefs::phiCov)] = Acts::square(0.5* dc->readoutElement()->activeTubeLength(dc->measurementHash()));
                        fitState = State::FailedCalib;
                    } else {
                        cov[Acts::toUnderlying(AxisDefs::etaCov)] = Acts::square(calibOutput.uncertPrimaryR());
                        cov[Acts::toUnderlying(AxisDefs::phiCov)] = Acts::square(calibOutput.sigmaZ());
                    }
                    calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos), fitState);
                    calibSP->setCovariance(cov);
                    calibSP->setDriftRadius(calibOutput.primaryDriftR());
                    double fastToF {(locToGlob * calibSP->localPosition()).norm() * c_inv};
                    double tubeT0 {m_mdtCalibrationTool->getCalibConstants(ctx, dc->identify())->tubeCalib->getCalib(dc->identify())->t0};
                    // Remember to add the signal propagation time!!
                    calibSP->setTimeMeasurement(ActsTrk::timeToActs(calibOutput.primaryTdc() * IMdtCalibrationTool::tdcBinSize - tubeT0 - fastToF));
                }
                break;
           }
           case RpcStripType: {
                auto* strip = static_cast<const xAOD::RpcMeasurement*>(spacePoint->primaryMeasurement());

                const Amg::Transform3D toGasGap{strip->readoutElement()->globalToLocalTransform(*gctx, strip->layerHash()) * locToGlob};
                const Amg::Vector3D lPos = toGasGap * calibSpPos;
                using EdgeSide = MuonGMR4::RpcReadoutElement::EdgeSide;
                calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos));
 
                // @TODO the constants could be converted to what is needed here (units, inverse) at initialization/construction time
                //       in particular 1/m_rpcSignalVelocity
                cov[Acts::toUnderlying(AxisDefs::timeCov)] = Acts::square(ActsTrk::timeToActs(m_rpcTimeResolution.value()));
 
                const double time1 = strip->time() 
                                   - strip->readoutElement()->distanceToEdge(strip->layerHash(), lPos,
                                                                             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(),lPos, EdgeSide::readOut)/m_rpcSignalVelocity;
                    calibSP->setTimeMeasurement(ActsTrk::timeToActs(0.5*(time1 + time2)));
                    cov[Acts::toUnderlying(AxisDefs::timeCov)] += Acts::square(ActsTrk::timeToActs(0.5*(time1 - time2)));
                } else {
                    calibSP->setTimeMeasurement(ActsTrk::timeToActs(time1));
                }
                calibSP->setCovariance(cov);
                ATH_MSG_VERBOSE("Create rpc space point "<<m_idHelperSvc->toString(strip->identify())<<", dimension "<<spacePoint->dimension()
                                << ", at "<<Amg::toString(calibSP->localPosition())<<", uncalib time: "
                                <<strip->time()<<", calib time: "<<ActsTrk::timeToAthena(calibSP->time())<<" cov " <<calibSP->covariance() 
                                <<", time Uncert: "<<ActsTrk::timeToAthena(std::sqrt(calibSP->covariance()[Acts::toUnderlying(AxisDefs::timeCov)])));
                break;
           }
           case TgcStripType: {
                calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos));
                if (spacePoint->primaryMeasurement()->measuresPhi()) {
                    const auto* strip = static_cast<const xAOD::TgcStrip*>(spacePoint->primaryMeasurement());
                    const Amg::Transform3D toGasGap{strip->readoutElement()->globalToLocalTransform(*gctx, strip->layerHash()) * locToGlob};
                    const Amg::Vector3D lPos = toGasGap * calibSP->localPosition();
                    const auto& sensorPlane = strip->readoutElement()->sensorLayout(strip->layerHash());
                    const auto& radialDesign = strip->readoutElement()->stripLayout(strip->layerHash());
                    cov[Acts::toUnderlying(AxisDefs::phiCov)] = Acts::square(
                        radialDesign.stripPitch(strip->channelNumber(), sensorPlane->to2D(lPos,true))) / 12.;
                }
                calibSP->setCovariance(cov);
                break;
           }
           case MMClusterType: {
                const xAOD::MMCluster* cluster = static_cast<const xAOD::MMCluster*>(spacePoint->primaryMeasurement());
                Amg::Vector3D globalPos{locToGlob * posInChamb};
                Amg::Vector3D globalDir{locToGlob.linear() * dirInChamb};
                
                std::pair<double, double> calibPosCov {calibrateMM(ctx, *gctx, *cluster, globalPos, globalDir)}; 
                
                ATH_MSG_DEBUG("Calibrated pos and cov" << calibPosCov.first << " " << calibPosCov.second);
                cov[Acts::toUnderlying(AxisDefs::etaCov)] = calibPosCov.second;
                Amg::Transform3D toChamberTrans{ locToGlob.inverse() * cluster->readoutElement()->localToGlobalTransform(*gctx, cluster->layerHash())};
 
                // since we want to take the second coordiante from the external estimate we need to transform the sp posiiton to the layer frame, replace the precission coordinate and transform back
                Amg::Vector3D calibSpPosInLayer = toChamberTrans.inverse() * calibSpPos;
                ATH_MSG_DEBUG("in layer before calibration" << Amg::toString(calibSpPosInLayer));
                calibSpPosInLayer.x() = calibPosCov.first;
                ATH_MSG_DEBUG("in layer after calibration" << Amg::toString(calibSpPosInLayer));
                calibSpPos = toChamberTrans * calibSpPosInLayer;
 
                calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos));
                calibSP->setCovariance(cov);
                ATH_MSG_DEBUG("calibrated MM cluster "<<m_idHelperSvc->toString(cluster->identify()) << " loc x old " << cluster->localPosition<1>()[0] << " new loc x " << calibSP->localPosition()[1]  << "cov " << calibSP->covariance());
                                
                break;
           }
           case sTgcStripType: {
                const auto* cluster = static_cast<const xAOD::sTgcMeasurement*>(spacePoint->primaryMeasurement());
 
                // We do not apply any correction for pads or wire only space points
                if (cluster->channelType() != sTgcIdHelper::sTgcChannelTypes::Strip) {
                    ATH_MSG_DEBUG("Calibrating an sTGC Pad or wire " << m_idHelperSvc->toString(cluster->identify()));
                    calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos));
                    calibSP->setCovariance(cov);
                    break;
                }
                
                std::optional<double> posAlongTheStrip{std::nullopt};
 
                // check if the space point is a strip/wire combination and take the position along the strip from the wire measurement
                if(spacePoint->secondaryMeasurement()) {
                    const auto* secMeas = static_cast<const xAOD::sTgcMeasurement*>(spacePoint->secondaryMeasurement());
                    ATH_MSG_VERBOSE("Using secondary measurement "<< m_idHelperSvc->toString(secMeas->identify())<<" for sTGC strip cluster " << m_idHelperSvc->toString(cluster->identify()));
                    // Extract scalar value - use 2D for pads (2 dimensions), 1D for wires (1 dimension)
                    if (secMeas->numDimensions() == 2) {
                        posAlongTheStrip = static_cast<double>(secMeas->localPosition<2>()[0]);
                    } else {
                        posAlongTheStrip = static_cast<double>(secMeas->localPosition<1>()[0]);
                    }
                } else {
                    ATH_MSG_VERBOSE("No secondary measurement for sTGC strip cluster " << m_idHelperSvc->toString(cluster->identify()));
                }
 
                Amg::Vector3D globalPos{locToGlob * posInChamb};
                Amg::Vector3D globalDir{locToGlob.linear() * dirInChamb};
                
                const auto* stripClus = static_cast<const xAOD::sTgcStripCluster*>(cluster);
                const auto [calibPos, calibCov] = calibratesTGC(ctx, *gctx, *stripClus, posAlongTheStrip, globalPos, globalDir); 
                
                ATH_MSG_DEBUG("Calibrated pos and cov" << calibPos << " " << calibCov);
                cov[Acts::toUnderlying(AxisDefs::etaCov)] = calibCov;
                Amg::Transform3D toChamberTrans{ locToGlob.inverse() * cluster->readoutElement()->localToGlobalTransform(*gctx, cluster->layerHash())};
 
                // since we want to take the second coordiante from the external estimate we need to transform the sp posiiton to the layer frame, replace the precission coordinate and transform back
                Amg::Vector3D calibSpPosInLayer = toChamberTrans.inverse() * calibSpPos;
                ATH_MSG_DEBUG("in layer before calibration" << Amg::toString(calibSpPosInLayer));
                calibSpPosInLayer.x() = calibPos;
                ATH_MSG_DEBUG("in layer after calibration" << Amg::toString(calibSpPosInLayer));
                calibSpPos = toChamberTrans * calibSpPosInLayer;
 
                calibSP = std::make_unique<CalibratedSpacePoint>(spacePoint, std::move(calibSpPos));
                calibSP->setCovariance(cov);
                ATH_MSG_DEBUG("calibrated sTGC cluster "<<m_idHelperSvc->toString(cluster->identify()) << " loc x old " << cluster->localPosition<1>()[0] << " new loc x " << calibSP->localPosition()[1]  << "cov " << calibSP->covariance());
                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 330 of file SpacePointCalibrator.cxx.

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

calibrateCombinedPrd()

void MuonR4::SpacePointCalibrator::calibrateCombinedPrd ( const EventContext & ctx, const ActsTrk::GeometryContext & gctx, const xAOD::CombinedMuonStrip * combinedPrd, ActsTrk::MutableTrackContainer::TrackStateProxy state ) const

private

Calibrates the track states from a combined muon strip.

It's a pseudo measurement composed out of two 1D strip measurements residing in the same gas gap (Relevant for Rpc/Tgc/sTgc)

Parameters

ctx	The event context providing the necessary conditions and event-specific information.
gctx	Pointer to the ActsTrk::GeometryContext, used for geometry-related transformations.
combinedPrd	Pointer to the measurement carrying the actual prds which are to be combined on the track state
state	The proxy to the actual track state to fill

Construct bound track parameters to fetch the global track position

Definition at line 410 of file SpacePointCalibrator.cxx.

                                                                                                             {
        const auto sl = ActsTrk::detail::xAODUncalibMeasCalibrator::pack(combinedPrd);
 
        Amg::Vector2D cmbPos = xAOD::toEigen(combinedPrd->localPosition<2>());
        AmgSymMatrix(2) cmbCov = xAOD::toEigen(combinedPrd->localCovariance<2>());
        if (combinedPrd->type() == xAOD::UncalibMeasType::RpcStripType) {
            if (m_useRpcTime) {
                ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Implement me");
            }
            setState<2>(ProjectorType::e2DimNoTime, cmbPos, cmbCov, sl, state);
     
        } else if (combinedPrd->type() == xAOD::UncalibMeasType::TgcStripType) {
            if (m_useTgcTime) {
                ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Implement me");
            }
 
            setState<2>(ProjectorType::e2DimNoTime, cmbPos, cmbCov, sl, state);
 
        } else if(combinedPrd->type() == xAOD::UncalibMeasType::sTgcStripType) {
            if (m_usesTgcTime) {
                ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Implement me");
            }
            // combined sTGC Space points can be strip/wire, strip/pad or pad/wire combinations.
            const auto* primMeas = static_cast<const xAOD::sTgcMeasurement*>(combinedPrd->primaryStrip());
 
            if(primMeas->channelType() == sTgcIdHelper::sTgcChannelTypes::Strip) {
                const auto* primStripMeas = static_cast<const xAOD::sTgcStripCluster*>(primMeas);
                const Acts::BoundTrackParameters trackPars{makeBoundPars(state)};
                std::pair<double, double> calibPosCov{calibratesTGC(ctx, gctx, *primStripMeas, cmbPos[1] , 
                                                                    trackPars.position(gctx.context()), 
                                                                    trackPars.direction())};
                cmbPos[0] = calibPosCov.first;
                cmbCov(0,0) = calibPosCov.second;
            }
            setState<2>(ProjectorType::e2DimNoTime, cmbPos, cmbCov, sl, state);
        
        } else {
            THROW_EXCEPTION("Undefined uncalibrated measurement "
                            <<m_idHelperSvc->toString(combinedPrd->identify()));
        }
    }

calibrateMM()

std::pair< double, double > MuonR4::SpacePointCalibrator::calibrateMM ( const EventContext & ctx, const ActsTrk::GeometryContext & gctx, const xAOD::MMCluster & cluster, const Amg::Vector3D & globalPos, const Amg::Vector3D & globalDir ) const

private

Calibrates the position and covariance of a MicroMegas (MM) cluster.

Parameters

ctx	The event context providing the necessary conditions and event-specific information.
gctx	Pointer to the ActsTrk::GeometryContext, used for geometry-related transformations.
cluster	Pointer to the xAOD::MMCluster representing the MicroMegas cluster to be calibrated.
globalPos	The global position from an external measurement.
globalDir	The global position from an external measurement.
calibLocPos	The calibrated local position of the cluster (output parameter).
calibLocCov	The calibrated local covariance of the cluster (output parameter).

Definition at line 365 of file SpacePointCalibrator.cxx.

                                                                                                    {
        std::vector<NSWCalib::CalibratedStrip> calibClus;
        StatusCode sc =  m_nswCalibTool->calibrateClus(ctx, gctx, cluster, globalPos, calibClus);
        if(sc.isFailure()) {
            ATH_MSG_WARNING("Failed to calibrate MM cluster "<<m_idHelperSvc->toString(cluster.identify()));
            return std::make_pair(0., 0.);
        }
 
        Amg::Vector2D locPos{cluster.localPosition<1>()[0] * Amg::Vector2D::UnitX()};
        Amg::Vector3D locDir = Muon::NswClustering::toLocal(cluster.readoutElement()->globalToLocalTransform(gctx, cluster.layerHash()), globalDir);
 
        Amg::MatrixX calibCov{};
        calibCov.resize(1,1);
        calibCov(0,0) = cluster.localCovariance<1>()(0, 0);
        ATH_MSG_DEBUG("old loc pos " << locPos[0] << " old cov" << calibCov(0,0)  );
 
        Muon::IMMClusterBuilderTool::RIO_Author rotAuthor = m_clusterBuilderToolMM->getCalibratedClusterPosition(ctx, calibClus, locDir ,locPos, calibCov);
        if(rotAuthor == Muon::IMMClusterBuilderTool::RIO_Author::unKnownAuthor){
            THROW_EXCEPTION("Failed to calibrate MM cluster "<<m_idHelperSvc->toString(cluster.identify()));
        }
        ATH_MSG_DEBUG("new loc pos " << locPos[0] << " new cov" << calibCov(0,0)  );
        return std::make_pair(locPos[0], calibCov(0,0));
    }

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

Only the combined muonstrip has zero dimensions

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 455 of file SpacePointCalibrator.cxx.

                                                                                                                 {
     
        const Acts::BoundTrackParameters trackPars{makeBoundPars(trackState)};
        
 
        const auto* muonMeas = ActsTrk::detail::xAODUncalibMeasCalibrator::unpack(link);
        const ActsTrk::GeometryContext* gctx = geoctx.get<const ActsTrk::GeometryContext*>();
        const EventContext* ctx = cctx.get<const EventContext*>();
        ATH_MSG_VERBOSE("Calibrate measurement "<<m_idHelperSvc->toString(xAOD::identify(muonMeas))
                        <<", smoothened: "<<trackState.hasSmoothed()<<", filtered: "<<trackState.hasFiltered()
                        <<", predicted: "<<trackState.hasPredicted()
                     <<" @\n"<<trackPars);
        if (muonMeas->numDimensions() == 0u) {
            calibrateCombinedPrd(*ctx, *gctx, static_cast<const xAOD::CombinedMuonStrip*>(muonMeas),
                                 trackState);
            return;
 
        }
        const Amg::Vector3D trackPos{trackPars.position(geoctx)};
        const Amg::Vector3D trackDir{trackPars.direction()};
 
        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 = m_MdtSignFromSegment ? 
                                         static_cast<double>(dec_trackSign(*dc)) :
                                         Acts::copySign(1.,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>(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>(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) {
                        const auto proj = rpcClust->measuresPhi() ? ProjectorType::e1DimRotNoTime
                                                                  : ProjectorType::e1DimNoTime;
                        setState<1>(proj,  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);
                        ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<"Please fix me using the ActsInterops package");
                        measCov(1,1) = std::pow(m_rpcTimeResolution, 2);
                        const auto proj = rpcClust->measuresPhi() ? ProjectorType::e1DimRotWithTime
                                                                  : ProjectorType::e1DimWithTime;
                        setState<2>(proj, measPars, measCov, link, trackState);
                    }
                } 
                else {
                    if (!m_useRpcTime) {
                        setState<2>(ProjectorType::e2DimNoTime, 
                                    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>());
                        ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<"Please fix me using the ActsInterops package");
                        measCov(2,2) = std::pow(m_rpcTimeResolution, 2);
                        setState<3>(ProjectorType::e2DimWithTime, measPars, measCov, link, trackState);
                    }
                }
                break;
            } case TgcStripType: {
                const auto* tgcClust = static_cast<const xAOD::TgcStrip*>(muonMeas);
                if (!m_useTgcTime) {
                    if (!tgcClust->measuresPhi()) {
                        setState<1>(ProjectorType::e1DimNoTime, 
                                    tgcClust->localPosition<1>(), 
                                    tgcClust->localCovariance<1>(), 
                                    link, trackState);
 
                    } else {
                        const auto [pos, cov] = xAOD::positionAndCovariance(tgcClust);
                        setState<2>(ProjectorType::e1DimRotNoTime, pos, cov, link, trackState);
 
                    }
                    } else {
                        ATH_MSG_WARNING("Tgc time calibration to be implemented...");
                    }
                break;
            } 
            case MMClusterType: {
                const auto* mmClust = static_cast<const xAOD::MMCluster*>(muonMeas);
                std::pair<double, double> calibPosCov{calibrateMM(*ctx,* gctx, *mmClust, trackPos, trackDir)};
                AmgVector(1) pos{AmgVector(1)(calibPosCov.first)};
                AmgSymMatrix(1) cov{AmgSymMatrix(1)(calibPosCov.second)};
 
                setState<1>(ProjectorType::e1DimNoTime, pos, cov, link, trackState);
                break;
            } case sTgcStripType: {
                const auto* stgcClust = static_cast<const xAOD::sTgcMeasurement*>(muonMeas);
 
                if(stgcClust->channelType() == sTgcIdHelper::sTgcChannelTypes::Wire) {
                        setState<1>(ProjectorType::e1DimNoTime, 
                                    muonMeas->localPosition<1>(), 
                                    muonMeas->localCovariance<1>(), link, trackState);
                } else if (stgcClust->channelType() == sTgcIdHelper::sTgcChannelTypes::Pad) {
                        setState<2>(ProjectorType::e2DimNoTime, 
                                    stgcClust->localPosition<2>(), 
                                    stgcClust->localCovariance<2>(), link, trackState);
                } else { // strips
                    const auto stgCluster = static_cast<const xAOD::sTgcStripCluster*>(muonMeas);
                    std::pair<double, double> calibPosCov{calibratesTGC(*ctx, *gctx, *stgCluster, std::nullopt, trackPos, trackDir)};
                    if(!m_usesTgcTime) {
                        AmgVector(1) pos{calibPosCov.first};
                        AmgSymMatrix(1) cov{calibPosCov.second};
                        setState<1>(ProjectorType::e1DimNoTime, pos, cov, link, trackState);
                    } else {
                        ATH_MSG_WARNING("sTGC time calibration to be implemented...");
                        AmgVector(2) pos{AmgVector(2)::Zero()};
                        AmgSymMatrix(2) cov{AmgSymMatrix(2)::Zero()};
                        pos[0] = calibPosCov.first;
                        pos[1] = stgCluster->time();
                        cov(0,0) = calibPosCov.second;
                        ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<"Please fix me using the ActsInterops package");
                        cov(1,1) = std::pow(25 /*ns*/, 2);
 
                        setState<2>(ProjectorType::e1DimWithTime, pos, cov, link, trackState);
                    }
                }
                break;
            } case Other: {
                ActsTrk::detail::xAODUncalibMeasCalibrator auxCalibrator{};
                auxCalibrator.calibrate(geoctx, cctx, link, trackState);
                break;
            } default: {
                THROW_EXCEPTION("The parsed measurement is not a muon measurement. Please check.");
            }
        }
    }

calibratesTGC()

std::pair< double, double > MuonR4::SpacePointCalibrator::calibratesTGC ( const EventContext & ctx, const ActsTrk::GeometryContext & gctx, const xAOD::sTgcStripCluster & cluster, std::optional< double > posAlongTheStrip, const Amg::Vector3D & globalPos, const Amg::Vector3D & globalDir ) const

private

Calibrates the position and covariance of an sTGC (small-strip Thin Gap Chamber) cluster.

Parameters

	ctx	The event context providing the necessary conditions for the calibration.
	gctx	Pointer to the ActsTrk::GeometryContext, which provides geometry-related information.
	cluster	Pointer to the sTGC strip cluster to be calibrated.
	posAlongTheStrip	The position along the strip obtained from the secondary measurement(wire), 0 if no wire measurement is present.
	globalPos	The global position from an external measurement.
	globalDir	The global direction from an external measurement.
[out]	calibLocPos	The calibrated local position of the cluster (output parameter).
[out]	calibLocCov	The calibrated local covariance of the cluster (output parameter).

Definition at line 393 of file SpacePointCalibrator.cxx.

                                                                                             {
 
        // if the second coordiante was not provided by the wire, take it from the seed track position 
        if(!posAlongTheStrip) {
            Amg::Vector3D extPosLocal =  cluster.readoutElement()->globalToLocalTransform(gctx, cluster.layerHash()) * globalPos;
            posAlongTheStrip = extPosLocal[1];
        }
 
        // For now just copying over the local position and covariance. Eventually this should apply corrections from B-Lines and as build geometry
        
        return std::make_pair(cluster.localPosition<1>()[0], cluster.localCovariance<1>()(0,0));
    }

driftAcceleration() [1/2]

double MuonR4::SpacePointCalibrator::driftAcceleration ( const Acts::CalibrationContext & cctx, const CalibratedSpacePoint & spacePoint, const double timeDelay ) const

finaloverride

Definition at line 675 of file SpacePointCalibrator.cxx.

                                                                                 {
        if(spacePoint.type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
            const MuonCalib::MdtFullCalibData* calibConsts = 
                    m_mdtCalibrationTool->getCalibConstants(*cctx.get<const EventContext*>(), spacePoint.spacePoint()->identify());
            return ActsTrk::accelerationToActs(calibConsts->rtRelation->rt()->driftAcceleration(ActsTrk::timeToAthena(spacePoint.time() - timeDelay)));
        }
        return 0.;                              
    }

driftAcceleration() [2/2]

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

finaloverride

Definition at line 355 of file SpacePointCalibrator.cxx.

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

driftRadius()

double MuonR4::SpacePointCalibrator::driftRadius ( const Acts::CalibrationContext & cctx, const CalibratedSpacePoint & spacePoint, const double timeDelay ) const

finaloverride

Definition at line 654 of file SpacePointCalibrator.cxx.

                                                                           {
        if(spacePoint.type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
            const MuonCalib::MdtFullCalibData* calibConsts = 
                    m_mdtCalibrationTool->getCalibConstants(*cctx.get<const EventContext*>(), spacePoint.spacePoint()->identify());
            return calibConsts->rtRelation->rt()->radius(ActsTrk::timeToAthena(spacePoint.time() - timeDelay));
        }
        return 0.;   
    }

driftVelocity() [1/2]

double MuonR4::SpacePointCalibrator::driftVelocity ( const Acts::CalibrationContext & cctx, const CalibratedSpacePoint & spacePoint, const double timeDelay ) const

finaloverride

Definition at line 665 of file SpacePointCalibrator.cxx.

                                                                             {
        if(spacePoint.type() == xAOD::UncalibMeasType::MdtDriftCircleType) {
            const MuonCalib::MdtFullCalibData* calibConsts = 
                    m_mdtCalibrationTool->getCalibConstants(*cctx.get<const EventContext*>(), spacePoint.spacePoint()->identify());
            return ActsTrk::velocityToActs(calibConsts->rtRelation->rt()->driftVelocity(ActsTrk::timeToAthena(spacePoint.time() - timeDelay)));
        }
        return 0.;  
    }

driftVelocity() [2/2]

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

finaloverride

Definition at line 345 of file SpacePointCalibrator.cxx.

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

getType()

SourceLinkType ActsTrk::detail::MeasurementCalibratorBase::getType ( const Acts::SourceLink & sl )

staticinherited

Returns the enumeration corresponding to the object type cached within the Acts::SourceLink.

The SourceLink must have been created by a MeasurementCalibrator to ensure that the underlying variant is cached. If the variant is a monostate, nTypes is returned

Parameters

sl	Reference to the source link to unpack.

initialize()

StatusCode MuonR4::SpacePointCalibrator::initialize ( )

finaloverride

Definition at line 51 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;
    }

pack() [1/2]

template<Acts::PointerConcept Ptr_t>

Acts::SourceLink ActsTrk::detail::MeasurementCalibratorBase::pack ( const Ptr_t & measurement )

staticinherited

Pack the measurement type pointer to an Acts::SourceLink including the intermediate conversion into a SourceLink_t.

Nullptrs are converted to a std::monostate.

Parameters

measurement

Pointer to the measurement to transform into a SourceLInk

pack() [2/2]

template<Acts::PointerConcept Ptr_t>

void ActsTrk::detail::MeasurementCalibratorBase::pack ( const std::vector< Ptr_t > & measList, std::vector< Acts::SourceLink > & targetSL )

staticinherited

Converts a vector measurement pointers to Acts::SourceLinks.

Parameters

measList	The list of measurement pointers for conversion
targetSL	The allocated SourceLink vectors to which the Acts::SourceLink objects are appended.

prepareCalibratedState()

template<std::size_t Dim, Acts::TrackStateProxyConcept proxy_t>

void ActsTrk::detail::MeasurementCalibratorBase::prepareCalibratedState ( const ProjectorType projector, Acts::SourceLink link, proxy_t & trackState ) const

protectedinherited

Queries the track proxy to allocate memory for the incoming calibration object.

Defines the projector indices and allocates the source link to the state

Parameters

projector	Projector configuration of the measurement
link	Source link to associate with the state
trackState	Refrence to the track state proxy to write.

setState()

template<std::size_t Dim, Acts::TrackStateProxyConcept proxy_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, proxy_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.

stampSignsOnMeasurements()

void MuonR4::SpacePointCalibrator::stampSignsOnMeasurements ( const xAOD::MuonSegment & segment ) const

finaloverride

Definition at line 643 of file SpacePointCalibrator.cxx.

                                                                                            {
        const auto [segPos, segLine] = makeLine(localSegmentPars(segment));
        const Segment* detSeg = MuonR4::detailedSegment(segment);
        for (const auto& meas : detSeg->measurements()) {
            if (meas->type() == xAOD::UncalibMeasType::MdtDriftCircleType){
                dec_trackSign(*meas->spacePoint()->primaryMeasurement()) =
                    SeedingAux::strawSign(segPos, segLine, *meas);
            }
        }
    }

unpackBase()

SourceLink_t ActsTrk::detail::MeasurementCalibratorBase::unpackBase ( const Acts::SourceLink & sl )

staticinherited

Unpack the SourceLink_t from the passed Acts source link.

Parameters

sl	Reference to the source link to unpack.

updateSigns()

void MuonR4::SpacePointCalibrator::updateSigns ( const Amg::Vector3D & trackPos, const Amg::Vector3D & trackDir, CalibSpacePointVec & hitsToCalib ) const

finaloverride

Definition at line 60 of file SpacePointCalibrator.cxx.

                                                                                  {
        std::vector<int> signs = SeedingAux::strawSigns(trackPos, trackDir,
                                                        hitsToCalib);
        for (const auto [spIdx, sp]: Acts::enumerate(hitsToCalib)) {
            sp->setDriftRadius(sp->driftRadius() * signs[spIdx]);
        }
    }

Member Data Documentation

m_clusterBuilderToolMM

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

private

Definition at line 144 of file SpacePointCalibrator.h.

{this, "MMClusterBuilder", ""};

m_detMgr

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

private

Definition at line 146 of file SpacePointCalibrator.h.

{nullptr};

m_geoCtxKey

ActsTrk::GeoContextReadKey_t MuonR4::SpacePointCalibrator::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}

private

access to the ACTS geometry context

Definition at line 136 of file SpacePointCalibrator.h.

{this, "AlignmentKey", "ActsAlignment", "cond handle key"}; 

m_idHelperSvc

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

private

Definition at line 138 of file SpacePointCalibrator.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_mdtCalibrationTool

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

private

Definition at line 140 of file SpacePointCalibrator.h.

{this, "MdtCalibrationTool", ""};

m_MdtSignFromSegment

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

private

Initial value:

{this, "useSegmentSigns", true,
                                    "Mdt drift signs are copied from the segment line instead from the track state"}

Definition at line 167 of file SpacePointCalibrator.h.

                                                    {this, "useSegmentSigns", true,
                                    "Mdt drift signs are copied from the segment line instead from the track state"};

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 151 of file SpacePointCalibrator.h.

{this, "PropagationSpeed", 1./ Gaudi::Units::c_light };

m_nswCalibTool

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

private

Definition at line 142 of file SpacePointCalibrator.h.

{this, "NSWCalibTool", ""};

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 154 of file SpacePointCalibrator.h.

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

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 157 of file SpacePointCalibrator.h.

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

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 161 of file SpacePointCalibrator.h.

{this, "useRpcTime", false};

m_usesTgcTime

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

private

Initial value:

{this, "usesTgcTime", false,
                                               "Load the sTgc time on the track states for the fit"}

Definition at line 165 of file SpacePointCalibrator.h.

                                             {this, "usesTgcTime", false,
                                               "Load the sTgc time on the track states for the fit"};

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 163 of file SpacePointCalibrator.h.

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

s_boundSpaceIndices

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 115 of file MeasurementCalibratorBase.h.

                                                                              {
        Acts::BoundSubspaceIndices{Acts::eBoundLoc0}, // One dimenion without time
        Acts::BoundSubspaceIndices{Acts::eBoundLoc1}, // Complementary one dimension without time
        Acts::BoundSubspaceIndices{Acts::eBoundLoc0, Acts::eBoundLoc1}, 
        Acts::BoundSubspaceIndices{Acts::eBoundLoc0, Acts::eBoundTime}, // One dimension with time
        Acts::BoundSubspaceIndices{Acts::eBoundLoc1, Acts::eBoundTime}, // Complementary one dimension with time
        Acts::BoundSubspaceIndices{Acts::eBoundLoc0, Acts::eBoundLoc1, Acts::eBoundTime} 
    };

---

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

• SpacePointCalibrator.h
• SpacePointCalibrator.cxx