MuonR4::SpacePointCalibrator Class Reference

#include <SpacePointCalibrator.h>

Inheritance diagram for MuonR4::SpacePointCalibrator:

Collaboration diagram for MuonR4::SpacePointCalibrator:

Public Member Functions
	SpacePointCalibrator (const std::string &type, const std::string &name, const IInterface *parent)
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

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", ""}
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< double >	m_mdtErrorScale {this, "mdtErrorScaleFactor", 1.0, "Scaling to apply to MDT errors for the pattern"}
Gaudi::Property< bool >	m_doMdtUncertFromProp {this, "MdtPropagationTimeUncert", false}

Detailed Description

Definition at line 24 of file SpacePointCalibrator.h.

Constructor & Destructor Documentation

SpacePointCalibrator()

MuonR4::SpacePointCalibrator::SpacePointCalibrator	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 28 of file SpacePointCalibrator.cxx.

                                                                                                                     :
            base_class(type, name, parent) {}

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 56 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 39 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 67 of file SpacePointCalibrator.cxx.

                                                                                      {
        
        SG::ReadHandle gctx{m_geoCtxKey, ctx};
        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);
                    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);
                    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 {
                        double uncert = calibOutput.driftRadiusUncert();
                        if(m_doMdtUncertFromProp) {
                            uncert = std::hypot(uncert, calibOutput.driftUncertSigProp());
                        }
                        diagCov(toInt(AxisDefs::phi), toInt(AxisDefs::phi)) = std::pow(m_mdtErrorScale * uncert, 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(m_mdtErrorScale * 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;
           }
           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 214 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;
    }

driftVelocity()

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

finaloverride

Definition at line 227 of file SpacePointCalibrator.cxx.

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

initialize()

StatusCode MuonR4::SpacePointCalibrator::initialize ( )

finaloverride

Definition at line 31 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(detStore()->retrieve(m_detMgr));
        return StatusCode::SUCCESS;
    }

Member Data Documentation

m_detMgr

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

private

Definition at line 67 of file SpacePointCalibrator.h.

m_doMdtUncertFromProp

Gaudi::Property<bool> MuonR4::SpacePointCalibrator::m_doMdtUncertFromProp {this, "MdtPropagationTimeUncert", false}

private

Definition at line 83 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 61 of file SpacePointCalibrator.h.

m_idHelperSvc

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

private

Definition at line 63 of file SpacePointCalibrator.h.

m_mdtCalibrationTool

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

private

Definition at line 65 of file SpacePointCalibrator.h.

m_mdtErrorScale

Gaudi::Property<double> MuonR4::SpacePointCalibrator::m_mdtErrorScale {this, "mdtErrorScaleFactor", 1.0, "Scaling to apply to MDT errors for the pattern"}

private

Definition at line 81 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 72 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 75 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 78 of file SpacePointCalibrator.h.

---

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

• SpacePointCalibrator.h
• SpacePointCalibrator.cxx