Muon::MuonPatternCalibration Class Reference

#include <MuonPatternCalibration.h>

Inheritance diagram for Muon::MuonPatternCalibration:

Collaboration diagram for Muon::MuonPatternCalibration:

Classes
struct	EtaPhiHits
struct	Region

Public Types
using	ISPrd = std::pair< Amg::Vector3D, const MuonCluster * >
using	ISPrdVec = std::vector< ISPrd >
using	ISPrdMdt = std::pair< Amg::Vector3D, const MdtPrepData * >
using	ISPrdMdtVec = std::vector< ISPrdMdt >
using	RegionIdMap = std::map< int, ISPrdMdtVec >
using	RegionMap = std::map< int, Region >

Public Member Functions
	MuonPatternCalibration (const std::string &, const std::string &, const IInterface *)
virtual	~MuonPatternCalibration ()=default
virtual StatusCode	initialize () override
StatusCode	calibrate (const EventContext &ctx, const MuonPatternCombination &pat, ROTsPerRegion &hitsPerRegion) const override
int	getRegionId (const Identifier &id) const override
bool	checkForPhiMeasurements (const MuonPatternCombination &pat) const override

Private Member Functions
StatusCode	createRegionMap (const EventContext &ctx, const MuonPatternCombination &pat, RegionMap &regionMap, bool hasPhiMeasurements) const
void	printRegionMap (const RegionMap &regionMap) const
void	calibrateRegionMap (const RegionMap &regionMap, IMuonPatternCalibration::ROTsPerRegion &hitsPerRegion) const
void	insertCluster (const MuonCluster &mdt, RegionMap &regionMap, const Amg::Vector3D &patpose, const Amg::Vector3D &patdire, bool hasPhiMeasurements) const
void	insertMdt (const MdtPrepData &clus, RegionMap &regionMap, const Amg::Vector3D &patpose, const Amg::Vector3D &patdire, bool hasPhiMeasurements) const
template<class ContType >
StatusCode	loadFromStoreGate (const EventContext &ctx, const SG::ReadHandleKey< ContType > &key, const ContType *&cont_ptr) const
	load the container from storegate given a ReadHandleKey. More...

Private Attributes
ToolHandle< IMdtDriftCircleOnTrackCreator >	m_mdtCreator
ToolHandle< IMuonClusterOnTrackCreator >	m_clusterCreator
PublicToolHandle< MuonEDMPrinterTool >	m_printer
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
Gaudi::Property< bool >	m_doMultiAnalysis {this, "DoMultiChamberAnalysis", true}
Gaudi::Property< double >	m_dropDistance {this, "DropDistance", 1500.}
Gaudi::Property< double >	m_phiAngleCut {this, "AngleCutPhi", 1.e9}
Gaudi::Property< bool >	m_doSummary {this, "DoSummary", false}
Gaudi::Property< bool >	m_recoverTriggerHits {this, "RecoverTriggerHits", true}
Gaudi::Property< bool >	m_removeDoubleMdtHits {this, "RemoveDoubleMdtHits", true}
SG::ReadHandleKey< Muon::RpcPrepDataContainer >	m_keyRpc {this, "RpcPrepDataContainer","RPC_Measurements"}
SG::ReadHandleKey< Muon::TgcPrepDataContainer >	m_keyTgc {this, "TgcPrepDataContainer","TGC_Measurements"}

Detailed Description

Definition at line 30 of file MuonPatternCalibration.h.

Member Typedef Documentation

ISPrd

using Muon::MuonPatternCalibration::ISPrd = std::pair<Amg::Vector3D, const MuonCluster*>

Definition at line 32 of file MuonPatternCalibration.h.

ISPrdMdt

using Muon::MuonPatternCalibration::ISPrdMdt = std::pair<Amg::Vector3D, const MdtPrepData*>

Definition at line 35 of file MuonPatternCalibration.h.

ISPrdMdtVec

using Muon::MuonPatternCalibration::ISPrdMdtVec = std::vector<ISPrdMdt>

Definition at line 36 of file MuonPatternCalibration.h.

ISPrdVec

using Muon::MuonPatternCalibration::ISPrdVec = std::vector<ISPrd>

Definition at line 33 of file MuonPatternCalibration.h.

RegionIdMap

using Muon::MuonPatternCalibration::RegionIdMap = std::map<int, ISPrdMdtVec>

Definition at line 37 of file MuonPatternCalibration.h.

RegionMap

using Muon::MuonPatternCalibration::RegionMap = std::map<int, Region>

Definition at line 49 of file MuonPatternCalibration.h.

Constructor & Destructor Documentation

MuonPatternCalibration()

Muon::MuonPatternCalibration::MuonPatternCalibration	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 22 of file MuonPatternCalibration.cxx.

    : base_class(t, n, p) {}

~MuonPatternCalibration()

virtual Muon::MuonPatternCalibration::~MuonPatternCalibration ( )

virtualdefault

Member Function Documentation

calibrate()

StatusCode Muon::MuonPatternCalibration::calibrate ( const EventContext &  ctx, const MuonPatternCombination &  pat, ROTsPerRegion &  hitsPerRegion  ) const

override

Definition at line 40 of file MuonPatternCalibration.cxx.

                                                                                                                                               {
    Muon::MuonPatternCalibration::RegionMap regionMap;
    bool hasPhiMeasurements = checkForPhiMeasurements(pattern);
    ATH_CHECK(createRegionMap(ctx, pattern, regionMap, hasPhiMeasurements));
    // calibrate hits
    calibrateRegionMap(regionMap, hitsPerRegion);
    return StatusCode::SUCCESS;
}

calibrateRegionMap()

void Muon::MuonPatternCalibration::calibrateRegionMap ( const RegionMap &  regionMap, IMuonPatternCalibration::ROTsPerRegion &  hitsPerRegion  ) const

private

Definition at line 429 of file MuonPatternCalibration.cxx.

                                                                                                      {
 
    
    for (const auto& [regionId, regMeasColl] : regionMap) {
 
        ROTRegion rotRegion{};
        rotRegion.regionId  = regionId;
        rotRegion.regionPos = regMeasColl.regionPos;
        rotRegion.regionDir = regMeasColl.regionDir;
        for (const auto& [globalPos, prd] : regMeasColl.triggerPrds) {
            std::unique_ptr<const MuonClusterOnTrack> cluster{m_clusterCreator->createRIO_OnTrack(*prd, globalPos)};
            if (!cluster) continue;
            rotRegion.push_back(std::move(cluster));
        }
        for (const auto& [regionId, MdtsWithIsect] :regMeasColl.mdtPrdsPerChamber) {
            ATH_MSG_VERBOSE("Run over region id "<<regionId);
            MdtVec mdtROTs{};
            for (const auto& [globalPos, prd] : MdtsWithIsect) {  
                ATH_MSG_VERBOSE("Calibrate prd"<<m_idHelperSvc->toString(prd->identify())
                                <<",tdc: "<<prd->tdc()<<",adc: "<<prd->adc()<<" at "<<Amg::toString(globalPos));
                const MdtDriftCircleOnTrack* mdt = m_mdtCreator->createRIO_OnTrack(*prd, globalPos, &globalPos);
                if (!mdt) {
                    ATH_MSG_VERBOSE("Failed to calibrate " << m_idHelperSvc->toString(prd->identify()));
                    continue;
                }
                mdtROTs.push_back(mdt);
            }
            if (!mdtROTs.empty()) rotRegion.push_back(std::move(mdtROTs));
        }
        hitsPerRegion.push_back(std::move(rotRegion));
    }
}

checkForPhiMeasurements()

bool Muon::MuonPatternCalibration::checkForPhiMeasurements ( const MuonPatternCombination &  pat ) const

override

Exclude the sTGC hits. MM hits do not have phi measurements

Definition at line 59 of file MuonPatternCalibration.cxx.

                                                                                       {
 
    for (const  MuonPatternChamberIntersect& intersect : pat.chamberData()) {
        for (const Trk::PrepRawData* prd : intersect.prepRawDataVec()){
            const Identifier id = prd->identify();
            if (!m_idHelperSvc->issTgc(id) &&
                m_idHelperSvc->measuresPhi(id)) return true;
        }
    }
    return false;
}

createRegionMap()

StatusCode Muon::MuonPatternCalibration::createRegionMap ( const EventContext &  ctx, const MuonPatternCombination &  pat, RegionMap &  regionMap, bool  hasPhiMeasurements  ) const

private

Try to recover missing phi clusters:

• loop over the clusters in the region and sort them by collection
• count the number of eta and phi clusters per collection

Remove the NSW hits from the segment building

Definition at line 73 of file MuonPatternCalibration.cxx.

{
    if (hasPhiMeasurements)
        ATH_MSG_DEBUG("pattern has phi measurements using extrapolation to determine second coordinate");
    else
        ATH_MSG_DEBUG("No phi measurements using center tubes");
 
    
    const Muon::TgcPrepDataContainer* tgcPrdCont{nullptr};
    const Muon::RpcPrepDataContainer* rpcPrdCont{nullptr};
    ATH_CHECK(loadFromStoreGate(ctx, m_keyRpc, rpcPrdCont));
    ATH_CHECK(loadFromStoreGate(ctx, m_keyTgc, tgcPrdCont)); 
   
    for (const MuonPatternChamberIntersect& isect : pat.chamberData()) {
 
        if (isect.prepRawDataVec().empty()) continue;
 
        const Amg::Vector3D& patpose = isect.intersectPosition();
        const Amg::Vector3D  patdire = isect.intersectDirection().unit();
 
        std::map<int, EtaPhiHits> etaPhiHitsPerChamber;
        std::set<Identifier>      clusterIds;
 
 
        const Trk::PrepRawData* prd = isect.prepRawDataVec().front();
        const Identifier id = prd->identify();
 
        // apply cut on the opening angle between pattern and chamber phi
        // do some magic to avoid problems at phi = 0 and 2*pi
        double phiStart  = patdire.phi();
        double chPhi     = prd->detectorElement()->center().phi();
        constexpr double phiRange  = 0.75 * M_PI;
        constexpr double phiRange2 = 0.25 * M_PI;
        double phiOffset = 0.;
        if (phiStart > phiRange || phiStart < -phiRange)
            phiOffset = 2 * M_PI;
        else if (phiStart > -phiRange2 && phiStart < phiRange2)
            phiOffset = M_PI;
 
        if (phiOffset > 1.5 * M_PI) {
            if (phiStart < 0) phiStart += phiOffset;
            if (chPhi < 0) chPhi += phiOffset;
        } else if (phiOffset > 0.) {
            phiStart += phiOffset;
            chPhi += phiOffset;
        }
        double dphi = std::abs(phiStart - chPhi);
 
        if (dphi > m_phiAngleCut) {
            ATH_MSG_DEBUG("Large angular phi difference between pattern and chamber, phi pattern "
                          << patdire.phi() << "   phi chamber " << prd->detectorElement()->center().phi());
            continue;
        }
 
        // map to find duplicate hits in the chamber
        std::map<Identifier, const MdtPrepData*> idMdtMap{};
 
        for (const Trk::PrepRawData* isect_prd : isect.prepRawDataVec()) {
 
            if (isect_prd->type(Trk::PrepRawDataType::MdtPrepData)) {
                 const MdtPrepData* mdt = dynamic_cast<const MdtPrepData*>(isect_prd);           
                if (m_removeDoubleMdtHits) {
                    const MdtPrepData*& previousMdt = idMdtMap[mdt->identify()];
                    if (!previousMdt || previousMdt->tdc() > mdt->tdc())
                        previousMdt = mdt;
                    else
                        continue;
                }
                insertMdt(*mdt, regionMap, patpose, patdire, hasPhiMeasurements);
                continue;
            } 
            else if (isect_prd->type(Trk::PrepRawDataType::MMPrepData) || isect_prd->type(Trk::PrepRawDataType::sTgcPrepData)){
                continue;
            }   
            const MuonCluster* clus = dynamic_cast<const MuonCluster*>(isect_prd);
            if (!clus) continue;
            const Identifier id = clus->identify();
            if (!clusterIds.insert(id).second) continue;
            
            if (m_recoverTriggerHits) {
                bool measuresPhi = m_idHelperSvc->measuresPhi(id);
                int  colHash     = clus->collectionHash();
                EtaPhiHits& hitsPerChamber = etaPhiHitsPerChamber[colHash];
                if (measuresPhi)
                    ++hitsPerChamber.nphi;
                else
                    ++hitsPerChamber.neta;
            }
            insertCluster(*clus, regionMap, patpose, patdire, hasPhiMeasurements);            
        }
        for (const auto& [coll_hash, hits] : etaPhiHitsPerChamber) {
            if ((hits.neta > 0 && hits.nphi == 0) || (hits.nphi > 0 && hits.neta == 0)) {
                if (m_idHelperSvc->isRpc(id) && rpcPrdCont) {
 
                    const Muon::RpcPrepDataCollection* prd_coll = rpcPrdCont->indexFindPtr(coll_hash);
                    if (!prd_coll) {
                        ATH_MSG_VERBOSE("RpcPrepDataCollection not found in container!!"<< m_keyRpc);
                        continue;
                    }                   
                    for (const Muon::RpcPrepData* rpc_prd : *prd_coll) {
                        if (!clusterIds.insert(rpc_prd->identify()).second) continue;
                        insertCluster(*rpc_prd, regionMap, patpose, patdire, hasPhiMeasurements);
                    }                    
                } else if (m_idHelperSvc->isTgc(id) && tgcPrdCont) {
                     const Muon::TgcPrepDataCollection* prd_coll = tgcPrdCont->indexFindPtr(coll_hash);
                     if (!prd_coll) {
                        ATH_MSG_DEBUG("TgcPrepDataCollection not found in container!! "<< m_keyTgc);
                        continue;
                    }
                   
                    for (const Muon::TgcPrepData* tgc_prd : *prd_coll) {
                        if (!clusterIds.insert(tgc_prd->identify()).second) continue;
                        insertCluster(*tgc_prd, regionMap, patpose, patdire, hasPhiMeasurements);                        
                    }                    
                }
            }
        }
    }
    return StatusCode::SUCCESS;
}

getRegionId()

int Muon::MuonPatternCalibration::getRegionId ( const Identifier &  id ) const

override

Definition at line 50 of file MuonPatternCalibration.cxx.

                                                                 {
 
    // simple division of MuonSpectrometer in regions using barrel/endcap seperation plus
    // inner/middle/outer seperation
    return m_idHelperSvc->stationIndex(id)* (  m_idHelperSvc->stationEta(id) > 0 ? 1 : -1);
}

initialize()

StatusCode Muon::MuonPatternCalibration::initialize ( )

overridevirtual

Definition at line 26 of file MuonPatternCalibration.cxx.

{
    ATH_MSG_VERBOSE("MuonPatternCalibration::Initializing");
    ATH_CHECK(m_mdtCreator.retrieve());
    ATH_CHECK(m_printer.retrieve());
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_keyRpc.initialize(!m_keyRpc.empty()));
    ATH_CHECK(m_keyTgc.initialize(!m_keyTgc.empty()));
    ATH_CHECK(m_clusterCreator.retrieve(EnableTool{!m_keyRpc.empty() || !m_keyTgc.empty()}));
    return StatusCode::SUCCESS;
}

insertCluster()

void Muon::MuonPatternCalibration::insertCluster ( const MuonCluster &  mdt, RegionMap &  regionMap, const Amg::Vector3D &  patpose, const Amg::Vector3D &  patdire, bool  hasPhiMeasurements  ) const

private

Definition at line 201 of file MuonPatternCalibration.cxx.

{
 
    const Identifier id = clus.identify();
    // check whether we are measuring phi or eta
    const bool measuresPhi = m_idHelperSvc->measuresPhi(id);
 
    Amg::Vector3D globalpos = clus.globalPosition();
    Amg::Vector3D intersect{Amg::Vector3D::Zero()};
 
    if (hasPhiMeasurements) {
        // if there is a phi measurement in the pattern use the global direction to calculate the intersect with
        // measurement plane and use the intersect to calculate the position along the strip
 
        // calculate intersect pattern measurement plane
        const Trk::Surface& surf         = clus.detectorElement()->surface(id);
        Amg::Vector3D       planepostion = surf.center();
        Amg::Vector3D       planenormal  = surf.normal();
        double              denom        = patdire.dot(planenormal);
        double              u            = (planenormal.dot(planepostion - patpose)) / (denom);
        Amg::Vector3D       piOnPlane    = (patpose + u * patdire);
 
        // transform to local plane coordiantes
        const Amg::Transform3D gToLocal = clus.detectorElement()->surface().transform().inverse();
        Amg::Vector3D          ilpos    = gToLocal * piOnPlane;
        Amg::Vector3D          glpos    = gToLocal * globalpos;
 
        // strip length
        double striplen(0.);
 
        // projective strips
        bool hasPointingPhiStrips = false;
 
        // detector specific stuff
        const RpcPrepData* rpc = dynamic_cast<const RpcPrepData*>(&clus);
        if (rpc) {
            striplen = rpc->detectorElement()->StripLength(measuresPhi);
        } else {
            const TgcPrepData* tgc = dynamic_cast<const TgcPrepData*>(&clus);
            if (!tgc) return;
 
            int gasGap = m_idHelperSvc->tgcIdHelper().gasGap(id);
            if (measuresPhi) {
                hasPointingPhiStrips = true;
                striplen             = tgc->detectorElement()->stripLength();
            } else {
                int wire = m_idHelperSvc->tgcIdHelper().channel(id);
                striplen = tgc->detectorElement()->gangCentralWidth(gasGap, wire);
            }
        }
 
        // set the position along the strip
        if (!measuresPhi) {
            glpos[0] = ilpos.x();
        } else {
            if (hasPointingPhiStrips) {
                // do some special for tgcs
                glpos[1] = ilpos.y();
            } else {
                glpos[1] = ilpos.y();
            }
        }
 
        // transform back to global coordinates
        intersect         = gToLocal.inverse() * glpos;
        Amg::Vector3D dif = globalpos - intersect;
        if ((intersect - piOnPlane).mag() > m_dropDistance || dif.mag() > 0.5 * striplen + m_dropDistance) {
 
            ATH_MSG_VERBOSE(">>>> extrapolated position far outside volume, dropping hit "
                            << m_idHelperSvc->toString(id) << ". dist along strip " << dif.mag() << " 1/2 strip len "
                            << 0.5 * striplen << " dist measurement plane " << (intersect - piOnPlane).mag());
            return;
        }
        if (dif.mag() > 0.5 * striplen) {
            Amg::Vector3D newpos = globalpos - dif * (0.5 * striplen / dif.mag());
 
            ATH_MSG_VERBOSE(">>>> extrapolated position outside volume, shifting position "
                            << m_idHelperSvc->toString(id) << ". position along strip " << dif.mag() << " 1/2 tube len "
                            << 0.5 * striplen << " dist To strip " << (intersect - piOnPlane).mag()
                            << ". dist to newpos " << (newpos - globalpos).mag() << " pos " << newpos);
 
            intersect = newpos;
        }
    } else {
        // no phi measurements, use strip center
        intersect = globalpos;
    }
 
    // enter hit in map
    int regionId = getRegionId(id);
 
    Region& region = regionMap[regionId];
    if (!region.init) {
        region.regionDir = patdire;
        region.regionPos = patpose;
        region.init = true;
    }   
    region.triggerPrds.emplace_back(intersect, &clus);
}

insertMdt()

void Muon::MuonPatternCalibration::insertMdt ( const MdtPrepData &  clus, RegionMap &  regionMap, const Amg::Vector3D &  patpose, const Amg::Vector3D &  patdire, bool  hasPhiMeasurements  ) const

private

Definition at line 304 of file MuonPatternCalibration.cxx.

{
 
    Amg::Vector3D     intersect{Amg::Vector3D::Zero()};
    const Identifier& id = mdt.identify();
 
    const MuonGM::MdtReadoutElement* detEl   = mdt.detectorElement();
    const Amg::Vector3D&             tubePos = mdt.globalPosition();
 
    if (hasPhiMeasurements) {
        // if there is a phi measurement in the pattern use the global direction to calculate the intersect with the
        // tube use the intersect to calculate the second coordinate
 
        const Amg::Transform3D amdbToGlobal = detEl->AmdbLRSToGlobalTransform();
 
 
        // calculate intersect pattern measurement plane
        const Amg::Vector3D& planepostion = tubePos;
 
        // always project on plane with normal in radial direction
        Amg::Vector3D planenormal = m_idHelperSvc->mdtIdHelper().isBarrel(id)
                                        ? amdbToGlobal.linear() * Amg::Vector3D(0., 0., 1.)
                                        : amdbToGlobal.linear() * Amg::Vector3D(0., 1., 0.);
 
        double        denom     = patdire.dot(planenormal);
        double        u         = (planenormal.dot(planepostion - patpose)) / (denom);
        Amg::Vector3D piOnPlane = (patpose + u * patdire);
 
        Amg::Vector3D lpiOnPlane = amdbToGlobal.inverse() * piOnPlane;
        Amg::Vector3D ltubePos   = amdbToGlobal.inverse() * tubePos;
 
        intersect = amdbToGlobal * Amg::Vector3D(lpiOnPlane.x(), ltubePos.y(), ltubePos.z());
 
        Amg::Vector3D dif     = tubePos - intersect;
        double        tubelen = detEl->getActiveTubeLength(m_idHelperSvc->mdtIdHelper().tubeLayer(id),
                                                    m_idHelperSvc->mdtIdHelper().tube(id));
 
        if (dif.mag() > 0.5 * tubelen) {
            Amg::Vector3D newpos = tubePos - dif * (0.5 * tubelen / dif.mag());
 
            ATH_MSG_VERBOSE(">>>> extrapolated position outside volume, shifting position "
                            << m_idHelperSvc->toString(id) << ". position along strip " << dif.mag() << " 1/2 tube len "
                            << 0.5 * tubelen << " dist To Wire " << (piOnPlane - intersect).mag() << ". dist to newpos "
                            << (newpos - tubePos).mag() << " pos " << newpos);
 
            intersect = newpos;
        }
    } else {
        // not phi measurement, use tube center
        intersect = tubePos;
    }
 
    // enter hit in map
    Identifier elId = m_idHelperSvc->mdtIdHelper().elementID(id);
 
    MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(elId);
    int                       chFlag  = elId.get_identifier32().get_compact();
    if (m_doMultiAnalysis) {
        if (m_idHelperSvc->isSmallChamber(id)) {
            ATH_MSG_VERBOSE(" Small chamber " << m_idHelperSvc->toString(elId));
            chFlag = 0;
            if (chIndex == MuonStationIndex::BIS) {
                int eta = m_idHelperSvc->stationEta(elId);
                if (std::abs(eta) == 8) {
                    ATH_MSG_VERBOSE(" BIS8 chamber " << m_idHelperSvc->toString(elId));
                    chFlag = 3;
                }
            }
        } else {
            ATH_MSG_VERBOSE(" Large chamber " << m_idHelperSvc->toString(elId));
            chFlag = 1;
            if (chIndex == MuonStationIndex::BIL) {
                std::string stName = m_idHelperSvc->chamberNameString(id);
                if (stName[2] == 'R') {
                    ATH_MSG_VERBOSE(" BIR chamber " << m_idHelperSvc->toString(elId));
                    chFlag = 2;
                }
            } else if (chIndex == MuonStationIndex::BOL) {
                if (std::abs(m_idHelperSvc->stationEta(id)) == 7) {
                    ATH_MSG_VERBOSE(" BOE chamber " << m_idHelperSvc->toString(elId));
                    chFlag = 4;
                }
            }
        }
        int phi = m_idHelperSvc->mdtIdHelper().stationPhi(id);
 
        chFlag += 10 * phi;
    }
    // use center tube for region assignment
    int regionId = getRegionId(id);
 
    Region& region = regionMap[regionId];
    if (!region.init) {
        region.regionPos = patpose;
        region.regionDir = patdire;
        region.init = true;        
    }
    region.mdtPrdsPerChamber[chFlag].emplace_back(intersect, &mdt);
}

loadFromStoreGate()

template<class ContType >

StatusCode Muon::MuonPatternCalibration::loadFromStoreGate ( const EventContext &  ctx, const SG::ReadHandleKey< ContType > &  key, const ContType *&  cont_ptr  ) const

private

load the container from storegate given a ReadHandleKey.

If the key is empty a nullptr will be returned

Definition at line 463 of file MuonPatternCalibration.cxx.

                                                                                             {
    if (key.empty()){
        ATH_MSG_VERBOSE("Empty key given for "<<typeid(ContType).name()<<".");
        cont_ptr = nullptr;
        return StatusCode::SUCCESS;
    }
    SG::ReadHandle<ContType> readHandle{key, ctx};
    if (!readHandle.isValid()) {
        ATH_MSG_FATAL("Failed to retrieve "<<key.fullKey()<<" from store gate");
        return StatusCode::FAILURE;
    }
    cont_ptr = readHandle.cptr();        
    return StatusCode::SUCCESS;
}

printRegionMap()

void Muon::MuonPatternCalibration::printRegionMap ( const RegionMap &  regionMap ) const

private

Definition at line 406 of file MuonPatternCalibration.cxx.

{
 
    ATH_MSG_INFO("Summarizing input");
 
    for (const auto& [detRegionId, chamberData] : regionMap) {
        ATH_MSG_INFO("new region " << detRegionId << " trigger " << chamberData.triggerPrds.size() << " mdt ch "
                                   << chamberData.mdtPrdsPerChamber.size());
        if (!chamberData.triggerPrds.empty()) ATH_MSG_INFO("trigger hits " << chamberData.triggerPrds.size());
 
        for (const auto& [globalPos, prd] : chamberData.triggerPrds) {
            ATH_MSG_INFO("  " << m_printer->print(*prd)<<" "<<globalPos);
        }
        for (const auto& [statId, MdtChamHits]: chamberData.mdtPrdsPerChamber) {
            ATH_MSG_INFO("new MDT chamber with " << MdtChamHits.size() << " hits");
            for (const auto& [globalPos, prd] : MdtChamHits) {
                ATH_MSG_INFO("  " << m_printer->print(*prd)<<" "<<globalPos);
            }
        }
    }
}

Member Data Documentation

m_clusterCreator

ToolHandle<IMuonClusterOnTrackCreator> Muon::MuonPatternCalibration::m_clusterCreator

private

Initial value:

{
        this,
        "ClusterCreator",
        "Muon::MuonClusterOnTrackCreator/MuonClusterOnTrackCreator",
    }

Definition at line 88 of file MuonPatternCalibration.h.

m_doMultiAnalysis

Gaudi::Property<bool> Muon::MuonPatternCalibration::m_doMultiAnalysis {this, "DoMultiChamberAnalysis", true}

private

Definition at line 105 of file MuonPatternCalibration.h.

m_doSummary

Gaudi::Property<bool> Muon::MuonPatternCalibration::m_doSummary {this, "DoSummary", false}

private

Definition at line 108 of file MuonPatternCalibration.h.

m_dropDistance

Gaudi::Property<double> Muon::MuonPatternCalibration::m_dropDistance {this, "DropDistance", 1500.}

private

Definition at line 106 of file MuonPatternCalibration.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonPatternCalibration::m_idHelperSvc

private

Initial value:

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

Definition at line 99 of file MuonPatternCalibration.h.

m_keyRpc

SG::ReadHandleKey<Muon::RpcPrepDataContainer> Muon::MuonPatternCalibration::m_keyRpc {this, "RpcPrepDataContainer","RPC_Measurements"}

private

Definition at line 112 of file MuonPatternCalibration.h.

m_keyTgc

SG::ReadHandleKey<Muon::TgcPrepDataContainer> Muon::MuonPatternCalibration::m_keyTgc {this, "TgcPrepDataContainer","TGC_Measurements"}

private

Definition at line 113 of file MuonPatternCalibration.h.

m_mdtCreator

ToolHandle<IMdtDriftCircleOnTrackCreator> Muon::MuonPatternCalibration::m_mdtCreator

private

Initial value:

{
        this,
        "MdtCreator",
        "",
    }

Definition at line 83 of file MuonPatternCalibration.h.

m_phiAngleCut

Gaudi::Property<double> Muon::MuonPatternCalibration::m_phiAngleCut {this, "AngleCutPhi", 1.e9}

private

Definition at line 107 of file MuonPatternCalibration.h.

m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MuonPatternCalibration::m_printer

private

Initial value:

{
        this,
        "Printer",
        "Muon::MuonEDMPrinterTool",
    }

Definition at line 93 of file MuonPatternCalibration.h.

m_recoverTriggerHits

Gaudi::Property<bool> Muon::MuonPatternCalibration::m_recoverTriggerHits {this, "RecoverTriggerHits", true}

private

Definition at line 109 of file MuonPatternCalibration.h.

m_removeDoubleMdtHits

Gaudi::Property<bool> Muon::MuonPatternCalibration::m_removeDoubleMdtHits {this, "RemoveDoubleMdtHits", true}

private

Definition at line 110 of file MuonPatternCalibration.h.

---

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

• MuonPatternCalibration.h
• MuonPatternCalibration.cxx