MuonMDT_CablingMap.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONMDT_CABLING_MUONMDT_CABLINGMAP_H
#define MUONMDT_CABLING_MUONMDT_CABLINGMAP_H
 
 
 
#include "AthenaKernel/CLASS_DEF.h"
#include "MuonCablingData/MdtTdcMap.h"
#include <set>
#include <memory>
#include <map>
#include <vector>
#include <cstdint>
/**********************************************
 *
 * @brief MDT map data object
 *
 **********************************************/
 
class MdtMezzanineType;
class MdtIdHelper;
class IdentifierHash;
class Identifier;
 
class MuonMDT_CablingMap {
   public:
    using MezzanineTypes = std::map<uint8_t, std::unique_ptr<MdtMezzanineType>>;
    using TdcOffSet = std::set<MdtTdcOffSorter, std::less<>>;
    using TdcOnlSet = std::vector<MdtTdcOnlSorter>;
 
    //       larger number of tubes. The csm caches the up to 2 CSM associated
    //       with this object
    struct MdtOffChModule {
        TdcOffSet::const_iterator begin() const { return cards.begin(); }
        TdcOffSet::const_iterator end() const { return cards.end(); }
        TdcOffSet::const_iterator begin() { return cards.begin(); }
        TdcOffSet::const_iterator end() { return cards.end(); }
 
        TdcOffSet cards{};
        std::array<MdtCablingOnData, 2> csm{};
    };
 
    using OffToOnlMap = std::map<MdtCablingOffData, MdtOffChModule>;
    struct MdtTdcModule {
        TdcOnlSet::const_iterator begin() const { return all_modules.begin(); }
        TdcOnlSet::const_iterator end() const { return all_modules.end(); }
        TdcOnlSet::const_iterator begin() { return all_modules.begin(); }
        TdcOnlSet::const_iterator end() { return all_modules.end(); }
 
        TdcOnlSet all_modules{};
 
        MdtTdcOnlSorter zero_module{nullptr};
    };
    using OnlToOffMap = std::map<MdtCablingOnData, MdtTdcModule>;
 
    /* mapping from hashid to ROB identifier as Subdetector+Rodid */
    using ChamberToROBMap = std::map<IdentifierHash, uint32_t>;
    using ROBToChamberMap = std::map<uint32_t, std::vector<IdentifierHash>>;
    using ListOfROB = std::vector<uint32_t>;
    using CablingData = MdtCablingData;
    MuonMDT_CablingMap();
    ~MuonMDT_CablingMap();
 
    bool addMezzanineLine(const int type, const int layer, const int sequence,
                          MsgStream& log);
 
    bool addMezanineLayout(std::unique_ptr<MdtMezzanineCard> card,
                           MsgStream& log);
 
    enum class DataSource { JSON, LegacyCOOL };
    bool addMezzanine(CablingData  cabling_data, DataSource source,
                      MsgStream& log);
 
    bool getOfflineId(CablingData& cabling_data, MsgStream& log) const;
 
    bool getOnlineId(CablingData& cabling_data, MsgStream& log) const;
    bool convert(const CablingData& cabling_data, Identifier& id,
                 bool check_valid = true) const;
    bool convert(const Identifier& id, CablingData& cabling_data) const;
 
    uint32_t getROBId(const IdentifierHash& stationCode, MsgStream& log) const;
    ListOfROB getROBId(const std::vector<IdentifierHash>& mdtHashVector,
                       MsgStream& log) const;
 
    std::vector<IdentifierHash> getMultiLayerHashVec(
        const std::vector<uint32_t>& ROBId_list, MsgStream& log) const;
 
    const std::vector<IdentifierHash>& getMultiLayerHashVec(
        const uint32_t ROBI, MsgStream& log) const;
 
    const ListOfROB& getAllROBId() const;
 
    const OnlToOffMap& getOnlineConvMap() const;
    const OffToOnlMap& getOfflineConvMap() const;
 
    bool finalize_init(MsgStream& log);
 
    bool getStationCode(const CablingData& map_data, IdentifierHash& mdtHashId,
                        MsgStream& log) const;
    bool getMultiLayerCode(const CablingData& map_data, Identifier& multiLayer,
                           IdentifierHash& mdtHashId, MsgStream& log) const;
 
    unsigned int csmNumOnChamber(const CablingData& map_data,
                                 MsgStream& log) const;
    bool has2CsmML() const;
    using MezzCardPtr = MdtMezzanineCard::MezzCardPtr;
    MezzCardPtr getHedgeHogMapping(uint8_t mezzCardId) const;
 
   private:
    bool addChamberToROBMap(const CablingData& cabling_data, MsgStream& log);
 
    const MdtIdHelper* m_mdtIdHelper{nullptr};
 
    MuonMDT_CablingMap& operator=(const MuonMDT_CablingMap& right) = delete;
    MuonMDT_CablingMap(const MuonMDT_CablingMap&) = delete;
 
    OffToOnlMap m_toOnlineConv{};
    OnlToOffMap m_toOfflineConv{};
    std::vector<std::unique_ptr<MdtTdcMap>> m_tdcs{};
 
    ROBToChamberMap m_ROBToMultiLayer{};
 
    ListOfROB m_listOfROB{};
 
    ChamberToROBMap m_chamberToROB{};
    ChamberToROBMap m_multilayerToROB{};
    bool m_2CSM_cham{false};
 
    using MezzCardList = std::vector<MezzCardPtr>;
    MezzCardList m_mezzCards{};
    MezzCardPtr legacyHedgehogCard(CablingData& cabling, MsgStream& msg) const;
};
 
CLASS_DEF(MuonMDT_CablingMap, 51038731, 1)
#include "AthenaKernel/CondCont.h"
CLASS_DEF(CondCont<MuonMDT_CablingMap>, 34552845, 0)
 
#endif