Muon::MuonIdHelperSvc Class Reference

Helper service that creates muon Identifiers and can be used to print Identifiers. More...

#include <MuonIdHelperSvc.h>

Inheritance diagram for Muon::MuonIdHelperSvc:

Classes
struct	StationNameData

Public Member Functions
	MuonIdHelperSvc (const std::string &name, ISvcLocator *svc)
	default AlgService constructor
virtual	~MuonIdHelperSvc () override=default
	destructor
virtual StatusCode	initialize () override
	AlgTool initilize.
virtual std::string	toString (const Identifier &id) const override
	print all fields to string
virtual std::string	toStringTech (const Identifier &id) const override
	print all fields up to technology to string
virtual std::string	toStringStation (const Identifier &id) const override
	print all fields up to stationName to string
virtual std::string	toStringChamber (const Identifier &id) const override
	print all fields up to chamber to string
virtual std::string	toStringDetEl (const Identifier &id) const override
	print all fields up to detector element to string
virtual std::string	toStringGasGap (const Identifier &id) const override
	print all fields up to gas gap to string
virtual std::string	chamberNameString (const Identifier &id) const override
	print chamber name to string
virtual bool	isMuon (const Identifier &id) const override
	returns whether this is a Muon Identifier or not
virtual bool	isMdt (const Identifier &id) const override
	returns whether this is a MDT Identifier or not
virtual bool	isMM (const Identifier &id) const override
	returns whether this is a MM Identifier or not
virtual bool	isCsc (const Identifier &id) const override
	returns whether this is a CSC Identifier or not
virtual bool	isRpc (const Identifier &id) const override
	returns whether this is a RPC Identifier or not
virtual bool	isTgc (const Identifier &id) const override
	returns whether this is a TGC Identifier or not
virtual bool	issTgc (const Identifier &id) const override
	returns whether this is a sTGC Identifier or not
virtual bool	issMdt (const Identifier &id) const override
	returns whether this is a sMDT Identifier or not
virtual bool	hasHPTDC (const Identifier &id) const override
	returns whether this Identifier belongs to an MDT with HPTDC or not NOTE that in Run4, no HPTDCs at all are planned to be present any more, so this function should be obsolete from Run4 onwards
virtual bool	measuresPhi (const Identifier &id) const override
	returns whether channel measures phi or not
virtual bool	isEndcap (const Identifier &id) const override
	returns whether this is an endcap Identifier or not
virtual bool	isTrigger (const Identifier &id) const override
	returns whether trigger chamber id or not
virtual bool	isSmallChamber (const Identifier &id) const override
	returns whether this is a small chamber, always returns true for TGCs
virtual int	gasGap (const Identifier &id) const override
	returns gas gap: gasGap for RPC + TGC, wireLayer for CSC, tube for MDT
virtual Identifier	chamberId (const Identifier &id) const override
	create a chamber ID
virtual Identifier	detElId (const Identifier &id) const override
	create a detector element ID
virtual Identifier	gasGapId (const Identifier &id) const override
	create a gasGap ID (will return layer Id for MDTs)
virtual Identifier	layerId (const Identifier &id) const override
	create a layer ID, returns tube id for the MDTs
virtual const MdtIdHelper &	mdtIdHelper () const override
	access to MdtIdHelper
virtual const RpcIdHelper &	rpcIdHelper () const override
	access to RpcIdHelper
virtual const TgcIdHelper &	tgcIdHelper () const override
	access to TgcIdHelper
virtual const CscIdHelper &	cscIdHelper () const override
	access to CscIdHelper
virtual const sTgcIdHelper &	stgcIdHelper () const override
	access to TgcIdHelper
virtual const MmIdHelper &	mmIdHelper () const override
	access to CscIdHelper
virtual MuonStationIndex::ChIndex	chamberIndex (const Identifier &id) const override
	calculate chamber index from Identifier
virtual MuonStationIndex::StIndex	stationIndex (const Identifier &id) const override
	calculate station index from Identifier
virtual MuonStationIndex::PhiIndex	phiIndex (const Identifier &id) const override
	calculate phi index from Identifier (not supported for MDT hits)
virtual MuonStationIndex::DetectorRegionIndex	regionIndex (const Identifier &id) const override
	calculate detector region index from Identifier
virtual MuonStationIndex::LayerIndex	layerIndex (const Identifier &id) const override
	calculate layer index from Identifier
virtual MuonStationIndex::TechnologyIndex	technologyIndex (const Identifier &id) const override
	calculate layer index from Identifier
virtual int	stationPhi (const Identifier &id) const override
	Return stationPhi for all technologies.
virtual int	stationEta (const Identifier &id) const override
	Return stationEta for all technologies.
virtual std::string	stationNameString (const Identifier &id) const override
	Return the station name string for all technologies.
virtual int	stationName (const Identifier &id) const override
	Return stationName for all technologies.
virtual int	stationRegion (const Identifier &id) const override
	Return stationRegion for all technologies.
virtual int	sector (const Identifier &id) const override
	return sector number 1-16, odd=large, even=small
virtual const std::set< MuonStationIndex::TechnologyIndex > &	technologiesInStation (MuonStationIndex::StIndex stIndex) const override
	Recieve all technologies in a station.
bool	hasRPC () const override
bool	hasTGC () const override
bool	hasMDT () const override
bool	hasCSC () const override
bool	hasSTGC () const override
bool	hasMM () const override
virtual IdentifierHash	moduleHash (const Identifier &id) const override
	Returns the module hash associated to an Identifier.
virtual IdentifierHash	detElementHash (const Identifier &id) const override
	Returns the detector element hash associated to an Identifier.

Private Types
using	TechIdx = MuonStationIndex::TechnologyIndex
using	ChIdx = MuonStationIndex::ChIndex
using	StIdx = MuonStationIndex::StIndex
using	PhiIdx = MuonStationIndex::PhiIndex

Private Member Functions
IdentifierHash	moduleHash (const MuonIdHelper &idHelper, const Identifier &id) const
IdentifierHash	detElementHash (const MuonIdHelper &idHelper, const Identifier &id) const

Private Attributes
const RpcIdHelper *	m_rpcIdHelper {nullptr}
	Sub detector specific IdHelpers.
const TgcIdHelper *	m_tgcIdHelper {nullptr}
const CscIdHelper *	m_cscIdHelper {nullptr}
const MdtIdHelper *	m_mdtIdHelper {nullptr}
const MmIdHelper *	m_mmIdHelper {nullptr}
const sTgcIdHelper *	m_stgcIdHelper {nullptr}
const MuonIdHelper *	m_primaryHelper {nullptr}
Gaudi::Property< bool >	m_hasMDT {this, "HasMDT", true, "Specify whether the current detector layour contains MDT chambers"}
Gaudi::Property< bool >	m_hasRPC {this, "HasRPC", true, "Specify whether the current detector layour contains RPC chambers"}
Gaudi::Property< bool >	m_hasTGC {this, "HasTGC", true, "Specify whether the current detector layour contains TGC chambers"}
Gaudi::Property< bool >	m_hasCSC {this, "HasCSC", true, "Specify whether current detector layout contains CSC chambers"}
Gaudi::Property< bool >	m_hasSTGC {this, "HasSTGC", true, "Specify whether current detector layout contains STGC chambers"}
Gaudi::Property< bool >	m_hasMM {this, "HasMM", true, "Specify whether current detector layout contains MicroMegas chambers"}
ServiceHandle< StoreGateSvc >	m_detStore {this, "DetectorStore", "DetectorStore"}
std::vector< StationNameData >	m_stationNameData {}
std::vector< TechIdx >	m_technologies {}
int	m_BIS_stat {-1}
std::unordered_set< Identifier >	m_smdt_stat {}
std::array< std::set< TechIdx >, static_cast< int >(StIdx::StIndexMax)>	m_techPerStation {}
	Array holding which technologies are there per station.

Detailed Description

Helper service that creates muon Identifiers and can be used to print Identifiers.

Definition at line 19 of file MuonIdHelperSvc.h.

Member Typedef Documentation

ChIdx

using Muon::MuonIdHelperSvc::ChIdx = MuonStationIndex::ChIndex

private

Definition at line 202 of file MuonIdHelperSvc.h.

PhiIdx

using Muon::MuonIdHelperSvc::PhiIdx = MuonStationIndex::PhiIndex

private

Definition at line 204 of file MuonIdHelperSvc.h.

StIdx

using Muon::MuonIdHelperSvc::StIdx = MuonStationIndex::StIndex

private

Definition at line 203 of file MuonIdHelperSvc.h.

TechIdx

using Muon::MuonIdHelperSvc::TechIdx = MuonStationIndex::TechnologyIndex

private

Definition at line 201 of file MuonIdHelperSvc.h.

Constructor & Destructor Documentation

MuonIdHelperSvc()

Muon::MuonIdHelperSvc::MuonIdHelperSvc	(	const std::string &	name,
		ISvcLocator *	svc )

default AlgService constructor

Definition at line 15 of file MuonIdHelperSvc.cxx.

                                                                            :
        base_class(name, svc) {}

~MuonIdHelperSvc()

virtual Muon::MuonIdHelperSvc::~MuonIdHelperSvc ( )

overridevirtualdefault

destructor

Member Function Documentation

chamberId()

Identifier Muon::MuonIdHelperSvc::chamberId ( const Identifier & id ) const

overridevirtual

create a chamber ID

Definition at line 431 of file MuonIdHelperSvc.cxx.

                                                                    {
        // use phi hits on segment
        switch (technologyIndex(id)) {
            using enum TechnologyIndex;
            case MDT: {
                return m_mdtIdHelper->elementID(id);
            } case RPC: {
                return m_rpcIdHelper->elementID(id);
            } case TGC: {
                return m_tgcIdHelper->elementID(id);
            } case CSC: {
                return m_cscIdHelper->elementID(id);
            } case STGC: {
                return m_stgcIdHelper->elementID(id);
            } case MM: {
                return m_mmIdHelper->elementID(id);
            } default:
                break;
        }
        return Identifier{};
    }

chamberIndex()

ChIndex Muon::MuonIdHelperSvc::chamberIndex ( const Identifier & id ) const

overridevirtual

calculate chamber index from Identifier

Definition at line 261 of file MuonIdHelperSvc.cxx.

                                                                    {
        if (!id.is_valid() || !isMuon(id)) {
            if (id.is_valid()) ATH_MSG_WARNING("chamberIndex: invalid ID " << m_primaryHelper->print_to_string(id));
            return ChIdx::ChUnknown;
        }
        return m_stationNameData[stationName(id)].chIndex;
    }

chamberNameString()

std::string Muon::MuonIdHelperSvc::chamberNameString ( const Identifier & id ) const

overridevirtual

print chamber name to string

Definition at line 373 of file MuonIdHelperSvc.cxx.

                                                                           {
        return m_primaryHelper->stationNameString(stationName(id));
    }

cscIdHelper()

virtual const CscIdHelper & Muon::MuonIdHelperSvc::cscIdHelper ( ) const

inlineoverridevirtual

access to CscIdHelper

Definition at line 117 of file MuonIdHelperSvc.h.

{ return *m_cscIdHelper; }

detElementHash() [1/2]

IdentifierHash Muon::MuonIdHelperSvc::detElementHash ( const Identifier & id ) const

overridevirtual

Returns the detector element hash associated to an Identifier.

Definition at line 598 of file MuonIdHelperSvc.cxx.

                                                                             {
       switch (technologyIndex(id)){
            using enum MuonStationIndex::TechnologyIndex;
            case MDT: {
                return detElementHash(*m_mdtIdHelper, id);
            }
            case RPC: {
                return detElementHash(*m_rpcIdHelper, id);
            }
            case TGC: {
                return detElementHash(*m_tgcIdHelper, id);
            }
            case CSC: {
                return detElementHash(*m_cscIdHelper, id);
            }
            case STGC: {
                return detElementHash(*m_stgcIdHelper, id);
            }
            case MM: {
                return detElementHash(*m_mmIdHelper, id);
            }
            default:
                break;
        }
        ATH_MSG_WARNING("detElementHash(): No muon Identifier "<<id);
        return IdentifierHash{};
    }

detElementHash() [2/2]

IdentifierHash Muon::MuonIdHelperSvc::detElementHash ( const MuonIdHelper & idHelper, const Identifier & id ) const

inlineprivate

Definition at line 562 of file MuonIdHelperSvc.cxx.

                                                                                                                 {
        IdentifierHash hash{};
        if (idHelper.get_detectorElement_hash(id, hash) ||
            static_cast<unsigned int>(hash)>= idHelper.detectorElement_hash_max()) {
            ATH_MSG_VERBOSE("Failed to deduce detector element hash "<<toString(id));
        }
        return hash;
    }

detElId()

Identifier Muon::MuonIdHelperSvc::detElId ( const Identifier & id ) const

overridevirtual

create a detector element ID

Definition at line 453 of file MuonIdHelperSvc.cxx.

                                                                  {
        // use phi hits on segment
        switch (technologyIndex(id)) {
            using enum MuonStationIndex::TechnologyIndex;
            case MDT: {
                return m_mdtIdHelper->channelID(id, m_mdtIdHelper->multilayer(id), 1, 1);;
            } case RPC: {
                return m_rpcIdHelper->channelID(id, m_rpcIdHelper->doubletZ(id), m_rpcIdHelper->doubletPhi(id), 1, false, 1);
            } case TGC: {
                return m_tgcIdHelper->elementID(id);   
            } case CSC: {
                return m_cscIdHelper->channelID(id, 2, 1, 1, 1);
            } case MM: {
                return m_mmIdHelper->channelID(id, m_mmIdHelper->multilayer(id), 1, 1);   
            } case STGC: {
                return m_stgcIdHelper->channelID(id, m_stgcIdHelper->multilayer(id), 1, sTgcIdHelper::sTgcChannelTypes::Strip, 1);
            } default:
                 break;
        }
        return id;
    }

gasGap()

int Muon::MuonIdHelperSvc::gasGap ( const Identifier & id ) const

overridevirtual

returns gas gap: gasGap for RPC + TGC, wireLayer for CSC, tube for MDT

Definition at line 186 of file MuonIdHelperSvc.cxx.

                                                          {
        switch (technologyIndex(id)) {
            using enum TechnologyIndex;
            case RPC: {
                return m_rpcIdHelper->gasGap(id);
            } case TGC: {
               return m_tgcIdHelper->gasGap(id);
            } case CSC: {
                return m_cscIdHelper->wireLayer(id);
            } case STGC: {
                return m_stgcIdHelper->gasGap(id);
            } case MM: {
                return m_mmIdHelper->gasGap(id);
            } case MDT: {
                return m_mdtIdHelper->channel(id);
            } default:
                break;
        }
        return 0;
    }

gasGapId()

Identifier Muon::MuonIdHelperSvc::gasGapId ( const Identifier & id ) const

overridevirtual

create a gasGap ID (will return layer Id for MDTs)

Definition at line 498 of file MuonIdHelperSvc.cxx.

                                                                   {
        switch (technologyIndex(id)) {
            using enum TechnologyIndex;
            case RPC: {
                return m_rpcIdHelper->channelID(id, m_rpcIdHelper->doubletZ(id), m_rpcIdHelper->doubletPhi(id), 
                                                m_rpcIdHelper->gasGap(id), false, 1);
            } case TGC: {
               return m_tgcIdHelper->channelID(id, m_tgcIdHelper->gasGap(id), false, 1); 
            } case CSC: {
                return m_cscIdHelper->channelID(id, m_cscIdHelper->chamberLayer(id), m_cscIdHelper->wireLayer(id), 1, 1);
            } case STGC: {
                return m_stgcIdHelper->channelID(id, m_stgcIdHelper->multilayer(id), m_stgcIdHelper->gasGap(id), 
                                                 sTgcIdHelper::sTgcChannelTypes::Strip, 1);
            } case MM: {
                return m_mmIdHelper->channelID(id, m_mmIdHelper->multilayer(id), m_mmIdHelper->gasGap(id), 1);
            } default: 
                break;
        }
        return id;
    }

hasCSC()

bool Muon::MuonIdHelperSvc::hasCSC ( ) const

override

Definition at line 549 of file MuonIdHelperSvc.cxx.

{ return m_hasCSC; }

hasHPTDC()

bool Muon::MuonIdHelperSvc::hasHPTDC ( const Identifier & id ) const

overridevirtual

returns whether this Identifier belongs to an MDT with HPTDC or not NOTE that in Run4, no HPTDCs at all are planned to be present any more, so this function should be obsolete from Run4 onwards

NOTE that in Run4, no HPTDCs at all are planned to be present any more, so this function should be obsolete from Run4 onwards

Definition at line 246 of file MuonIdHelperSvc.cxx.

                                                             {
        // the remaining sMDTs (installed in BI in LS1) all have an HPTDC in Run3
        // all BME sMDTs have no HPTDC
        return issMdt(id) && !m_mdtIdHelper->isBME(id);
    }

hasMDT()

bool Muon::MuonIdHelperSvc::hasMDT ( ) const

override

Definition at line 548 of file MuonIdHelperSvc.cxx.

{ return m_mdtIdHelper != nullptr; }

hasMM()

bool Muon::MuonIdHelperSvc::hasMM ( ) const

override

Definition at line 551 of file MuonIdHelperSvc.cxx.

{ return m_hasMM; }

hasRPC()

bool Muon::MuonIdHelperSvc::hasRPC ( ) const

override

Definition at line 546 of file MuonIdHelperSvc.cxx.

{ return m_rpcIdHelper != nullptr; }

hasSTGC()

bool Muon::MuonIdHelperSvc::hasSTGC ( ) const

override

Definition at line 550 of file MuonIdHelperSvc.cxx.

{ return m_hasSTGC; }

hasTGC()

bool Muon::MuonIdHelperSvc::hasTGC ( ) const

override

Definition at line 547 of file MuonIdHelperSvc.cxx.

{ return m_tgcIdHelper != nullptr; }

initialize()

StatusCode Muon::MuonIdHelperSvc::initialize ( )

overridevirtual

AlgTool initilize.

Find an id helper that is not a nullptr

Cache the sMDT stations

Definition at line 18 of file MuonIdHelperSvc.cxx.

                                           {
        ATH_CHECK(m_detStore.retrieve());
        if (m_hasMDT) ATH_CHECK(m_detStore->retrieve(m_mdtIdHelper));
        if (m_hasRPC) ATH_CHECK(m_detStore->retrieve(m_rpcIdHelper));
        if (m_hasTGC) ATH_CHECK(m_detStore->retrieve(m_tgcIdHelper));
        if (m_hasCSC) ATH_CHECK(m_detStore->retrieve(m_cscIdHelper));       
        if (m_hasSTGC) ATH_CHECK(m_detStore->retrieve(m_stgcIdHelper));
        if (m_hasMM) ATH_CHECK(m_detStore->retrieve(m_mmIdHelper));
       
        using AllHelperArray = std::array<const MuonIdHelper*, 6>; 
        const AllHelperArray allHelpers{m_mdtIdHelper, m_rpcIdHelper, m_tgcIdHelper,
                                         m_cscIdHelper, m_stgcIdHelper, m_mmIdHelper};
        AllHelperArray::const_iterator itr = std::ranges::find_if(allHelpers,
                                                          [](const MuonIdHelper* h){return h != nullptr;});
        if (itr == allHelpers.end()){
            ATH_MSG_WARNING("No MuonIdHelper has been created before. Please do not setup the service if no muon layout is loaded");
            return StatusCode::SUCCESS;
        }                
        m_primaryHelper = (*itr);
 
        std::stringstream techStr{};
        
        for (int tech = 0; tech <= m_primaryHelper->technologyNameIndexMax(); ++tech) {
            std::string name = m_primaryHelper->technologyString(tech);
            
            if (name == "MDT") m_technologies.push_back(TechIdx::MDT);
            if (name == "CSC") m_technologies.push_back(TechIdx::CSC);
            if (name == "RPC") m_technologies.push_back(TechIdx::RPC);
            if (name == "TGC") m_technologies.push_back(TechIdx::TGC);
            if (name == "STGC") m_technologies.push_back(TechIdx::STGC);
            if (name == "MM") m_technologies.push_back(TechIdx::MM);
            techStr<< ", " << tech << " " << name;
        }
         ATH_MSG_DEBUG(" Technologies: size " << m_primaryHelper->technologyNameIndexMax()<<" "<<techStr.str());
       
        unsigned int nstationsNames = m_primaryHelper->stationNameIndexMax() + 1;
        m_stationNameData.resize(nstationsNames);
        for (int i = 0; i <= m_primaryHelper->stationNameIndexMax(); ++i) {
            std::string name = m_primaryHelper->stationNameString(i);
            if (name.compare(MuonIdHelper::BAD_NAME) == 0) continue;
 
            StationNameData& data = m_stationNameData[i];
 
            data.stationName = std::move(name);
            data.isEndcap = m_primaryHelper->isEndcap(i);
            data.isSmall = m_primaryHelper->isSmall(i);
 
            if (data.isEndcap) {
                if (data.stationName[1] == '1')
                    data.chIndex = ChIdx::EML;
                else if (data.stationName[1] == '2')
                    data.chIndex = ChIdx::EML;
                else if (data.stationName[1] == '3')
                    data.chIndex = ChIdx::EML;
                else if (data.stationName[1] == '4')
                    data.chIndex = ChIdx::EIL;
 
                if (data.stationName[1] == 'O') {
                    if (data.stationName[2] == 'L')
                        data.chIndex = ChIdx::EOL;
                    else
                        data.chIndex = ChIdx::EOS;
                } else if (data.stationName[1] == 'M') {
                    if (data.stationName[2] == 'L')
                        data.chIndex = ChIdx::EML;
                    else
                        data.chIndex = ChIdx::EMS;
                } else if (data.stationName[1] == 'I') {
                    if (data.stationName[2] == 'L')
                        data.chIndex = ChIdx::EIL;
                    else
                        data.chIndex = ChIdx::EIS;
                } else if (data.stationName[1] == 'E') {
                    if (data.stationName[0] == 'B') {
                        data.chIndex = ChIdx::BEE;
                    } else {
                        if (data.stationName[2] == 'L')
                            data.chIndex = ChIdx::EEL;
                        else
                            data.chIndex = ChIdx::EES;
                    }
                } else if (data.stationName[0] == 'C') {
                    if (data.stationName[2] == 'L')
                        data.chIndex = ChIdx::CSL;
                    else
                        data.chIndex = ChIdx::CSS;
                }
                if (data.stationName[0] == 'S' || data.stationName[0] == 'M') {
                    if (data.isSmall)
                        data.chIndex = ChIdx::EIS;
                    else
                        data.chIndex = ChIdx::EIL;
                }
 
            } else {
                if (data.stationName[1] == 'O') {
                    if (data.stationName[2] == 'L')
                        data.chIndex = ChIdx::BOL;
                    else
                        data.chIndex = ChIdx::BOS;
                } else if (data.stationName[1] == 'M') {
                    if (data.stationName[2] == 'L' || data.stationName[2] == 'E')
                        data.chIndex = ChIdx::BML;
                    else
                        data.chIndex = ChIdx::BMS;
                } else if (data.stationName[1] == 'I') {
                    if (data.stationName[2] == 'L' || data.stationName[2] == 'M' || data.stationName[2] == 'R')
                        data.chIndex = ChIdx::BIL;
                    else
                        data.chIndex = ChIdx::BIS;
                }
            }
            if (data.chIndex == ChIdx::ChUnknown) {
               ATH_MSG_ERROR("data.chIndex is negative in MuonIdHelperSvc::initialize ");
               return StatusCode::FAILURE;
            }
            data.stIndex = toStationIndex(data.chIndex);
 
            if (msgLvl(MSG::DEBUG)) {
                msg(MSG::DEBUG) << "Adding station " << i << " " << data.stationName << " ";
                if (data.isEndcap)
                    msg(MSG::DEBUG) << " Endcap, ";
                else
                    msg(MSG::DEBUG) << " Barrel, ";
                if (data.isSmall)
                    msg(MSG::DEBUG) << " Small, ";
                else
                    msg(MSG::DEBUG) << " Large, ";
 
                msg(MSG::DEBUG) << chName(data.chIndex) << "  " << stName(data.stIndex) << endmsg;
            }
        }
        // now, let's check if we are in the inner barrel layer, and if there are RPCs installed
        // if yes, the MDT chambers must be sMDTs
        if (m_mdtIdHelper && m_rpcIdHelper) {
            m_BIS_stat = m_mdtIdHelper->stationNameIndex("BIS");
            for (int eta = MdtIdHelper::stationEtaMin(true); eta <= MdtIdHelper::stationEtaMax(true); ++eta) {
                for (int phi = 1; phi <= 8; ++phi) {
                    // now, let's check if we are in the inner barrel layer, and if there are RPCs installed
                    // if yes, the MDT chambers must be sMDTs
                    // now try to retrieve RPC identifier with the same station name/eta/phi and check if it is valid
                    bool isValid = false;
                    m_rpcIdHelper->elementID(m_BIS_stat, eta, phi, 1, isValid);
                    // last 4 arguments are: doubletR, check, isValid
                    // there is a BI RPC in the same station, thus, this station was already upgraded and sMDTs are present
                    if (!isValid) continue;
                    m_smdt_stat.emplace(m_mdtIdHelper->elementID(m_BIS_stat, eta, phi));
                }
            }
        }
 
        std::ranges::for_each(allHelpers, [this](const MuonIdHelper* idHelper){
            if (!idHelper) return;
            const TechIdx techIdx = technologyIndex(*idHelper->module_begin());
            for (auto itr = idHelper->module_begin(); itr != idHelper->module_end(); ++itr) {
                const auto idx = toStationIndex(chamberIndex(*itr));
                if (idx == StIndex::StUnknown) continue;
                m_techPerStation[toInt(idx)].insert(techIdx);
            }
        }); 
 
        ATH_MSG_DEBUG("Configured the service with the following flags --- hasMDT: "<< hasMDT()<<" hasRPC: "<<hasRPC()
                      <<" hasTGC"<< hasTGC() << " hasCSC: "<< hasCSC() << " hasSTGC: " << hasSTGC() << " hasMM: " << hasMM() );
        return StatusCode::SUCCESS;
    }

isCsc()

bool Muon::MuonIdHelperSvc::isCsc ( const Identifier & id ) const

overridevirtual

returns whether this is a CSC Identifier or not

Definition at line 216 of file MuonIdHelperSvc.cxx.

                                                          {
        return m_cscIdHelper && m_cscIdHelper->is_csc(id);
    }

isEndcap()

bool Muon::MuonIdHelperSvc::isEndcap ( const Identifier & id ) const

overridevirtual

returns whether this is an endcap Identifier or not

Definition at line 258 of file MuonIdHelperSvc.cxx.

{ return m_primaryHelper->isEndcap(id); }

isMdt()

bool Muon::MuonIdHelperSvc::isMdt ( const Identifier & id ) const

overridevirtual

returns whether this is a MDT Identifier or not

Definition at line 210 of file MuonIdHelperSvc.cxx.

                                                          {
        return m_mdtIdHelper && m_mdtIdHelper->is_mdt(id);
    }

isMM()

bool Muon::MuonIdHelperSvc::isMM ( const Identifier & id ) const

overridevirtual

returns whether this is a MM Identifier or not

Definition at line 213 of file MuonIdHelperSvc.cxx.

                                                         {
        return m_mmIdHelper && m_mmIdHelper->is_mm(id);
    }

isMuon()

bool Muon::MuonIdHelperSvc::isMuon ( const Identifier & id ) const

overridevirtual

returns whether this is a Muon Identifier or not

Definition at line 207 of file MuonIdHelperSvc.cxx.

                                                           { 
        return m_primaryHelper && m_primaryHelper->is_muon(id); 
    }

isRpc()

bool Muon::MuonIdHelperSvc::isRpc ( const Identifier & id ) const

overridevirtual

returns whether this is a RPC Identifier or not

Definition at line 219 of file MuonIdHelperSvc.cxx.

                                                          {
        return m_rpcIdHelper && m_rpcIdHelper->is_rpc(id);
    }

isSmallChamber()

bool Muon::MuonIdHelperSvc::isSmallChamber ( const Identifier & id ) const

overridevirtual

returns whether this is a small chamber, always returns true for TGCs

Definition at line 259 of file MuonIdHelperSvc.cxx.

{ return m_primaryHelper->isSmall(id); }

issMdt()

bool Muon::MuonIdHelperSvc::issMdt ( const Identifier & id ) const

overridevirtual

returns whether this is a sMDT Identifier or not

Definition at line 236 of file MuonIdHelperSvc.cxx.

                                                           {
        if (!isMdt(id)) {
            return false;
        }
        if (stationName(id) == m_BIS_stat) {
            return m_smdt_stat.find(m_mdtIdHelper->elementID(id)) != m_smdt_stat.end();
        }
        return m_mdtIdHelper->isBME(id) || m_mdtIdHelper->isBMG(id);
    }

issTgc()

bool Muon::MuonIdHelperSvc::issTgc ( const Identifier & id ) const

overridevirtual

returns whether this is a sTGC Identifier or not

Definition at line 227 of file MuonIdHelperSvc.cxx.

                                                           {
        return m_stgcIdHelper && m_stgcIdHelper->is_stgc(id);
    }

isTgc()

bool Muon::MuonIdHelperSvc::isTgc ( const Identifier & id ) const

overridevirtual

returns whether this is a TGC Identifier or not

Definition at line 223 of file MuonIdHelperSvc.cxx.

                                                          {
        return m_tgcIdHelper && m_tgcIdHelper->is_tgc(id);
    }

isTrigger()

bool Muon::MuonIdHelperSvc::isTrigger ( const Identifier & id ) const

overridevirtual

returns whether trigger chamber id or not

Definition at line 254 of file MuonIdHelperSvc.cxx.

                                                              {
        return isRpc(id) || isTgc(id);
    }

layerId()

Identifier Muon::MuonIdHelperSvc::layerId ( const Identifier & id ) const

overridevirtual

create a layer ID, returns tube id for the MDTs

Return Identifier for the Mdts

Definition at line 475 of file MuonIdHelperSvc.cxx.

                                                                  {
        switch (technologyIndex(id)) {
            using enum TechnologyIndex;
            case TGC: {
                return m_tgcIdHelper->channelID(id, m_tgcIdHelper->gasGap(id), m_tgcIdHelper->measuresPhi(id), 1);
            } case RPC: {
                return m_rpcIdHelper->channelID(id, m_rpcIdHelper->doubletZ(id), m_rpcIdHelper->doubletPhi(id), 
                                                m_rpcIdHelper->gasGap(id), m_rpcIdHelper->measuresPhi(id), 1); 
            } case CSC: {
                return m_cscIdHelper->channelID(id, m_cscIdHelper->chamberLayer(id), m_cscIdHelper->wireLayer(id), 
                                                m_cscIdHelper->measuresPhi(id), 1);
            } case MM: {
                return m_mmIdHelper->channelID(id, m_mmIdHelper->multilayer(id), m_mmIdHelper->gasGap(id), 1);
            } case STGC: {
                return m_stgcIdHelper->channelID(id, m_stgcIdHelper->multilayer(id), 
                                                 m_stgcIdHelper->gasGap(id), m_stgcIdHelper->channelType(id), 1);
            } default:
                break;
        }
        return id;
    }

layerIndex()

LayerIndex Muon::MuonIdHelperSvc::layerIndex ( const Identifier & id ) const

overridevirtual

calculate layer index from Identifier

Definition at line 327 of file MuonIdHelperSvc.cxx.

                                                                     {
        return toLayerIndex(stationIndex(id));
    }

mdtIdHelper()

virtual const MdtIdHelper & Muon::MuonIdHelperSvc::mdtIdHelper ( ) const

inlineoverridevirtual

access to MdtIdHelper

Definition at line 108 of file MuonIdHelperSvc.h.

{ return *m_mdtIdHelper; }

measuresPhi()

virtual bool Muon::MuonIdHelperSvc::measuresPhi ( const Identifier & id ) const

overridevirtual

returns whether channel measures phi or not

mmIdHelper()

virtual const MmIdHelper & Muon::MuonIdHelperSvc::mmIdHelper ( ) const

inlineoverridevirtual

access to CscIdHelper

Definition at line 123 of file MuonIdHelperSvc.h.

{ return *m_mmIdHelper; }

moduleHash() [1/2]

IdentifierHash Muon::MuonIdHelperSvc::moduleHash ( const Identifier & id ) const

overridevirtual

Returns the module hash associated to an Identifier.

Definition at line 570 of file MuonIdHelperSvc.cxx.

                                                                         {
        switch (technologyIndex(id)){
            using enum MuonStationIndex::TechnologyIndex;
            case MDT: {
                return moduleHash(*m_mdtIdHelper, id);
            }
            case RPC: {
                return moduleHash(*m_rpcIdHelper, id);
            }
            case TGC: {
                return moduleHash(*m_tgcIdHelper, id);
            }
            case CSC: {
                return moduleHash(*m_cscIdHelper, id);
            }
            case STGC: {
                return moduleHash(*m_stgcIdHelper, id);
            }
            case MM: {
                return moduleHash(*m_mmIdHelper, id);
            }
            default:
                break;
        }
 
        ATH_MSG_WARNING("moduleHash(): No muon Identifier "<<id);
        return IdentifierHash{};
    }

moduleHash() [2/2]

IdentifierHash Muon::MuonIdHelperSvc::moduleHash ( const MuonIdHelper & idHelper, const Identifier & id ) const

inlineprivate

Definition at line 554 of file MuonIdHelperSvc.cxx.

                                                                                                             {
        IdentifierHash hash{};
        if (idHelper.get_module_hash(id, hash) ||
            static_cast<unsigned int>(hash) >= idHelper.module_hash_max()){
            ATH_MSG_VERBOSE("Failed to deduce module hash "<<toString(id));            
        }
        return hash;
    }

phiIndex()

PhiIndex Muon::MuonIdHelperSvc::phiIndex ( const Identifier & id ) const

overridevirtual

calculate phi index from Identifier (not supported for MDT hits)

Definition at line 277 of file MuonIdHelperSvc.cxx.

                                                                 {
#ifndef NDEBUG
        if (!id.is_valid() || !isMuon(id)) {
            if (id.is_valid()) ATH_MSG_WARNING("phiIndex: invalid ID " << m_primaryHelper->print_to_string(id));
            return PhiIdx::PhiUnknown;
        }
        if (isMdt(id) || isMM(id)) {
            ATH_MSG_WARNING("phiIndex: not supported for " << toString(id));
            return PhiIdx::PhiUnknown;
        }
#endif
        switch (stationIndex(id)) {
            case StIndex::BI:{
                return m_rpcIdHelper->doubletR(id) == 1 ?  PhiIdx::BI1 : PhiIdx::BI2;
            } case StIndex::BM: {
                return m_rpcIdHelper->doubletR(id) == 1 ? PhiIdx::BM1 : PhiIdx::BM2;
            } case StIndex::BO: {
                return m_rpcIdHelper->doubletR(id) == 1 ? PhiIdx::BO1 : PhiIdx::BO2;
            } case StIndex::EI: {
                switch (technologyIndex(id)) {
                    case TechIdx::CSC:
                        return PhiIdx::CSC;
                    case TechIdx::TGC:
                        return PhiIdx::T4;
                    case TechIdx::STGC:
                        return m_stgcIdHelper->multilayer(id) == 1 ? PhiIdx::STGC1 : PhiIdx::STGC2;
                    default:
                        break;
                }
                break;
            } case StIndex::EM: {
                const std::string chamberName = stationNameString(id);
                if (chamberName[1] == '1') {
                    return PhiIdx::T1;
                } else if (chamberName[1] == '2') {
                    return PhiIdx::T2;
                } else {
                    return PhiIdx::T3;
                }
            } default:
                break;
        }
        return PhiIdx::PhiUnknown;
    }

regionIndex()

DetectorRegionIndex Muon::MuonIdHelperSvc::regionIndex ( const Identifier & id ) const

overridevirtual

calculate detector region index from Identifier

Definition at line 322 of file MuonIdHelperSvc.cxx.

                                                                               {
        if (isEndcap(id)) return stationEta(id) < 0 ? DetectorRegionIndex::EndcapC : DetectorRegionIndex::EndcapA;
        return DetectorRegionIndex::Barrel;
    }

rpcIdHelper()

virtual const RpcIdHelper & Muon::MuonIdHelperSvc::rpcIdHelper ( ) const

inlineoverridevirtual

access to RpcIdHelper

Definition at line 111 of file MuonIdHelperSvc.h.

{ return *m_rpcIdHelper; }

sector()

int Muon::MuonIdHelperSvc::sector ( const Identifier & id ) const

overridevirtual

return sector number 1-16, odd=large, even=small

Definition at line 518 of file MuonIdHelperSvc.cxx.

                                                          {
        // TGC has different segmentation, return 0 for the moment
        if (isTgc(id)) {
            auto initTgcSectorMapping = [&]() -> std::vector<int>* {
                std::vector<int>* mapping = nullptr;
                StatusCode sc = m_detStore->retrieve(mapping, "TGC_SectorMapping");
                if (sc.isFailure() || !mapping) {
                    ATH_MSG_WARNING("sector: failed to retrieve TGC sector mapping");
                    return nullptr;
                }
                ATH_MSG_DEBUG("sector: retrieve TGC sector mapping " << mapping->size());
                return mapping;
            };
            static const std::vector<int> tgcSectorMapping = *initTgcSectorMapping();
 
            IdentifierHash hash;
            m_tgcIdHelper->get_module_hash(id, hash);
            if (hash >= tgcSectorMapping.size()) {
                ATH_MSG_WARNING("sector: TGC not yet supported");
                return 0;
            }
            return tgcSectorMapping[hash];
        }
        int sect = 2 * stationPhi(id);
        if (!isSmallChamber(id)) --sect;
        return sect;
    }

stationEta()

virtual int Muon::MuonIdHelperSvc::stationEta ( const Identifier & id ) const

overridevirtual

Return stationEta for all technologies.

stationIndex()

StIndex Muon::MuonIdHelperSvc::stationIndex ( const Identifier & id ) const

overridevirtual

calculate station index from Identifier

Definition at line 269 of file MuonIdHelperSvc.cxx.

                                                                    {
        if (!id.is_valid() || !isMuon(id)) {
            if (id.is_valid()) ATH_MSG_WARNING("stationIndex: invalid ID " << m_primaryHelper->print_to_string(id));
            return StIdx::StUnknown;
        }
        return m_stationNameData[stationName(id)].stIndex;
    }

stationName()

virtual int Muon::MuonIdHelperSvc::stationName ( const Identifier & id ) const

overridevirtual

Return stationName for all technologies.

stationNameString()

virtual std::string Muon::MuonIdHelperSvc::stationNameString ( const Identifier & id ) const

overridevirtual

Return the station name string for all technologies.

stationPhi()

virtual int Muon::MuonIdHelperSvc::stationPhi ( const Identifier & id ) const

overridevirtual

Return stationPhi for all technologies.

stationRegion()

virtual int Muon::MuonIdHelperSvc::stationRegion ( const Identifier & id ) const

overridevirtual

Return stationRegion for all technologies.

stgcIdHelper()

virtual const sTgcIdHelper & Muon::MuonIdHelperSvc::stgcIdHelper ( ) const

inlineoverridevirtual

access to TgcIdHelper

Definition at line 120 of file MuonIdHelperSvc.h.

{ return *m_stgcIdHelper; }

technologiesInStation()

const std::set< TechnologyIndex > & Muon::MuonIdHelperSvc::technologiesInStation ( MuonStationIndex::StIndex stIndex ) const

overridevirtual

Recieve all technologies in a station.

Definition at line 232 of file MuonIdHelperSvc.cxx.

                                                                    {
        assert(toInt(stIndex) < static_cast<int>(m_techPerStation.size()));
        return m_techPerStation[toInt(stIndex)];
    }

technologyIndex()

TechnologyIndex Muon::MuonIdHelperSvc::technologyIndex ( const Identifier & id ) const

overridevirtual

calculate layer index from Identifier

Definition at line 331 of file MuonIdHelperSvc.cxx.

                                                                               {
        if (isMdt(id)) return TechIdx::MDT;   
        else if (issTgc(id)) return TechIdx::STGC;
        else if (isMM(id)) return TechIdx::MM;     
        else if (isTgc(id)) return TechIdx::TGC;
        else if (isRpc(id)) return TechIdx::RPC;
        else if (isCsc(id)) return TechIdx::CSC;
        return TechIdx::TechnologyUnknown;
    }

tgcIdHelper()

virtual const TgcIdHelper & Muon::MuonIdHelperSvc::tgcIdHelper ( ) const

inlineoverridevirtual

access to TgcIdHelper

Definition at line 114 of file MuonIdHelperSvc.h.

{ return *m_tgcIdHelper; }

toString()

std::string Muon::MuonIdHelperSvc::toString ( const Identifier & id ) const

overridevirtual

print all fields to string

Definition at line 340 of file MuonIdHelperSvc.cxx.

                                                                  {
        if (!id.is_valid()) return " Invalid Identifier";
        switch (technologyIndex(id)) {
            using enum TechnologyIndex;
            case MDT:{
                return toStringGasGap(id);
            } case RPC: {
                return std::format("{:} {:} channel {:2d}", toStringGasGap(id), 
                                   measuresPhi(id) ? "phi" : "eta", m_rpcIdHelper->channel(id));
            } case TGC: {
                return std::format("{:} {:} channel {:2d}", toStringGasGap(id), 
                                   measuresPhi(id) ? "phi" : "eta",  m_tgcIdHelper->channel(id));
            } case CSC: {
                return std::format("{:} {:} channel {:2d}", toStringGasGap(id), 
                                   measuresPhi(id) ? "phi" : "eta",  m_cscIdHelper->channel(id));
            } case STGC: {
                using sTgcType = sTgcIdHelper::sTgcChannelTypes;
                const int channelType = m_stgcIdHelper->channelType(id);
                return std::format("{:} {:} channel {:3d}", toStringGasGap(id), 
                                    channelType == sTgcType::Strip ? "eta" : channelType == sTgcType::Wire ? "phi" : "pad" ,
                                    m_stgcIdHelper->channel(id));
            } case MM: {
                return std::format("{:} channel {:4d}",toStringGasGap(id),  m_mmIdHelper->channel(id));
            } default:
                break;
        }
        return {};
    }

toStringChamber()

std::string Muon::MuonIdHelperSvc::toStringChamber ( const Identifier & id ) const

overridevirtual

print all fields up to chamber to string

Definition at line 381 of file MuonIdHelperSvc.cxx.

                                                                         {
        if (!id.is_valid()) {
            return " Invalid Identifier";
        }
        if (isRpc(id)) {
            return std::format("{:} dbR {:1}", toStringStation(id), m_rpcIdHelper->doubletR(id));
        }
        return toStringStation(id);
    }

toStringDetEl()

std::string Muon::MuonIdHelperSvc::toStringDetEl ( const Identifier & id ) const

overridevirtual

print all fields up to detector element to string

Definition at line 391 of file MuonIdHelperSvc.cxx.

                                                                       {
        switch (technologyIndex(id)) {
            using enum TechnologyIndex;
            case MDT: {
                return std::format("{:} ml {:1d}", toStringChamber(id), m_mdtIdHelper->multilayer(id));
            } case RPC: {
                return std::format("{:} dbZ {:1d} dbPhi {:1d}", toStringChamber(id), m_rpcIdHelper->doubletZ(id), m_rpcIdHelper->doubletPhi(id));
            } case TGC: {
                return toStringChamber(id);
            } case CSC: {
                return std::format("{:} chlay {:1d}",toStringChamber(id), m_cscIdHelper->chamberLayer(id));
            } case STGC: {
                return std::format("{:} chlay {:1d}",toStringChamber(id), m_stgcIdHelper->multilayer(id));
            } case MM: {
                return std::format("{:} chlay {:1d}",toStringChamber(id), m_mmIdHelper->multilayer(id));
            } default:
                break;
        }
        return "Invalid detector element";
    }

toStringGasGap()

std::string Muon::MuonIdHelperSvc::toStringGasGap ( const Identifier & id ) const

overridevirtual

print all fields up to gas gap to string

Definition at line 412 of file MuonIdHelperSvc.cxx.

                                                                        {
        switch (technologyIndex(id)) {
            using enum TechnologyIndex;
            case MDT: {
                return std::format("{:} lay {:1d} tube {:1d}", toStringDetEl(id),
                                   m_mdtIdHelper->tubeLayer(id), m_mdtIdHelper->tube(id));
            } case RPC:
              case TGC: {
                return std::format("{:} gap {:1d}", toStringDetEl(id), gasGap(id)); 
            } case STGC:
              case MM:
              case CSC: {
                return std::format("{:} lay {:1d}", toStringDetEl(id), gasGap(id));
            } default:
                break;
        }
        return "invalid gas gap Id";
    }

toStringStation()

std::string Muon::MuonIdHelperSvc::toStringStation ( const Identifier & id ) const

overridevirtual

print all fields up to stationName to string

Definition at line 377 of file MuonIdHelperSvc.cxx.

                                                                         {
        return std::format("{:} {:} eta {:2d} phi {:2d}", toStringTech(id),stationNameString(id),
                                                          stationEta(id), stationPhi(id));
    }

toStringTech()

std::string Muon::MuonIdHelperSvc::toStringTech ( const Identifier & id ) const

overridevirtual

print all fields up to technology to string

Definition at line 369 of file MuonIdHelperSvc.cxx.

                                                                      {
        return  technologyName(technologyIndex(id));
    }

Member Data Documentation

m_BIS_stat

int Muon::MuonIdHelperSvc::m_BIS_stat {-1}

private

Definition at line 215 of file MuonIdHelperSvc.h.

{-1};

m_cscIdHelper

const CscIdHelper* Muon::MuonIdHelperSvc::m_cscIdHelper {nullptr}

private

Definition at line 185 of file MuonIdHelperSvc.h.

{nullptr};

m_detStore

ServiceHandle<StoreGateSvc> Muon::MuonIdHelperSvc::m_detStore {this, "DetectorStore", "DetectorStore"}

private

Definition at line 199 of file MuonIdHelperSvc.h.

{this, "DetectorStore", "DetectorStore"};

m_hasCSC

Gaudi::Property<bool> Muon::MuonIdHelperSvc::m_hasCSC {this, "HasCSC", true, "Specify whether current detector layout contains CSC chambers"}

private

Definition at line 195 of file MuonIdHelperSvc.h.

{this, "HasCSC", true, "Specify whether current detector layout contains CSC chambers"};

m_hasMDT

Gaudi::Property<bool> Muon::MuonIdHelperSvc::m_hasMDT {this, "HasMDT", true, "Specify whether the current detector layour contains MDT chambers"}

private

Definition at line 192 of file MuonIdHelperSvc.h.

{this, "HasMDT", true, "Specify whether the current detector layour contains MDT chambers"};

m_hasMM

Gaudi::Property<bool> Muon::MuonIdHelperSvc::m_hasMM {this, "HasMM", true, "Specify whether current detector layout contains MicroMegas chambers"}

private

Definition at line 197 of file MuonIdHelperSvc.h.

{this, "HasMM", true, "Specify whether current detector layout contains MicroMegas chambers"};

m_hasRPC

Gaudi::Property<bool> Muon::MuonIdHelperSvc::m_hasRPC {this, "HasRPC", true, "Specify whether the current detector layour contains RPC chambers"}

private

Definition at line 193 of file MuonIdHelperSvc.h.

{this, "HasRPC", true, "Specify whether the current detector layour contains RPC chambers"};

m_hasSTGC

Gaudi::Property<bool> Muon::MuonIdHelperSvc::m_hasSTGC {this, "HasSTGC", true, "Specify whether current detector layout contains STGC chambers"}

private

Definition at line 196 of file MuonIdHelperSvc.h.

{this, "HasSTGC", true, "Specify whether current detector layout contains STGC chambers"};

m_hasTGC

Gaudi::Property<bool> Muon::MuonIdHelperSvc::m_hasTGC {this, "HasTGC", true, "Specify whether the current detector layour contains TGC chambers"}

private

Definition at line 194 of file MuonIdHelperSvc.h.

{this, "HasTGC", true, "Specify whether the current detector layour contains TGC chambers"};        

m_mdtIdHelper

const MdtIdHelper* Muon::MuonIdHelperSvc::m_mdtIdHelper {nullptr}

private

Definition at line 186 of file MuonIdHelperSvc.h.

{nullptr};

m_mmIdHelper

const MmIdHelper* Muon::MuonIdHelperSvc::m_mmIdHelper {nullptr}

private

Definition at line 187 of file MuonIdHelperSvc.h.

{nullptr};

m_primaryHelper

const MuonIdHelper* Muon::MuonIdHelperSvc::m_primaryHelper {nullptr}

private

Definition at line 190 of file MuonIdHelperSvc.h.

{nullptr};

m_rpcIdHelper

const RpcIdHelper* Muon::MuonIdHelperSvc::m_rpcIdHelper {nullptr}

private

Sub detector specific IdHelpers.

Definition at line 183 of file MuonIdHelperSvc.h.

{nullptr};

m_smdt_stat

std::unordered_set<Identifier> Muon::MuonIdHelperSvc::m_smdt_stat {}

private

Definition at line 216 of file MuonIdHelperSvc.h.

{};

m_stationNameData

std::vector<StationNameData> Muon::MuonIdHelperSvc::m_stationNameData {}

private

Definition at line 212 of file MuonIdHelperSvc.h.

{};

m_stgcIdHelper

const sTgcIdHelper* Muon::MuonIdHelperSvc::m_stgcIdHelper {nullptr}

private

Definition at line 188 of file MuonIdHelperSvc.h.

{nullptr};

m_technologies

std::vector<TechIdx> Muon::MuonIdHelperSvc::m_technologies {}

private

Definition at line 213 of file MuonIdHelperSvc.h.

{};

m_techPerStation

std::array<std::set<TechIdx>, static_cast<int>(StIdx::StIndexMax)> Muon::MuonIdHelperSvc::m_techPerStation {}

private

Array holding which technologies are there per station.

Definition at line 218 of file MuonIdHelperSvc.h.

{};

m_tgcIdHelper

const TgcIdHelper* Muon::MuonIdHelperSvc::m_tgcIdHelper {nullptr}

private

Definition at line 184 of file MuonIdHelperSvc.h.

{nullptr};

---

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

• MuonIdHelperSvc.h
• MuonIdHelperSvc.cxx