NrpcCablingData.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUON_CABLING_NRPCCABLINGDATA_H
#define MUON_CABLING_NRPCCABLINGDATA_H
 
#include <cstdint>
#include <iostream>
#include <set>
/*
 * @brief: Helper struct containing all information to convert from the offline
 * identifiers to the online identifiers
 */
 
#define CABLING_OPERATORS(CL_NAME) \
      bool operator<(const CL_NAME& other)  const { return m_cache.hash < other.m_cache.hash; } \
      bool operator==(const CL_NAME& other) const {return m_cache.hash == other.m_cache.hash; } \
      bool operator!=(const CL_NAME& other) const { return m_cache.hash != other.m_cache.hash; } \
      bool operator!() const {return !m_cache.hash;} \
      \
      CL_NAME() = default; \
      CL_NAME( const CL_NAME& other): CL_NAME() { \
         m_cache.hash = other.m_cache.hash; \
      } \
      CL_NAME& operator=(const CL_NAME& other) { \
            if (&other != this) m_cache.hash = other.m_cache.hash; \
            return *this; \
      }
 
struct NrpcCablingOfflineID {
    CABLING_OPERATORS(NrpcCablingOfflineID)
    
    int8_t& stationIndex{m_cache.cache[0]};  
    int8_t& eta{m_cache.cache[1]};           
    int8_t& phi{m_cache.cache[2]};           
    int8_t& doubletR{m_cache.cache[3]};      
 
    int8_t& doubletPhi{m_cache.cache[4]};  
    int8_t& doubletZ{m_cache.cache[5]};    
    int8_t& gasGap{m_cache.cache[6]};      
 
     static constexpr int8_t measPhiBit = 1 << 0; 
     static constexpr int8_t stripSideBit = 1 << 1;
 
     bool measuresPhi() const { return m_measPhiStrip & measPhiBit; }
     bool stripSide() const { return m_measPhiStrip & stripSideBit; }
     void setMeasPhiAndSide(bool measPhi, bool stripSide) {
        m_measPhiStrip = measPhi * measPhiBit | stripSideBit * stripSide;
     }
   private:
        union {
            long int hash{0};
            int8_t cache[8];
        } m_cache{};
 
        int8_t& m_measPhiStrip{m_cache.cache[7]};     
 
};
 
struct NrpcCablingOnlineID {
    CABLING_OPERATORS(NrpcCablingOnlineID)
    int16_t& subDetector{m_cache.cache[0]};
    int16_t& tdcSector{m_cache.cache[1]};
    int16_t& tdc{m_cache.cache[2]};
   private:
    union {
        int64_t hash{0};
        int16_t cache[4];
    } m_cache{};
};
 
struct NrpcTdcStripRange{
    public:
       uint8_t firstStrip{0};
       uint8_t lastStrip{0};
       bool operator<(const NrpcTdcStripRange& other ) const{
          return lastStrip < other.firstStrip;
       }       
 };
 
struct NrpcTdcChannelRange {
    public:
        uint8_t firstChannel{0};
        uint8_t lastChannel{0};    
        bool operator<(const NrpcTdcChannelRange& other) const{
          return lastChannel < other.firstChannel;
       }
};
 
struct NrpcCablingData : public NrpcCablingOfflineID, NrpcCablingOnlineID {
    NrpcCablingData() = default;
    uint8_t strip{0};      // Offline strip number
    uint8_t channelId{0};  // Online tdc channel number
 
    bool operator<(const NrpcCablingData&) const {return false; }
    bool operator==(const NrpcCablingData& other) const {
        return strip == other.strip && channelId == other.channelId &&
            static_cast<const NrpcCablingOfflineID&>(*this) == other &&
            static_cast<const NrpcCablingOnlineID&>(*this) == other;
    }
    bool operator!=(NrpcCablingData& other) const {return ! ((*this) == other);}
};
 
struct NrpcCablingCoolData: public NrpcCablingOfflineID, NrpcCablingOnlineID,
                                   NrpcTdcStripRange, NrpcTdcChannelRange {
        NrpcCablingCoolData() = default;
        bool operator<(const NrpcCablingCoolData&) const { return false;}
};
struct NrpcCablOnDataByStrip: public NrpcTdcStripRange, NrpcTdcChannelRange, NrpcCablingOnlineID {
    NrpcCablOnDataByStrip() = default;
    NrpcCablOnDataByStrip(const NrpcCablingCoolData& data):
        NrpcTdcStripRange(data), 
        NrpcTdcChannelRange(data), 
        NrpcCablingOnlineID(data) {}
    
    bool operator<(const NrpcCablOnDataByStrip& other) const{
        if (static_cast<const NrpcCablingOnlineID&>(*this) != other) {
            return static_cast<const NrpcCablingOnlineID&>(*this) < other;
        }
        return static_cast<const NrpcTdcStripRange&>(*this) < other;
    }
};
struct NrpcCablOnDataByTdc : public NrpcTdcStripRange, NrpcTdcChannelRange, NrpcCablingOnlineID {
    NrpcCablOnDataByTdc() = default;
    NrpcCablOnDataByTdc(const NrpcCablingCoolData& data):
        NrpcTdcStripRange(data),
        NrpcTdcChannelRange(data),
        NrpcCablingOnlineID(data) {}
    
    bool operator<(const NrpcCablOnDataByTdc& other) const{
        if (static_cast<const NrpcCablingOnlineID&>(*this) != other) {
            return static_cast<const NrpcCablingOnlineID&>(*this) < other;
        }
        return static_cast<const NrpcTdcChannelRange&>(*this) < other;
    }
};
 
inline bool operator<(const NrpcCablOnDataByStrip& a,const NrpcCablingData& b) {
    return a.lastStrip < b.strip;
}
inline bool operator<(const NrpcCablingData& a, const NrpcCablOnDataByStrip& b) {
    return a.strip < b.firstStrip;
}
inline bool operator<(const NrpcCablOnDataByStrip& a, const  NrpcCablingCoolData& b) {
     if (static_cast<const NrpcCablingOnlineID&>(a) != static_cast<const NrpcCablingOnlineID&>(b)) {
         return static_cast<const NrpcCablingOnlineID&>(a) < b;
     }
     return static_cast<const NrpcTdcStripRange&>(a) < b;
}
inline bool operator<(const  NrpcCablingCoolData& a, const NrpcCablOnDataByStrip& b) {
     if (static_cast<const NrpcCablingOnlineID&>(a) != b) return static_cast<const NrpcCablingOnlineID&>(a) < b;
     return static_cast<const NrpcTdcStripRange&>(a) < b;
}
 
inline bool operator<(const NrpcCablOnDataByTdc& a, const NrpcCablingData& b) {
    if (static_cast<const NrpcCablingOnlineID&>(a) != b) return static_cast<const NrpcCablingOnlineID&>(a) < b;
    return a.lastChannel < b.channelId;
}
inline bool operator<(const NrpcCablingData& a, const NrpcCablOnDataByTdc& b) {
    if (static_cast<const NrpcCablingOnlineID&>(a) != b) return static_cast<const NrpcCablingOnlineID&>(a) < b;
    return a.channelId < b.firstChannel;
}
using NrpcCablOnDataByStripSet = std::set<NrpcCablOnDataByStrip, std::less<>>;
 
 
std::ostream& operator<<(std::ostream& ostr, const NrpcCablingOfflineID& obj);
std::ostream& operator<<(std::ostream& ostr, const NrpcCablingOnlineID& obj);
std::ostream& operator<<(std::ostream& ostr, const NrpcTdcStripRange& obj);
std::ostream& operator<<(std::ostream& ostr, const NrpcTdcChannelRange& obj);
std::ostream& operator<<(std::ostream& ostr, const NrpcCablingData& obj);
std::ostream& operator<<(std::ostream& ostr, const NrpcCablingCoolData& obj);
std::ostream& operator<<(std::ostream& ostr, const NrpcCablOnDataByTdc& obj);
std::ostream& operator<<(std::ostream& ostr, const NrpcCablOnDataByStrip& obj);
 
#undef CABLING_OPERATORS
#endif