MuonTGC_Cabling::TGCCabling Class Reference

#include <TGCCabling.h>

Inheritance diagram for MuonTGC_Cabling::TGCCabling:

Classes
struct	Config

Public Types
enum	MAXMINREADOUTIDS {   MAXRODID = 12 , MINRODID = 1 , MAXSRODID = 3 , MINSRODID = 1 ,   MAXSSWID = 9 , MINSSWID = 0 , MAXSBLOC = 31 , MINSBLOC = 0 ,   MINCHANNELID = 40 , MAXCHANNELID = 199 }

Public Member Functions
	TGCCabling (const TGCCabling &)=delete
TGCCabling &	operator= (const TGCCabling &)=delete
	TGCCabling (const Config &cfg)
virtual	~TGCCabling ()
std::unique_ptr< TGCChannelId >	getASDOutChannel (const TGCChannelId &slb_in) const
const TGCModuleId *	getSLBFromReadout (TGCId::SideType side, int rodId, int sswId, int sbLoc) const
std::unique_ptr< TGCModuleId >	getSLBFromRxId (TGCId::SideType side, int rodId, int sswId, int rxId) const
bool	getReadoutFromSLB (const TGCModuleSLB &slb, TGCId::SideType &side, int &rodId, int &sswId, int &sbLoc) const
std::unique_ptr< TGCChannelId >	getASDOutFromReadout (TGCId::SideType side, int rodId, int sswId, int sbLoc, int channel, bool orChannel=false) const
bool	getReadoutFromASDOut (const TGCChannelASDOut &asdout, TGCId::SideType &side, int &rodId, int &sswId, int &sbLoc, int &channel, bool orChannel=false) const
bool	getHighPtIDFromReadout (TGCId::SideType side, int rodId, int sswId, int sbLoc, int channel, TGCId::SignalType &signal, TGCId::RegionType &region, int &sectorInReadout, int &hpbId, int &block, int &hitId, int &pos) const
bool	getReadoutFromHighPtID (TGCId::SideType side, int rodId, int &sswId, int &sbLoc, int &channel, TGCId::SignalType signal, TGCId::RegionType region, int sectorInReadout, int hpbId, int block, int hitId, int pos, TGCId::ModuleType moduleType, bool orChannel) const
bool	getReadoutFromLowPtCoincidence (TGCId::SideType side, int rodId, int sswId, int sbLoc, int &channel, int block, int pos, bool middle=false) const
std::unique_ptr< TGCChannelId >	getChannel (const TGCChannelId &channelId, TGCChannelId::ChannelIdType type, bool orChannel=false) const
TGCModuleMap	getModule (const TGCModuleId &moduleId, TGCModuleId::ModuleIdType type) const

Private Member Functions
int	getIndexFromReadoutWithoutChannel (const TGCId::SideType side, const int rodId, const int sswId, const int sbLoc) const

Private Attributes
std::unique_ptr< TGCCableInASD >	m_cableInASD {}
std::unique_ptr< TGCCableASDToPP >	m_cableASDToPP {}
std::unique_ptr< TGCCableInPP >	m_cableInPP {}
std::unique_ptr< TGCCablePPToSLB >	m_cablePPToSLB {}
std::unique_ptr< TGCCableInSLB >	m_cableInSLB {}
std::unique_ptr< TGCCableSLBToHPB >	m_cableSLBToHPB {}
std::unique_ptr< TGCCableHPBToSL >	m_cableHPBToSL {}
std::unique_ptr< TGCCableSLBToSSW >	m_cableSLBToSSW {}
std::unique_ptr< TGCCableSSWToROD >	m_cableSSWToROD {}
std::map< int, std::unique_ptr< TGCModuleId > > m_slbModuleIdMap	ATLAS_THREAD_SAFE
std::mutex	m_mutex

Detailed Description

Definition at line 32 of file TGCCabling.h.

Member Enumeration Documentation

MAXMINREADOUTIDS

enum MuonTGC_Cabling::TGCCabling::MAXMINREADOUTIDS

Enumerator
MAXRODID
MINRODID
MAXSRODID
MINSRODID
MAXSSWID
MINSSWID
MAXSBLOC
MINSBLOC
MINCHANNELID
MAXCHANNELID

Definition at line 51 of file TGCCabling.h.

                          {
        MAXRODID = 12,
        MINRODID = 1,
        MAXSRODID = 3,
        MINSRODID = 1,
        MAXSSWID = 9,
        MINSSWID = 0,
        MAXSBLOC = 31,
        MINSBLOC = 0,
        MINCHANNELID = 40,
        MAXCHANNELID = 199
    };

Constructor & Destructor Documentation

TGCCabling() [1/2]

MuonTGC_Cabling::TGCCabling::TGCCabling ( const TGCCabling & )

delete

TGCCabling() [2/2]

MuonTGC_Cabling::TGCCabling::TGCCabling

(

const Config &

cfg

)

Definition at line 26 of file TGCCabling.cxx.

    : m_cableInASD{std::make_unique<TGCCableInASD>(cfg.fileNameASDtoPP)},
      m_cableASDToPP{std::make_unique<TGCCableASDToPP>(
          cfg.fileNameASDtoPP, cfg.fileNameASDtoPPdiff)},
      m_cableInPP{std::make_unique<TGCCableInPP>(cfg.fileNameInPP)},
      m_cablePPToSLB{std::make_unique<TGCCablePPToSLB>(cfg.fileNamePPtoSL)},
      m_cableInSLB{std::make_unique<TGCCableInSLB>()},
      m_cableSLBToHPB{std::make_unique<TGCCableSLBToHPB>(cfg.fileNamePPtoSL)},
      m_cableHPBToSL{std::make_unique<TGCCableHPBToSL>(cfg.fileNamePPtoSL)},
      m_cableSLBToSSW{std::make_unique<TGCCableSLBToSSW>(cfg.fileNameSLBtoROD)},
      m_cableSSWToROD{
          std::make_unique<TGCCableSSWToROD>(cfg.fileNameSLBtoROD)} {}

~TGCCabling()

MuonTGC_Cabling::TGCCabling::~TGCCabling ( )

virtualdefault

Member Function Documentation

getASDOutChannel()

std::unique_ptr< TGCChannelId > MuonTGC_Cabling::TGCCabling::getASDOutChannel

(

const TGCChannelId &

slb_in

)

const

Definition at line 41 of file TGCCabling.cxx.

                                  {
    TGCChannelSLBIn slb_in(in.getSideType(), in.getModuleType(),
                           in.getRegionType(), in.getSector(), in.getId(),
                           in.getChannel());
    return getChannel(slb_in, TGCChannelId::ChannelIdType::ASDOut);
}

getASDOutFromReadout()

std::unique_ptr< TGCChannelId > MuonTGC_Cabling::TGCCabling::getASDOutFromReadout	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	sbLoc,
		int	channel,
		bool	orChannel = false ) const

Definition at line 354 of file TGCCabling.cxx.

                          {
    const TGCModuleId* slb = getSLBFromReadout(side, rodId, sswId, sbLoc);
    if (!slb) {
        return nullptr;
    }
 
    TGCChannelSLBIn slbin(slb->getSideType(), slb->getModuleType(),
                          slb->getRegionType(), slb->getSector(), slb->getId(),
                          channel);
    if (!slbin.isValid()) {
        return nullptr;
    }
 
    return getChannel(slbin, TGCChannelId::ChannelIdType::ASDOut, orChannel);
}

getChannel()

std::unique_ptr< TGCChannelId > MuonTGC_Cabling::TGCCabling::getChannel	(	const TGCChannelId &	channelId,
		TGCChannelId::ChannelIdType	type,
		bool	orChannel = false ) const

Definition at line 403 of file TGCCabling.cxx.

                          {
    switch (channelId.getChannelIdType()) {
        case TGCChannelId::ChannelIdType::ASDIn:
            if (type == TGCChannelId::ChannelIdType::ASDOut) {
                return m_cableInASD->getChannel(channelId, orChannel);
            }
            if (type == TGCChannelId::ChannelIdType::SLBIn) {
                std::unique_ptr<TGCChannelId> asdout =
                    m_cableInASD->getChannel(channelId, false);
                if (!asdout || !asdout->isValid()) {
 
                    return nullptr;
                }
                std::unique_ptr<TGCChannelId> ppin =
                    m_cableASDToPP->getChannel(*asdout, false);
                if (!ppin || !ppin->isValid()) {
                    return nullptr;
                }
                std::unique_ptr<TGCChannelId> ppout =
                    m_cableInPP->getChannel(*ppin, orChannel);
                if (!ppout || !ppout->isValid()) {
 
                    return nullptr;
                }
                return m_cablePPToSLB->getChannel(*ppout, false);
            }
            break;
        case TGCChannelId::ChannelIdType::ASDOut:
            if (type == TGCChannelId::ChannelIdType::ASDIn) {
                return m_cableInASD->getChannel(channelId, orChannel);
            }
            if (type == TGCChannelId::ChannelIdType::PPIn) {
                return m_cableASDToPP->getChannel(channelId, orChannel);
            }
            if (type == TGCChannelId::ChannelIdType::SLBIn) {
                std::unique_ptr<TGCChannelId> ppin =
                    m_cableASDToPP->getChannel(channelId, false);
                if (!ppin || !ppin->isValid()) {
 
                    return nullptr;
                }
                std::unique_ptr<TGCChannelId> ppout =
                    m_cableInPP->getChannel(*ppin, orChannel);
                if (!ppout || !ppout->isValid()) {
 
                    return nullptr;
                }
                return m_cablePPToSLB->getChannel(*ppout, false);
            }
            break;
        case TGCChannelId::ChannelIdType::PPIn:
            if (type == TGCChannelId::ChannelIdType::ASDOut) {
                return m_cableASDToPP->getChannel(channelId, orChannel);
            }
            if (type == TGCChannelId::ChannelIdType::PPOut) {
                return m_cableInPP->getChannel(channelId, orChannel);
            }
            break;
        case TGCChannelId::ChannelIdType::PPOut:
            if (type == TGCChannelId::ChannelIdType::PPIn) {
                return m_cableInPP->getChannel(channelId, orChannel);
            }
            if (type == TGCChannelId::ChannelIdType::SLBIn) {
                return m_cablePPToSLB->getChannel(channelId, orChannel);
            }
            break;
        case TGCChannelId::ChannelIdType::SLBIn:
            if (type == TGCChannelId::ChannelIdType::SLBOut) {
                return m_cableInSLB->getChannel(channelId, orChannel);
            }
            if (type == TGCChannelId::ChannelIdType::HPBIn) {
                std::unique_ptr<TGCChannelId> slbout =
                    m_cableInSLB->getChannel(channelId, orChannel);
                if (!slbout || !slbout->isValid()) {
 
                    return nullptr;
                }
                return m_cableSLBToHPB->getChannel(*slbout, false);
            }
            if (type == TGCChannelId::ChannelIdType::PPOut) {
                return m_cablePPToSLB->getChannel(channelId, orChannel);
            }
            if (type == TGCChannelId::ChannelIdType::ASDOut) {
                std::unique_ptr<TGCChannelId> ppout =
                    m_cablePPToSLB->getChannel(channelId, false);
                if (!ppout || !ppout->isValid()) {
 
                    return nullptr;
                }
                std::unique_ptr<TGCChannelId> ppin =
                    m_cableInPP->getChannel(*ppout, orChannel);
                if (!ppin || !ppin->isValid()) {
                    return nullptr;
                }
                return m_cableASDToPP->getChannel(*ppin, false);
            }
            if (type == TGCChannelId::ChannelIdType::ASDIn) {
                std::unique_ptr<TGCChannelId> ppout =
                    m_cablePPToSLB->getChannel(channelId, false);
                if (!ppout || !ppout->isValid()) {
                    return nullptr;
                }
                std::unique_ptr<TGCChannelId> ppin =
                    m_cableInPP->getChannel(*ppout, orChannel);
                if (!ppin || !ppin->isValid()) {
                    return nullptr;
                }
                std::unique_ptr<TGCChannelId> asdout =
                    m_cableASDToPP->getChannel(*ppin, false);
                if (!asdout || !asdout->isValid()) {
                    return nullptr;
                }
                return m_cableInASD->getChannel(*asdout, false);
            }
            break;
        case TGCChannelId::ChannelIdType::SLBOut:
            if (type == TGCChannelId::ChannelIdType::SLBIn) {
                return m_cableInSLB->getChannel(channelId, orChannel);
            }
            if (type == TGCChannelId::ChannelIdType::HPBIn) {
                return m_cableSLBToHPB->getChannel(channelId, orChannel);
            }
            break;
        case TGCChannelId::ChannelIdType::HPBIn:
            if (type == TGCChannelId::ChannelIdType::SLBIn) {
                std::unique_ptr<TGCChannelId> slbout =
                    m_cableSLBToHPB->getChannel(channelId, false);
                if (!slbout || !slbout->isValid()) {
                    return nullptr;
                }
                return m_cableInSLB->getChannel(*slbout, orChannel);
            }
            if (type == TGCChannelId::ChannelIdType::SLBOut) {
                return m_cableSLBToHPB->getChannel(channelId, orChannel);
            }
            break;
        default:
            break;
    }
    return nullptr;
}

getHighPtIDFromReadout()

bool MuonTGC_Cabling::TGCCabling::getHighPtIDFromReadout	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	sbLoc,
		int	channel,
		TGCId::SignalType &	signal,
		TGCId::RegionType &	region,
		int &	sectorInReadout,
		int &	hpbId,
		int &	block,
		int &	hitId,
		int &	pos ) const

Definition at line 288 of file TGCCabling.cxx.

                                                        {
    signal = TGCId::NoSignalType;
    region = TGCId::NoRegionType;
    sectorInReadout = -1;
    hpbId = -1;
    block = -1;
    hitId = -1;
    pos = -1;
 
    const TGCModuleId* slb = getSLBFromReadout(side, rodId, sswId, sbLoc);
    if (!slb) {
        return 0;
    }
 
    TGCChannelSLBIn slbin(slb->getSideType(), slb->getModuleType(),
                          slb->getRegionType(), slb->getSector(), slb->getId(),
                          channel);
 
    std::unique_ptr<TGCChannelId> hpbin =
        getChannel(slbin, TGCChannelId::ChannelIdType::HPBIn, false);
    if (!hpbin || !hpbin->isValid()) {
        return false;
    }
    signal = hpbin->getSignalType();
    region = hpbin->getRegionType();
    sectorInReadout = hpbin->getSectorInReadout();
    hpbId = hpbin->getId();
    block = hpbin->getBlock();
    pos = hpbin->getChannel() % 2;
    hitId = (hpbin->getChannel() - pos) / 2;
 
    return true;
}

getIndexFromReadoutWithoutChannel()

int MuonTGC_Cabling::TGCCabling::getIndexFromReadoutWithoutChannel ( const TGCId::SideType side, const int rodId, const int sswId, const int sbLoc ) const

private

Definition at line 598 of file TGCCabling.cxx.

                                                                         {
    return ((((side - TGCId::Aside) * (MAXRODID - MINRODID + 1) + rodId -
              MINRODID) *
                 (MAXSSWID - MINSSWID + 1) +
             sswId - MINSSWID) *
                (MAXSBLOC - MINSBLOC + 1) +
            sbLoc - MINSBLOC);
}

getModule()

TGCModuleMap MuonTGC_Cabling::TGCCabling::getModule	(	const TGCModuleId &	moduleId,
		TGCModuleId::ModuleIdType	type ) const

Definition at line 547 of file TGCCabling.cxx.

                                                                       {
    switch (moduleId.getModuleIdType()) {
        case TGCModuleId::PP:
            if (type == TGCModuleId::SLB) {
                return m_cablePPToSLB->getModule(moduleId);
            }
            break;
        case TGCModuleId::SLB:
            if (type == TGCModuleId::PP) {
                return m_cablePPToSLB->getModule(moduleId);
            }
            if (type == TGCModuleId::HPB) {
                return m_cableSLBToHPB->getModule(moduleId);
            }
            if (type == TGCModuleId::SSW) {
                return m_cableSLBToSSW->getModule(moduleId);
            }
            break;
        case TGCModuleId::HPB:
            if (type == TGCModuleId::SLB) {
                return m_cableSLBToHPB->getModule(moduleId);
            }
            if (type == TGCModuleId::SL) {
                return m_cableHPBToSL->getModule(moduleId);
            }
            break;
        case TGCModuleId::SL:
            if (type == TGCModuleId::HPB) {
                return m_cableHPBToSL->getModule(moduleId);
            }
            break;
        case TGCModuleId::SSW:
            if (type == TGCModuleId::SLB) {
                return m_cableSLBToSSW->getModule(moduleId);
            }
            if (type == TGCModuleId::ROD) {
                return m_cableSSWToROD->getModule(moduleId);
            }
            break;
        case TGCModuleId::ROD:
            if (type == TGCModuleId::SSW) {
                return m_cableSSWToROD->getModule(moduleId);
            }
            break;
        default:
            break;
    }
    return TGCModuleMap{};
}

getReadoutFromASDOut()

bool MuonTGC_Cabling::TGCCabling::getReadoutFromASDOut	(	const TGCChannelASDOut &	asdout,
		TGCId::SideType &	side,
		int &	rodId,
		int &	sswId,
		int &	sbLoc,
		int &	channel,
		bool	orChannel = false ) const

Definition at line 373 of file TGCCabling.cxx.

                                                            {
    // initialize
    side = TGCId::NoSideType;
    rodId = -1;
    sswId = -1;
    sbLoc = -1;
    channel = -1;
 
    // SLBIn channel
    std::unique_ptr<TGCChannelId> slbin{
        getChannel(asdout, TGCChannelId::ChannelIdType::SLBIn, orChannel)};
 
    if (!slbin) {
        return false;
    }
    channel = slbin->getChannel();
 
    auto slb = slbin->getModule();
    if (!slb) {
        return false;
    }
 
    // SLB Module -> readout ID
    return getReadoutFromSLB(*static_cast<TGCModuleSLB*>(slb.get()), side,
                             rodId, sswId, sbLoc);
}

getReadoutFromHighPtID()

bool MuonTGC_Cabling::TGCCabling::getReadoutFromHighPtID	(	TGCId::SideType	side,
		int	rodId,
		int &	sswId,
		int &	sbLoc,
		int &	channel,
		TGCId::SignalType	signal,
		TGCId::RegionType	region,
		int	sectorInReadout,
		int	hpbId,
		int	block,
		int	hitId,
		int	pos,
		TGCId::ModuleType	moduleType,
		bool	orChannel ) const

Definition at line 221 of file TGCCabling.cxx.

                          {
    // initialize
    sswId = -1;
    sbLoc = -1;
    channel = -1;
 
    // get sector number
 
    int readoutSector = (rodId - 1);
    int sector = sectorInReadout;
    if (rodId < 13) {
        if (region == TGCId::Forward) {
            sector +=
                readoutSector * (TGCId::NUM_FORWARD_SECTOR / TGCId::N_RODS);
        } else {
            sector +=
                readoutSector * (TGCId::NUM_ENDCAP_SECTOR / TGCId::N_RODS);
        }
    } else if (rodId < 20) {
        readoutSector -= 16;
        if (region == TGCId::Forward) {
            sector += readoutSector * (TGCId::NUM_FORWARD_SECTOR /
                                       TGCModuleId::NumberOfSReadoutSector);
        } else {
            sector += readoutSector * (TGCId::NUM_ENDCAP_SECTOR /
                                       TGCModuleId::NumberOfSReadoutSector);
        }
    }
 
    TGCChannelHPBIn hpbin(side, signal, region, sector, hpbId, block,
                          hitId * 2 + pos);
    if (!hpbin.isValid()) {
        return false;
    }
 
    std::unique_ptr<TGCChannelId> slbout =
        m_cableSLBToHPB->getChannelInforHPB(hpbin, moduleType, false);
    if (!slbout || !slbout->isValid()) {
        return 0;
    }
    std::unique_ptr<TGCChannelId> slbin =
        m_cableInSLB->getChannel(*slbout, orChannel);
 
    if (!slbin) {
        return false;
    }
    channel = slbin->getChannel();
 
    auto slb = slbin->getModule();
    if (!slb) {
        return false;
    }
 
    // SLB Module -> readout ID
    TGCId::SideType sideType;
    int rodid;  // dummy
    bool status = getReadoutFromSLB(*dynamic_cast<TGCModuleSLB*>(slb.get()),
                                    sideType, rodid, sswId, sbLoc);
 
    return status;
}

getReadoutFromLowPtCoincidence()

bool MuonTGC_Cabling::TGCCabling::getReadoutFromLowPtCoincidence	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	sbLoc,
		int &	channel,
		int	block,
		int	pos,
		bool	middle = false ) const

Definition at line 326 of file TGCCabling.cxx.

                                                                          {
    bool orChannel = flag;
 
    const TGCModuleId* slb = getSLBFromReadout(side, rodId, sswId, sbLoc);
    if (!slb) {
        return 0;
    }
 
    TGCChannelSLBOut slbout(slb->getSideType(), slb->getModuleType(),
                            slb->getRegionType(), slb->getSector(),
                            slb->getId(), block, pos);
 
    std::unique_ptr<TGCChannelId> slbin =
        getChannel(slbout, TGCChannelId::ChannelIdType::SLBIn, orChannel);
 
    if (!slbin) {
        return false;
    }
 
    channel = slbin->getChannel();
 
    return true;
}

getReadoutFromSLB()

bool MuonTGC_Cabling::TGCCabling::getReadoutFromSLB	(	const TGCModuleSLB &	slb,
		TGCId::SideType &	side,
		int &	rodId,
		int &	sswId,
		int &	sbLoc ) const

Definition at line 145 of file TGCCabling.cxx.

                                                                 {
    // initialize
    side = TGCId::NoSideType;
    rodId = -1;
    sswId = -1;
    sbLoc = -1;
 
    // Fill side
    side = slb.getSideType();
 
    TGCModuleMap sswMap = getModule(slb, TGCModuleId::SSW);
 
    if (sswMap.empty()) {
        return false;
    }
 
    // SSW Module
    std::unique_ptr<TGCModuleId>& ssw = sswMap.begin()->second;
    if (!ssw) {
        return false;
    }
 
    // Fill SSW ID
    sswId = ssw->getId();
 
    // Fill SBLoc
    sbLoc = slb.getSBLoc();
 
    if (sbLoc < 0) {
        TGCModuleMap slbMap = getModule(*ssw, TGCModuleId::SLB);
        if (slbMap.empty()) {
            return false;
        }
 
        TGCModuleSLB* pSlb = nullptr;
 
        for (auto& [id, module] : slbMap) {
            pSlb = dynamic_cast<TGCModuleSLB*>(module.get());
 
            if (pSlb && slb.getRegionType() == pSlb->getRegionType() &&
                slb.getSector() == pSlb->getSector() &&
                slb.getId() == pSlb->getId()) {
                if (slb.getModuleType() == pSlb->getModuleType()) {
                    sbLoc = pSlb->getSBLoc();
                    break;
                }
                // SI is connected to the SLB corrsponding WI
                if (slb.getModuleType() == TGCId::SI &&
                    pSlb->getModuleType() == TGCId::WI) {
                    sbLoc = pSlb->getSBLoc();
 
                    break;
                }
            }
        }
        if (sbLoc < 0) {
            return false;
        }
    }
 
    TGCModuleMap rodMap = getModule(*ssw, TGCModuleId::ROD);
    if (rodMap.empty()) {
        return false;
    }
 
    // ROD Module
    std::unique_ptr<TGCModuleId>& rod = rodMap.begin()->second;
 
    // Fill ROD ID
    rodId = rod->getId();
    return true;
}

getSLBFromReadout()

const TGCModuleId * MuonTGC_Cabling::TGCCabling::getSLBFromReadout	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	sbLoc ) const

Definition at line 50 of file TGCCabling.cxx.

                                                                  {
    std::scoped_lock lock(m_mutex);
 
    int indexFromReadoutWithoutChannel =
        getIndexFromReadoutWithoutChannel(side, rodId, sswId, sbLoc);
    const auto it = m_slbModuleIdMap.find(indexFromReadoutWithoutChannel);
    if (it != m_slbModuleIdMap.end()) {
        // Already seen this ReadoutID without channel.
        // Stored pointer is returned.
        return it->second.get();
    }
 
    // ROD Module
    int readoutSector = rodId - 1;  // rodID = 1..12
    TGCModuleROD rod(side, readoutSector);
 
    // SSW Module
    TGCModuleMap sswMap = getModule(rod, TGCModuleId::SSW);
    if (sswMap.empty()) {
        m_slbModuleIdMap.insert(
            std::make_pair(indexFromReadoutWithoutChannel, nullptr));
        return nullptr;
    }
 
    std::unique_ptr<TGCModuleId> ssw = sswMap.popModule(sswId);
    if (!ssw) {
        m_slbModuleIdMap.insert(
            std::make_pair(indexFromReadoutWithoutChannel, nullptr));
        return nullptr;  // Do not need to delete ssw here.
                         // We can delete ssw but nothing will be done.
    }
 
    // SLB Module
    TGCModuleMap slbMap = getModule(*ssw, TGCModuleId::SLB);
 
    if (slbMap.empty()) {
        m_slbModuleIdMap.insert(
            std::make_pair(indexFromReadoutWithoutChannel, nullptr));
        return nullptr;
    }
 
    std::unique_ptr<TGCModuleId> slb{};
    for (auto& [id, module] : slbMap) {
        const auto* SLB = dynamic_cast<TGCModuleSLB*>(module.get());
        if (SLB && SLB->getSBLoc() == sbLoc) {
            slb = std::move(module);
            break;
        }
    }
 
    if (!slb) {
        m_slbModuleIdMap.insert(
            std::make_pair(indexFromReadoutWithoutChannel, nullptr));
        return nullptr;  // Do not delete slb here.
    }
 
    return m_slbModuleIdMap
        .insert(std::make_pair(indexFromReadoutWithoutChannel, std::move(slb)))
        .first->second.get();
}

getSLBFromRxId()

std::unique_ptr< TGCModuleId > MuonTGC_Cabling::TGCCabling::getSLBFromRxId	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	rxId ) const

Definition at line 114 of file TGCCabling.cxx.

                                                                        {
 
    // ROD Module
    int readoutSector = rodId - 1;  // rodID = 1..12
    TGCModuleROD rod(side, readoutSector);
 
    // SSW Module
    TGCModuleMap sswMap = getModule(rod, TGCModuleId::SSW);
    if (sswMap.empty()) {
        return nullptr;
    }
 
    std::unique_ptr<TGCModuleId> ssw = sswMap.popModule(sswId);
 
    if (!ssw) {
        return nullptr;  // Do not need to delete ssw here.
                         // We can delete ssw but nothing will be done.
    }
 
    // SLB Module
    TGCModuleMap slbMap = getModule(*ssw, TGCModuleId::SLB);
    if (slbMap.empty()) {
        return nullptr;
    }
 
    return slbMap.popModule(rxId);
}

operator=()

TGCCabling & MuonTGC_Cabling::TGCCabling::operator= ( const TGCCabling & )

delete

Member Data Documentation

ATLAS_THREAD_SAFE

std::map<int, std::unique_ptr<TGCModuleId> > m_slbModuleIdMap MuonTGC_Cabling::TGCCabling::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 136 of file TGCCabling.h.

m_cableASDToPP

std::unique_ptr<TGCCableASDToPP> MuonTGC_Cabling::TGCCabling::m_cableASDToPP {}

private

Definition at line 125 of file TGCCabling.h.

{};

m_cableHPBToSL

std::unique_ptr<TGCCableHPBToSL> MuonTGC_Cabling::TGCCabling::m_cableHPBToSL {}

private

Definition at line 130 of file TGCCabling.h.

{};

m_cableInASD

std::unique_ptr<TGCCableInASD> MuonTGC_Cabling::TGCCabling::m_cableInASD {}

private

Definition at line 124 of file TGCCabling.h.

{};

m_cableInPP

std::unique_ptr<TGCCableInPP> MuonTGC_Cabling::TGCCabling::m_cableInPP {}

private

Definition at line 126 of file TGCCabling.h.

{};

m_cableInSLB

std::unique_ptr<TGCCableInSLB> MuonTGC_Cabling::TGCCabling::m_cableInSLB {}

private

Definition at line 128 of file TGCCabling.h.

{};

m_cablePPToSLB

std::unique_ptr<TGCCablePPToSLB> MuonTGC_Cabling::TGCCabling::m_cablePPToSLB {}

private

Definition at line 127 of file TGCCabling.h.

{};

m_cableSLBToHPB

std::unique_ptr<TGCCableSLBToHPB> MuonTGC_Cabling::TGCCabling::m_cableSLBToHPB {}

private

Definition at line 129 of file TGCCabling.h.

{};

m_cableSLBToSSW

std::unique_ptr<TGCCableSLBToSSW> MuonTGC_Cabling::TGCCabling::m_cableSLBToSSW {}

private

Definition at line 131 of file TGCCabling.h.

{};

m_cableSSWToROD

std::unique_ptr<TGCCableSSWToROD> MuonTGC_Cabling::TGCCabling::m_cableSSWToROD {}

private

Definition at line 132 of file TGCCabling.h.

{};

m_mutex

std::mutex MuonTGC_Cabling::TGCCabling::m_mutex

mutableprivate

Definition at line 137 of file TGCCabling.h.

---

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

• TGCCabling.h
• TGCCabling.cxx