Muon::MuonEventCnvTool Class Reference

Tool used in the persisency convertors to help rebuild EDM objects. More...

#include <MuonEventCnvTool.h>

Inheritance diagram for Muon::MuonEventCnvTool:

Collaboration diagram for Muon::MuonEventCnvTool:

Public Types
enum	MuonConcreteType {   MDT , RPC , CSC , TGC ,   MM , STGC , TypeUnknown }

Public Member Functions
	MuonEventCnvTool (const std::string &, const std::string &, const IInterface *)
virtual StatusCode	initialize () override
virtual void	checkRoT (const Trk::RIO_OnTrack &rioOnTrack) const override
	check that the RoT is correctly filled
virtual std::pair< const Trk::TrkDetElementBase *, const Trk::PrepRawData * >	getLinks (Trk::RIO_OnTrack &rioOnTrack) const override
virtual void	prepareRIO_OnTrack (Trk::RIO_OnTrack *rot) const override
virtual void	prepareRIO_OnTrackLink (const Trk::RIO_OnTrack *rot, ELKey_t &key, ELIndex_t &index) const override
	Similar, but just return the EL components rather then changing ROT.
virtual void	recreateRIO_OnTrack (Trk::RIO_OnTrack *RoT) const override
	Take the passed RoT and recreate it (i.e.
virtual const Trk::TrkDetElementBase *	getDetectorElement (const Identifier &id, const IdentifierHash &idHash) const override
	Return the detectorElement associated with this Identifier.
virtual const Trk::TrkDetElementBase *	getDetectorElement (const Identifier &id) const override
	Return the detectorElement associated with this Identifier.

Private Member Functions
const Trk::PrepRawData *	getLink (const Identifier &id, const IdentifierHash &idHash) const
template<class CONT>
const Trk::PrepRawData *	getLink (const Identifier &id, const IdentifierHash &idHash, const SG::ReadHandleKey< CONT > &handle, const EventContext &ctx) const

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadHandleKey< RpcPrepDataContainer >	m_rpcPrdKey {this, "RpcClusterContainer", "RPC_Measurements", "Location for RPC PRDs"}
SG::ReadHandleKey< CscPrepDataContainer >	m_cscPrdKey {this, "CscClusterContainer", "CSC_Clusters", "Location for CSC PRDs"}
SG::ReadHandleKey< TgcPrepDataContainer >	m_tgcPrdKey {this, "TgcClusterContainer", "TGC_MeasurementsAllBCs", "Location for TGC PRDs"}
SG::ReadHandleKey< MdtPrepDataContainer >	m_mdtPrdKey {this, "MdtClusterContainer", "MDT_DriftCircles", "Location for MDT PRDs"}
SG::ReadHandleKey< MMPrepDataContainer >	m_mmPrdKey {this, "MM_ClusterContainer", "MM_Measurements", "Location for MM PRDs"}
SG::ReadHandleKey< sTgcPrepDataContainer >	m_stgcPrdKey {this, "STGC_ClusterContainer", "STGC_Measurements", "Location for sTGC PRDs"}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_detectorManagerKey
Gaudi::Property< bool >	m_manuallyFindPRDs
	If true, search for PRDs manually - i.e.
Gaudi::Property< bool >	m_fixTGCs {this, "FixTGCs", false, "If true, try to fix broken EL, e.g. ATLASRECTS-5151"}

Detailed Description

Tool used in the persisency convertors to help rebuild EDM objects.

Definition at line 30 of file MuonEventCnvTool.h.

Member Enumeration Documentation

MuonConcreteType

enum Muon::MuonEventCnvTool::MuonConcreteType

Enumerator
MDT
RPC
CSC
TGC
MM
STGC
TypeUnknown

Definition at line 32 of file MuonEventCnvTool.h.

{ MDT, RPC, CSC, TGC, MM, STGC, TypeUnknown };

Constructor & Destructor Documentation

MuonEventCnvTool()

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

Definition at line 31 of file MuonEventCnvTool.cxx.

: base_class(t, n, p) {}

Member Function Documentation

checkRoT()

void Muon::MuonEventCnvTool::checkRoT ( const Trk::RIO_OnTrack & rioOnTrack ) const

overridevirtual

check that the RoT is correctly filled

Definition at line 46 of file MuonEventCnvTool.cxx.

                                                                          {
    MuonConcreteType type = TypeUnknown;
    const Identifier& id = rioOnTrack.identify();
    if (m_idHelperSvc->isRpc(id))
        type = RPC;
    else if (m_idHelperSvc->isTgc(id))
        type = TGC;
    else if (m_idHelperSvc->isMdt(id))
        type = MDT;
    else if (m_idHelperSvc->isMM(id))
        type = MM;
    else if (m_idHelperSvc->issTgc(id))
        type = STGC;
    else if (m_idHelperSvc->isCsc(id))
        type = CSC;
 
    if (type == TypeUnknown) {
        ATH_MSG_ERROR("Type does not match known concrete type of MuonSpectrometer! Dumping RoT:" << rioOnTrack);
    } else {
        ATH_MSG_VERBOSE("Type = " << type << "(RPC=" << RPC << ", CSC=" << CSC << ", TGC=" << TGC << "MDT=" << MDT << ", STGC=" << STGC
                                  << "MM=" << MM << ")");
    }
}

getDetectorElement() [1/2]

const Trk::TrkDetElementBase * Muon::MuonEventCnvTool::getDetectorElement ( const Identifier & id ) const

overridevirtual

Return the detectorElement associated with this Identifier.

Definition at line 169 of file MuonEventCnvTool.cxx.

                                                                                               {
    const EventContext& ctx = Gaudi::Hive::currentContext();    
    const MuonGM::MuonDetectorManager* muonMgr{nullptr};    
    SG::ReadCondHandle muonMgrHandle{m_detectorManagerKey, ctx};
    if (!muonMgrHandle.isValid()) {
        ATH_MSG_ERROR("Failed to retrieve the Muon detector manager from the conditions store");
        return nullptr;
    }
    muonMgr = muonMgrHandle.cptr();
    
    const Trk::TrkDetElementBase* detEl = nullptr;
    // TODO Check that these are in the most likely ordering, for speed. EJWM.
    if (m_idHelperSvc->isRpc(id)) {
        detEl = muonMgr->getRpcReadoutElement(id);
    } else if (m_idHelperSvc->isCsc(id)) {
        detEl = muonMgr->getCscReadoutElement(id);
    } else if (m_idHelperSvc->isTgc(id)) {
        detEl = muonMgr->getTgcReadoutElement(id);
    } else if (m_idHelperSvc->isMdt(id)) {
        detEl = muonMgr->getMdtReadoutElement(id);
    } else if (m_idHelperSvc->issTgc(id)) {
        detEl = muonMgr->getsTgcReadoutElement(id);
    } else if (m_idHelperSvc->isMM(id)) {
        detEl = muonMgr->getMMReadoutElement(id);
    }
    if (!detEl) ATH_MSG_ERROR("Could not find detector element for Identifier: " << m_idHelperSvc->toString(id));
    return detEl;
}

getDetectorElement() [2/2]

const Trk::TrkDetElementBase * Muon::MuonEventCnvTool::getDetectorElement ( const Identifier & id, const IdentifierHash & idHash ) const

overridevirtual

Return the detectorElement associated with this Identifier.

Parameters

idHash

idHash

Definition at line 165 of file MuonEventCnvTool.cxx.

                                                                                                                        {
    return getDetectorElement(id);
}

getLink() [1/2]

const Trk::PrepRawData * Muon::MuonEventCnvTool::getLink ( const Identifier & id, const IdentifierHash & idHash ) const

private

Definition at line 198 of file MuonEventCnvTool.cxx.

                                                                                                            {
    const EventContext& ctx = Gaudi::Hive::currentContext();
    if (m_idHelperSvc->isMdt(id)) {
        return getLink(id, idHash, m_mdtPrdKey, ctx);
    } else if (m_idHelperSvc->isRpc(id)) {
        return getLink(id, idHash, m_rpcPrdKey, ctx);
    } else if (m_idHelperSvc->isTgc(id)) {
        return getLink(id, idHash, m_tgcPrdKey, ctx);
    } else if (m_idHelperSvc->isMM(id)) {
        return getLink(id, idHash, m_mmPrdKey, ctx);
    } else if (m_idHelperSvc->issTgc(id)) {
        return getLink(id, idHash, m_stgcPrdKey, ctx);
    }
    ATH_MSG_ERROR("The given Identifier is not a muon one " << m_idHelperSvc->toString(id));
    return nullptr;
}

getLink() [2/2]

template<class CONT>

const Trk::PrepRawData * Muon::MuonEventCnvTool::getLink ( const Identifier & id, const IdentifierHash & idHash, const SG::ReadHandleKey< CONT > & handle, const EventContext & ctx ) const

private

Definition at line 216 of file MuonEventCnvTool.cxx.

                                                                                                                            {
    SG::ReadHandle<CONT> handle{prdKey, ctx};
    if (!handle.isValid()) {
        ATH_MSG_ERROR("PRD container not found at " << prdKey);
        return nullptr;
    } else {
        ATH_MSG_DEBUG("PRD Cluster container found at " << prdKey);
    }
 
    auto ptr = handle->indexFindPtr(idHash);
    if (!ptr) {
        ATH_MSG_DEBUG("No matching PRD found");
        return nullptr;
    }
    // if we find PRD, then recreate link
    // loop though collection to find matching PRD.
    // there MUST be a faster way to do this!!
    for (const auto& collIt : *ptr) {
        if (collIt->identify() == id) return collIt;
    }
    ATH_MSG_DEBUG("No matching PRD found");
    return nullptr;
}

getLinks()

std::pair< const Trk::TrkDetElementBase *, const Trk::PrepRawData * > Muon::MuonEventCnvTool::getLinks ( Trk::RIO_OnTrack & rioOnTrack ) const

overridevirtual

Definition at line 70 of file MuonEventCnvTool.cxx.

                                                                                                                           {
    using namespace Trk;
    using namespace MuonGM;
 
    const Identifier& id = rioOnTrack.identify();
    const TrkDetElementBase* detEl = getDetectorElement(id);
    if (!detEl) {
        ATH_MSG_ERROR("Could not find detector element for " << m_idHelperSvc->toString(id));
        ATH_MSG_ERROR(rioOnTrack);
    }
    const PrepRawData* prd = m_manuallyFindPRDs ? getLink(id, rioOnTrack.idDE()) : nullptr;
 
    if (m_fixTGCs && m_idHelperSvc->isTgc(id) && !rioOnTrack.prepRawData()) {
        // Okay, so we might have hit the nasty issue that the TGC EL is broken in some samples
        // Need to fix by pointing to the key defined here (assumung it has been configured correctly for this sample)
        Muon::TgcClusterOnTrack* tgc = dynamic_cast<Muon::TgcClusterOnTrack*>(&rioOnTrack);
        ElementLinkToIDC_TGC_Container& el = tgc->m_rio;
        el.resetWithKeyAndIndex(m_tgcPrdKey.key(), el.index());
    }
 
    ATH_MSG_VERBOSE("Found PRD at : " << prd);
    return std::pair<const Trk::TrkDetElementBase*, const Trk::PrepRawData*>(detEl, prd);
}

initialize()

StatusCode Muon::MuonEventCnvTool::initialize ( )

overridevirtual

Definition at line 33 of file MuonEventCnvTool.cxx.

                                            {
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_rpcPrdKey.initialize());
    ATH_CHECK(m_tgcPrdKey.initialize());
    ATH_CHECK(m_mdtPrdKey.initialize());
    ATH_CHECK(m_detectorManagerKey.initialize());
    ATH_CHECK(m_cscPrdKey.initialize(!m_cscPrdKey.empty()));    // check for layouts without CSCs
    ATH_CHECK(m_mmPrdKey.initialize(!m_mmPrdKey.empty()));      // check for layouts without MicroMegas
    ATH_CHECK(m_stgcPrdKey.initialize(!m_stgcPrdKey.empty()));  // check for layouts without STGCs
 
    return StatusCode::SUCCESS;
}

prepareRIO_OnTrack()

void Muon::MuonEventCnvTool::prepareRIO_OnTrack ( Trk::RIO_OnTrack * rot ) const

overridevirtual

Definition at line 94 of file MuonEventCnvTool.cxx.

                                                                       {
    Muon::MdtDriftCircleOnTrack* mdt = dynamic_cast<Muon::MdtDriftCircleOnTrack*>(RoT);
    if (mdt) {
        prepareRIO_OnTrackElementLink<const Muon::MdtPrepDataContainer, Muon::MdtDriftCircleOnTrack>(mdt);
        return;
    }
    Muon::CscClusterOnTrack* csc = dynamic_cast<Muon::CscClusterOnTrack*>(RoT);
    if (csc) {
        prepareRIO_OnTrackElementLink<const Muon::CscPrepDataContainer, Muon::CscClusterOnTrack>(csc);
        return;
    }
    Muon::RpcClusterOnTrack* rpc = dynamic_cast<Muon::RpcClusterOnTrack*>(RoT);
    if (rpc) {
        prepareRIO_OnTrackElementLink<const Muon::RpcPrepDataContainer, Muon::RpcClusterOnTrack>(rpc);
        return;
    }
    Muon::TgcClusterOnTrack* tgc = dynamic_cast<Muon::TgcClusterOnTrack*>(RoT);
    if (tgc) {
        prepareRIO_OnTrackElementLink<const Muon::TgcPrepDataContainer, Muon::TgcClusterOnTrack>(tgc);
        return;
    }
    Muon::sTgcClusterOnTrack* stgc = dynamic_cast<Muon::sTgcClusterOnTrack*>(RoT);
    if (stgc) {
        prepareRIO_OnTrackElementLink<const Muon::sTgcPrepDataContainer, Muon::sTgcClusterOnTrack>(stgc);
        return;
    }
    Muon::MMClusterOnTrack* mm = dynamic_cast<Muon::MMClusterOnTrack*>(RoT);
    if (mm) {
        prepareRIO_OnTrackElementLink<const Muon::MMPrepDataContainer, Muon::MMClusterOnTrack>(mm);
        return;
    }
}

prepareRIO_OnTrackLink()

void Muon::MuonEventCnvTool::prepareRIO_OnTrackLink ( const Trk::RIO_OnTrack * rot, ELKey_t & key, ELIndex_t & index ) const

overridevirtual

Similar, but just return the EL components rather then changing ROT.

Definition at line 127 of file MuonEventCnvTool.cxx.

                                                                                                                 {
    const Muon::MdtDriftCircleOnTrack* mdt = dynamic_cast<const Muon::MdtDriftCircleOnTrack*>(RoT);
    if (mdt) {
        prepareRIO_OnTrackElementLink<const Muon::MdtPrepDataContainer, Muon::MdtDriftCircleOnTrack>(mdt, key, index);
        return;
    }
    const Muon::CscClusterOnTrack* csc = dynamic_cast<const Muon::CscClusterOnTrack*>(RoT);
    if (csc) {
        prepareRIO_OnTrackElementLink<const Muon::CscPrepDataContainer, Muon::CscClusterOnTrack>(csc, key, index);
        return;
    }
    const Muon::RpcClusterOnTrack* rpc = dynamic_cast<const Muon::RpcClusterOnTrack*>(RoT);
    if (rpc) {
        prepareRIO_OnTrackElementLink<const Muon::RpcPrepDataContainer, Muon::RpcClusterOnTrack>(rpc, key, index);
        return;
    }
    const Muon::TgcClusterOnTrack* tgc = dynamic_cast<const Muon::TgcClusterOnTrack*>(RoT);
    if (tgc) {
        prepareRIO_OnTrackElementLink<const Muon::TgcPrepDataContainer, Muon::TgcClusterOnTrack>(tgc, key, index);
        return;
    }
    const Muon::sTgcClusterOnTrack* stgc = dynamic_cast<const Muon::sTgcClusterOnTrack*>(RoT);
    if (stgc) {
        prepareRIO_OnTrackElementLink<const Muon::sTgcPrepDataContainer, Muon::sTgcClusterOnTrack>(stgc, key, index);
        return;
    }
    const Muon::MMClusterOnTrack* mm = dynamic_cast<const Muon::MMClusterOnTrack*>(RoT);
    if (mm) {
        prepareRIO_OnTrackElementLink<const Muon::MMPrepDataContainer, Muon::MMClusterOnTrack>(mm, key, index);
        return;
    }
    }

recreateRIO_OnTrack()

void Muon::MuonEventCnvTool::recreateRIO_OnTrack ( Trk::RIO_OnTrack * RoT ) const

overridevirtual

Take the passed RoT and recreate it (i.e.

fill missing pointers etc)

Definition at line 160 of file MuonEventCnvTool.cxx.

                                                                        {
    std::pair<const Trk::TrkDetElementBase*, const Trk::PrepRawData*> pair = getLinks(*RoT);
    if (pair.first) Trk::ITrkEventCnvTool::setRoT_Values(pair, RoT);
}

Member Data Documentation

m_cscPrdKey

SG::ReadHandleKey<CscPrepDataContainer> Muon::MuonEventCnvTool::m_cscPrdKey {this, "CscClusterContainer", "CSC_Clusters", "Location for CSC PRDs"}

private

Definition at line 71 of file MuonEventCnvTool.h.

{this, "CscClusterContainer", "CSC_Clusters", "Location for CSC PRDs"};

m_detectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::MuonEventCnvTool::m_detectorManagerKey

private

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",
                                                                                "Key of input MuonDetectorManager condition data"}

Definition at line 77 of file MuonEventCnvTool.h.

                                                                           {this, "DetectorManagerKey", "MuonDetectorManager",
                                                                                "Key of input MuonDetectorManager condition data"};

m_fixTGCs

Gaudi::Property<bool> Muon::MuonEventCnvTool::m_fixTGCs {this, "FixTGCs", false, "If true, try to fix broken EL, e.g. ATLASRECTS-5151"}

private

Definition at line 84 of file MuonEventCnvTool.h.

{this, "FixTGCs", false, "If true, try to fix broken EL, e.g. ATLASRECTS-5151"};        

m_idHelperSvc

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

private

Definition at line 68 of file MuonEventCnvTool.h.

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

m_manuallyFindPRDs

Gaudi::Property<bool> Muon::MuonEventCnvTool::m_manuallyFindPRDs

private

Initial value:

{this, "FindPRDsManually", false,
                                                 "If true, search for PRDs manually - i.e. do not rely on ElementLink working"}

If true, search for PRDs manually - i.e.

do not rely on ElementLink working

Warning

This functionality is left in primarily for debugging - will probably be removed in near future.

Definition at line 82 of file MuonEventCnvTool.h.

                                              {this, "FindPRDsManually", false,
                                                 "If true, search for PRDs manually - i.e. do not rely on ElementLink working"};

m_mdtPrdKey

SG::ReadHandleKey<MdtPrepDataContainer> Muon::MuonEventCnvTool::m_mdtPrdKey {this, "MdtClusterContainer", "MDT_DriftCircles", "Location for MDT PRDs"}

private

Definition at line 73 of file MuonEventCnvTool.h.

{this, "MdtClusterContainer", "MDT_DriftCircles", "Location for MDT PRDs"};

m_mmPrdKey

SG::ReadHandleKey<MMPrepDataContainer> Muon::MuonEventCnvTool::m_mmPrdKey {this, "MM_ClusterContainer", "MM_Measurements", "Location for MM PRDs"}

private

Definition at line 74 of file MuonEventCnvTool.h.

{this, "MM_ClusterContainer", "MM_Measurements", "Location for MM PRDs"};

m_rpcPrdKey

SG::ReadHandleKey<RpcPrepDataContainer> Muon::MuonEventCnvTool::m_rpcPrdKey {this, "RpcClusterContainer", "RPC_Measurements", "Location for RPC PRDs"}

private

Definition at line 70 of file MuonEventCnvTool.h.

{this, "RpcClusterContainer", "RPC_Measurements", "Location for RPC PRDs"};

m_stgcPrdKey

SG::ReadHandleKey<sTgcPrepDataContainer> Muon::MuonEventCnvTool::m_stgcPrdKey {this, "STGC_ClusterContainer", "STGC_Measurements", "Location for sTGC PRDs"}

private

Definition at line 75 of file MuonEventCnvTool.h.

{this, "STGC_ClusterContainer", "STGC_Measurements", "Location for sTGC PRDs"};

m_tgcPrdKey

SG::ReadHandleKey<TgcPrepDataContainer> Muon::MuonEventCnvTool::m_tgcPrdKey {this, "TgcClusterContainer", "TGC_MeasurementsAllBCs", "Location for TGC PRDs"}

private

Definition at line 72 of file MuonEventCnvTool.h.

{this, "TgcClusterContainer", "TGC_MeasurementsAllBCs", "Location for TGC PRDs"};

---

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

• MuonEventCnvTool.h
• MuonEventCnvTool.cxx