#include <RpcCablingMap.h>

Collaboration diagram for Muon::RpcCablingMap:

Classes
struct	CoolDBEntry
	Helper struct to ship all information from the Database. More...
struct	GasGapToTdcAssociation
	Helper struct to associate all strips in an eta/phi gasGap to the corresponding Tdc. More...
struct	TdcToGasGapAssociation
	Helper struct to associate all Tdcs to their corresponding strips in the gasGap. More...

Public Types
using	ChamberToROBMap = std::unordered_map<IdentifierHash, uint32_t>
	typedef to implement the csm mapping to ROB
using	ROBToChamberMap = std::unordered_map<uint32_t, std::vector<IdentifierHash>>
using	ListOfROB = std::vector<uint32_t>
using	FlatCablePtr = GeoModel::TransientConstSharedPtr<Muon::RpcFlatCableTranslator>

Public Member Functions
	RpcCablingMap (const IMuonIdHelperSvc *idHelperSvc)
	Constructor taking the IdHelperSvc.
	~RpcCablingMap ()
bool	getOfflineId (RpcCablingData &cabling_data, MsgStream &log) const
	return the offline id given the online id
bool	getOnlineId (RpcCablingData &cabling_data, MsgStream &log) const
	return the online id given the offline id
bool	convert (const RpcCablingData &translationCache, Identifier &id, bool checkValid=true) const
	Converts the translation cache back to an Identifier.
bool	convert (const Identifier &id, RpcCablingData &translationCache, bool setSideBit) const
	Copies the Identifier field onto the translationCache.
bool	insertChannels (CoolDBEntry &&dbEntry, MsgStream &log)
	Inserts a new dbEntry into the map.
std::set< FlatCablePtr >	flatCables () const
	Returns the list of all Rpc flat cable cards.
bool	finalize (MsgStream &log)
	Performs consistency checks for the cabling data (I.e.
uint32_t	getROBId (const IdentifierHash &stationCode, MsgStream &log) const
	return the ROD id of a given chamber, given the hash id
ListOfROB	getROBId (const std::vector< IdentifierHash > &rpcHashVector, MsgStream &log) const
	get the robs corresponding to a vector of hashIds, copied from Svc before the readCdo migration
const std::vector< IdentifierHash > &	getChamberHashVec (const uint32_t ROBI, MsgStream &log) const
	return a HashId list for a given ROD
std::vector< IdentifierHash >	getChamberHashVec (const ListOfROB &ROBs, MsgStream &log) const
const ListOfROB &	getAllROBId () const
	return the full list of ROD id

Private Types
using	AllTdcsPerGasGap = std::vector<GasGapToTdcAssociation>
using	AllGasGapsPerTdc = std::vector<TdcToGasGapAssociation>
using	OfflToOnlMap = std::map<RpcCablingOfflineID, AllTdcsPerGasGap>
using	OnlToOfflMap = std::map<RpcCablingOnlineID, AllGasGapsPerTdc>

Private Attributes
const RpcIdHelper &	m_rpcIdHelper
	Pointer to the RpcIdHelper.
OnlToOfflMap	m_onToOffline {}
	Map storing the connection from online -> offline channels.
OfflToOnlMap	m_offToOnline {}
	Map to cache the offline -> online conversions *‍/.
ChamberToROBMap	m_chambROBs {}
ROBToChamberMap	m_ROBHashes {}
ListOfROB	m_listOfROB {}
	full list of ROBs

Detailed Description

Definition at line 27 of file RpcCablingMap.h.

Member Typedef Documentation

◆ AllGasGapsPerTdc

using Muon::RpcCablingMap::AllGasGapsPerTdc = std::vector<TdcToGasGapAssociation>

private

Definition at line 116 of file RpcCablingMap.h.

◆ AllTdcsPerGasGap

using Muon::RpcCablingMap::AllTdcsPerGasGap = std::vector<GasGapToTdcAssociation>

private

Definition at line 115 of file RpcCablingMap.h.

◆ ChamberToROBMap

using Muon::RpcCablingMap::ChamberToROBMap = std::unordered_map<IdentifierHash, uint32_t>

typedef to implement the csm mapping to ROB

Definition at line 31 of file RpcCablingMap.h.

◆ FlatCablePtr

using Muon::RpcCablingMap::FlatCablePtr = GeoModel::TransientConstSharedPtr<Muon::RpcFlatCableTranslator>

Definition at line 35 of file RpcCablingMap.h.

◆ ListOfROB

using Muon::RpcCablingMap::ListOfROB = std::vector<uint32_t>

Definition at line 33 of file RpcCablingMap.h.

◆ OfflToOnlMap

using Muon::RpcCablingMap::OfflToOnlMap = std::map<RpcCablingOfflineID, AllTdcsPerGasGap>

private

Definition at line 117 of file RpcCablingMap.h.

◆ OnlToOfflMap

using Muon::RpcCablingMap::OnlToOfflMap = std::map<RpcCablingOnlineID, AllGasGapsPerTdc>

private

Definition at line 118 of file RpcCablingMap.h.

◆ ROBToChamberMap

using Muon::RpcCablingMap::ROBToChamberMap = std::unordered_map<uint32_t, std::vector<IdentifierHash>>

Definition at line 32 of file RpcCablingMap.h.

Constructor & Destructor Documentation

◆ RpcCablingMap()

Muon::RpcCablingMap::RpcCablingMap ( const IMuonIdHelperSvc * idHelperSvc )

Constructor taking the IdHelperSvc.

Definition at line 14 of file RpcCablingMap.cxx.

14 :

15 m_rpcIdHelper{idHelperSvc->rpcIdHelper()}{}

Muon::RpcCablingMap::m_rpcIdHelper

const RpcIdHelper & m_rpcIdHelper

Pointer to the RpcIdHelper.

Definition RpcCablingMap.h:114

◆ ~RpcCablingMap()

Muon::RpcCablingMap::~RpcCablingMap ( )

default

Member Function Documentation

◆ convert() [1/2]

bool Muon::RpcCablingMap::convert	(	const Identifier &	id,
		RpcCablingData &	translationCache,
		bool	setSideBit ) const

Copies the Identifier field onto the translationCache.

Parameters

id	Identifier of the offline channel to copy
setSideBit	Indicate that the chip is located at the HV side of the chamber (BIL-RPC)

Definition at line 33 of file RpcCablingMap.cxx.

                                                                                                              {
        if (!m_rpcIdHelper.is_rpc(channelId)) {
            return false;
        }
        translator.stationIndex = m_rpcIdHelper.stationName(channelId);
        translator.eta = m_rpcIdHelper.stationEta(channelId);
        translator.phi = m_rpcIdHelper.stationPhi(channelId);
        translator.doubletR = m_rpcIdHelper.doubletR(channelId);
        translator.doubletPhi = m_rpcIdHelper.doubletPhi(channelId);
        translator.doubletZ = m_rpcIdHelper.doubletZ(channelId);
        translator.gasGap = m_rpcIdHelper.gasGap(channelId);
        translator.setMeasPhiAndSide(m_rpcIdHelper.measuresPhi(channelId), setSideBit);
        translator.strip = m_rpcIdHelper.strip(channelId);
        return true;
    }

◆ convert() [2/2]

bool Muon::RpcCablingMap::convert	(	const RpcCablingData &	translationCache,
		Identifier &	id,
		bool	checkValid = true ) const

Converts the translation cache back to an Identifier.

Parameters

translationCache	Reference to the translation cache to take the Identifier fields from
id	Reference to the target Identifier to modify
checkValid	Checks whether the resuling Identifier is valid within the boundaries of the associated fields. May trigger the function to return false, but is also tremendously slow!!!

Definition at line 19 of file RpcCablingMap.cxx.

                                                                                                        {
        bool valid{!check_valid};
        id = check_valid
           ? m_rpcIdHelper.channelID(translator.stationIndex, translator.eta, translator.phi,
                                     translator.doubletR, translator.doubletZ,
                                     translator.doubletPhi, translator.gasGap,
                                     translator.measuresPhi(), translator.strip, valid)
            : m_rpcIdHelper.channelID(translator.stationIndex, translator.eta, translator.phi,
                                      translator.doubletR, translator.doubletZ,
                                      translator.doubletPhi, translator.gasGap,
                                      translator.measuresPhi(), translator.strip);
        return valid;
    }

◆ finalize()

bool Muon::RpcCablingMap::finalize ( MsgStream & log )

Performs consistency checks for the cabling data (I.e.

looking for 0 strips and overlaps)

Generate the ROB maps

Definition at line 164 of file RpcCablingMap.cxx.

                                               {
        if (m_offToOnline.empty()) {
            log << MSG::ERROR <<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__
                <<": finalize() -- No data has been loaded " << endmsg;
            return false;
         }
        RpcCablingData RobOffId{};
        RobOffId.strip = 1;
        for (const auto& [card, chambers] : m_onToOffline) {
            for (const TdcToGasGapAssociation& chamber : chambers) {
                static_cast<RpcCablingOfflineID&>(RobOffId) = chamber.gasGapID;
                Identifier chId{0};
                if (!convert(RobOffId, chId, true)) {
                    log << MSG::ERROR<<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__
                        << ": Could not construct an offline identifier from " << chamber.gasGapID << endmsg;
                    return false;
                }
                IdentifierHash hash{0};
                if (m_rpcIdHelper.get_module_hash(chId, hash)) {
                    log << MSG::ERROR <<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__
                        << ": Failed to generate a hash for " << chamber.gasGapID << endmsg;
                    return false;
                }
                uint32_t hardId = (card.subDetector << 16) | card.boardSector;
                m_chambROBs[hash] = hardId;
                std::vector<IdentifierHash>& robHashes = m_ROBHashes[hardId];
                if (std::ranges::find(robHashes, hash) == robHashes.end()){
                    robHashes.push_back(hash);
                }
            }
        }
        return true;
    }

◆ flatCables()

std::set< RpcCablingMap::FlatCablePtr > Muon::RpcCablingMap::flatCables ( ) const

Returns the list of all Rpc flat cable cards.

Definition at line 242 of file RpcCablingMap.cxx.

                                                                      {
        std::set<FlatCablePtr> cables{};
        for (const auto &[offId, gapToTdcs] : m_offToOnline) {
            for (const GasGapToTdcAssociation& assoc : gapToTdcs){
                cables.insert(assoc.flatCable);
            }
        }
        return cables;
    }

◆ getAllROBId()

const RpcCablingMap::ListOfROB & Muon::RpcCablingMap::getAllROBId ( ) const

return the full list of ROD id

Definition at line 239 of file RpcCablingMap.cxx.

                                                                   {
        return m_listOfROB;
    }

◆ getChamberHashVec() [1/2]

std::vector< IdentifierHash > Muon::RpcCablingMap::getChamberHashVec	(	const ListOfROB &	ROBs,
		MsgStream &	log ) const

Definition at line 228 of file RpcCablingMap.cxx.

                                                                                                          {
        std::unordered_set<IdentifierHash> hashSet{};
        for (const uint32_t rob : ROBs) {
            const std::vector<IdentifierHash>& hashFromROB = getChamberHashVec(rob, log);
            hashSet.insert(hashFromROB.begin(), hashFromROB.end());
        }
        std::vector<IdentifierHash> hashVec{};
        hashVec.insert(hashVec.end(), hashSet.begin(), hashSet.end());
        return hashVec;
    }

◆ getChamberHashVec() [2/2]

const std::vector< IdentifierHash > & Muon::RpcCablingMap::getChamberHashVec	(	const uint32_t	ROBI,
		MsgStream &	log ) const

return a HashId list for a given ROD

Definition at line 217 of file RpcCablingMap.cxx.

                                                                                                               {
        ROBToChamberMap::const_iterator itr = m_ROBHashes.find(ROBI);
        if (itr != m_ROBHashes.end()){
            return itr->second;
        }
        if (log.level() <= MSG::WARNING) {
            log << MSG::WARNING << "ROB ID " << ROBI << " not found ! " << endmsg;
        }
        static const std::vector<IdentifierHash> dummy;
        return dummy;
    }

◆ getOfflineId()

bool Muon::RpcCablingMap::getOfflineId	(	RpcCablingData &	cabling_data,
		MsgStream &	log ) const

return the offline id given the online id

The channel is not connected to this slot

Assign the chamber

Definition at line 93 of file RpcCablingMap.cxx.

                                                                                          {
        OnlToOfflMap::const_iterator itr = m_onToOffline.find(translatorCache);
        if (itr == m_onToOffline.end()) {
            log << MSG::DEBUG <<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__<<": The tdc chip "
                << static_cast<const RpcCablingOnlineID&>(translatorCache) << " is unknown " << endmsg;
            return false;
        }
        for (const TdcToGasGapAssociation& connectChamb: itr->second) {
            const std::optional<uint8_t> stripCh = connectChamb.flatCable->stripChannel(translatorCache.channelId, log);
            if (!stripCh) {
                continue;
            }
            static_cast<RpcCablingOfflineID&>(translatorCache) = connectChamb.gasGapID;
            translatorCache.strip = (*stripCh) + connectChamb.firstStrip;
            if (log.level() <= MSG::DEBUG) {
                log <<MSG::DEBUG<<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__<<":   -- Card "
                    <<connectChamb.gasGapID<<", strip: "<<static_cast<int>(translatorCache.strip)<<endmsg;
            }
            return true;
        }
        log << MSG::DEBUG<<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__<<": No tdc channel could be found for the object "
            << static_cast<const RpcCablingOnlineID&>(translatorCache)
            << " tdc: " << static_cast<int>(translatorCache.channelId) << endmsg;
 
        return false;
    }

◆ getOnlineId()

bool Muon::RpcCablingMap::getOnlineId	(	RpcCablingData &	cabling_data,
		MsgStream &	log ) const

return the online id given the offline id

get the online id from the offline id

Assign the TDC / tdcSector / subDetector ID

Definition at line 50 of file RpcCablingMap.cxx.

                                                                                         {
        if (log.level()<= MSG::DEBUG) {
            log<<MSG::DEBUG<<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__<<": test "<<translatorCache<<endmsg;
        }    
        const RpcCablingOfflineID& offId{translatorCache};
        OfflToOnlMap::const_iterator itr = m_offToOnline.find(offId);
        if (itr == m_offToOnline.end()) {
            log << MSG::DEBUG<<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__<<": The offline identifier "
                << offId << " is unknown " << endmsg;
            return false;
        }
        const AllTdcsPerGasGap& tdcs{itr->second};
        if (log.level() <= MSG::DEBUG) {
            log<<MSG::DEBUG<<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__<<": Chamber "<<offId<<" has "
               <<tdcs.size()<<" cards "<<endmsg;
        }
 
        const AllTdcsPerGasGap::const_iterator onlineCardItr = 
                    std::ranges::find_if(tdcs, [&translatorCache](const GasGapToTdcAssociation& tdc){
                        return tdc.firstStrip + RpcFlatCableTranslator::readStrips > translatorCache.strip
                            && tdc.firstStrip <= translatorCache.strip;
                    });
        if (onlineCardItr != itr->second.end()) {
            const GasGapToTdcAssociation& onlineCard = (*onlineCardItr);
            std::optional<uint8_t> tdcChannel = onlineCard.flatCable->tdcChannel(translatorCache.strip, log);
            if (tdcChannel) {
                static_cast<RpcCablingOnlineID&>(translatorCache) = onlineCard.tdcID;
                translatorCache.channelId = (*tdcChannel);
                if (log.level() <= MSG::DEBUG) {
                    log <<MSG::DEBUG<<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__<<": Mapped to card "
                        <<onlineCard.tdcID<<", channel: "<<static_cast<int>(translatorCache.channelId)<<endmsg;
                }
                return true;
            } else if (log.level() <= MSG::DEBUG) {
                log <<MSG::DEBUG<<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__<<":\n"<<(*onlineCard.flatCable)<<endmsg;
            }
        }
        log << MSG::DEBUG<<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__<<": No tdc channel could be found for the object "
            << static_cast<const RpcCablingOfflineID&>(translatorCache)<< " strip: " << static_cast<int>(translatorCache.strip) << endmsg;
        return false;
    }

◆ getROBId() [1/2]

uint32_t Muon::RpcCablingMap::getROBId	(	const IdentifierHash &	stationCode,
		MsgStream &	log ) const

return the ROD id of a given chamber, given the hash id

Definition at line 198 of file RpcCablingMap.cxx.

                                                                                            {
        ChamberToROBMap::const_iterator it = m_chambROBs.find(stationCode);
        if (it != m_chambROBs.end()) {
            return it->second;
        }
        if (log.level() <= MSG::WARNING) {
            log << MSG::WARNING << "Station code " << stationCode << " not found !! "<< endmsg;
        }
        return 0;
    }

◆ getROBId() [2/2]

RpcCablingMap::ListOfROB Muon::RpcCablingMap::getROBId	(	const std::vector< IdentifierHash > &	rpcHashVector,
		MsgStream &	log ) const

get the robs corresponding to a vector of hashIds, copied from Svc before the readCdo migration

Definition at line 209 of file RpcCablingMap.cxx.

                                                                                                                       {
        ListOfROB toRet{};
        toRet.reserve(rpcHashVector.size());
        for (const IdentifierHash& hash : rpcHashVector) {
            toRet.push_back(getROBId(hash, log));
        }
        return toRet;
    }

◆ insertChannels()

bool Muon::RpcCablingMap::insertChannels	(	CoolDBEntry &&	dbEntry,
		MsgStream &	log )

Inserts a new dbEntry into the map.

Parameters

dbEntry	Reference to all the DB information to insert
log	Refernce to the MsgStream of the executing algorithm to report failures & debugs

Definition at line 122 of file RpcCablingMap.cxx.

                                                                          {
        RpcCablingOfflineID offCh{entry};
        RpcCablingOnlineID  onlCh{entry};
        GasGapToTdcAssociation offToOnl{};
        offToOnl.tdcID = onlCh;
        offToOnl.flatCable = entry.flatCable;
        offToOnl.firstStrip = entry.firstStrip;
 
        m_offToOnline[offCh].emplace_back(std::move(offToOnl));
        std::ranges::sort(m_offToOnline[offCh], 
                          [](const GasGapToTdcAssociation& a, const GasGapToTdcAssociation& b){
                            return a.firstStrip < b.firstStrip;
                          });
 
        TdcToGasGapAssociation onlToOff{};
        onlToOff.gasGapID = offCh;
        onlToOff.firstStrip = entry.firstStrip - RpcFlatCableTranslator::firstStrip;
        onlToOff.flatCable = entry.flatCable;
        m_onToOffline[onlCh].push_back(std::move(onlToOff));
        std::ranges::sort(m_onToOffline[onlCh], 
                          [](const TdcToGasGapAssociation& a, const TdcToGasGapAssociation& b){
                            return a.firstStrip < b.firstStrip;
                          });
        
        if (log.level()<= MSG::DEBUG) {
            log<<MSG::DEBUG<<"RpcCablingMap::"<<__func__<<"() - "<<__LINE__<<": Add new cabling channel "
                <<offCh<<std::format("firstStrip: {:2d}", entry.firstStrip)<<" - "<<onlCh
                <<std::format("flatCable: {:2d}", entry.flatCable->id())<<endmsg;
        }
 
        int sub = entry.subDetector;
        int rod = entry.boardSector;
 
        int32_t hardId = (sub << 16) | rod;
 
        const bool robInitialized = std::find(m_listOfROB.begin(), m_listOfROB.end(), hardId) != m_listOfROB.end();
        if (!robInitialized) {
            m_listOfROB.push_back(hardId);
        }
    
        return true;
    }

Member Data Documentation

◆ m_chambROBs

ChamberToROBMap Muon::RpcCablingMap::m_chambROBs {}

private

Definition at line 125 of file RpcCablingMap.h.

125{};

◆ m_listOfROB

ListOfROB Muon::RpcCablingMap::m_listOfROB {}

private

full list of ROBs

Definition at line 129 of file RpcCablingMap.h.

129{};

◆ m_offToOnline

OfflToOnlMap Muon::RpcCablingMap::m_offToOnline {}

private

Map to cache the offline -> online conversions *‍/.

Definition at line 123 of file RpcCablingMap.h.

123{};

◆ m_onToOffline

OnlToOfflMap Muon::RpcCablingMap::m_onToOffline {}

private

Map storing the connection from online -> offline channels.

Definition at line 121 of file RpcCablingMap.h.

121{};

◆ m_ROBHashes

ROBToChamberMap Muon::RpcCablingMap::m_ROBHashes {}

private

Definition at line 126 of file RpcCablingMap.h.

126{};

◆ m_rpcIdHelper

const RpcIdHelper& Muon::RpcCablingMap::m_rpcIdHelper

private

Pointer to the RpcIdHelper.

Definition at line 114 of file RpcCablingMap.h.

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

Classes

Public Types

Public Member Functions

Private Types

Private Attributes

Detailed Description

Member Typedef Documentation

◆ AllGasGapsPerTdc

◆ AllTdcsPerGasGap

◆ ChamberToROBMap

◆ FlatCablePtr

◆ ListOfROB

◆ OfflToOnlMap

◆ OnlToOfflMap

◆ ROBToChamberMap

Constructor & Destructor Documentation

◆ RpcCablingMap()

◆ ~RpcCablingMap()

Member Function Documentation

◆ convert() [1/2]

◆ convert() [2/2]

◆ finalize()

◆ flatCables()

◆ getAllROBId()

◆ getChamberHashVec() [1/2]

◆ getChamberHashVec() [2/2]

◆ getOfflineId()

◆ getOnlineId()

◆ getROBId() [1/2]

◆ getROBId() [2/2]

◆ insertChannels()

Member Data Documentation

◆ m_chambROBs

◆ m_listOfROB

◆ m_offToOnline

◆ m_onToOffline

◆ m_ROBHashes

◆ m_rpcIdHelper