ModuleKeyHelper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
  */
#ifndef INDET_MODULEKEYHELPER_H
#define INDET_MODULEKEYHELPER_H
 
#include <array>
#include <type_traits>
 
namespace InDet {
   namespace MaskUtils {
      template<unsigned int bit, unsigned int end, typename T=unsigned int>
      static consteval T createMask() {
         if constexpr(bit>31u) {
            return static_cast<T>(0u);
         }
         else if constexpr(bit>=end) {
            return static_cast<T>(0u);
         }
         else {
            return static_cast<T>(1u<<bit) | createMask<bit+1u,end, T>();
         }
      }
   }
 
   template <typename T, unsigned  int T_ROW_BITS, unsigned int T_COL_BITS, unsigned int T_CHIP_BITS, unsigned int T_MASK_SEL_BITS, unsigned int T_N_MASKS=3>
   struct ModuleKeyHelper {
      static constexpr unsigned int ROW_BITS = T_ROW_BITS;
      static constexpr unsigned int COL_BITS = T_COL_BITS;
      static constexpr unsigned int CHIP_BITS = T_CHIP_BITS;
      static constexpr unsigned int MASK_SEL_BITS = T_MASK_SEL_BITS;
      static constexpr unsigned int N_MASKS = T_N_MASKS;
      static constexpr T ROW_SHIFT   = 0u;
      static constexpr T COL_SHIFT   = ROW_BITS;
      static constexpr T CHIP_SHIFT  = ROW_BITS + COL_BITS;
      static constexpr T MASK_SEL_SHIFT = ROW_BITS + COL_BITS + CHIP_BITS;
      static constexpr T ROW_MASK    = MaskUtils::createMask<0,                          ROW_BITS>();
      static constexpr T COL_MASK    = MaskUtils::createMask<ROW_BITS,                   ROW_BITS+COL_BITS>();
      static constexpr T CHIP_MASK   = MaskUtils::createMask<ROW_BITS+COL_BITS,          ROW_BITS+COL_BITS+CHIP_BITS>();
      static constexpr T MASK_SEL_MASK  = MaskUtils::createMask<ROW_BITS+COL_BITS+CHIP_BITS,ROW_BITS+COL_BITS+CHIP_BITS+MASK_SEL_BITS>();
      static constexpr unsigned int MASKS_SIZE=N_MASKS;
      using KEY_TYPE = T;
 
   protected:
      template <unsigned int SHIFT, T MASK>
      static constexpr T makeKeyPart([[maybe_unused]] T val) {
         if constexpr(MASK==0) {
            return T{};
         }
         else {
            assert (((val << SHIFT) & MASK) == (val << SHIFT));
            return (val << SHIFT);
         }
      }
 
      static constexpr T makeKey(unsigned int mask_sel, unsigned int chip, unsigned int col, unsigned int row=0u) {
         return   makeKeyPart<MASK_SEL_SHIFT,MASK_SEL_MASK>(mask_sel)
            | makeKeyPart<CHIP_SHIFT,CHIP_MASK>(chip)
            | makeKeyPart<COL_SHIFT,COL_MASK>(col)
            | makeKeyPart<ROW_SHIFT,ROW_MASK>(row);
      }
   public:
 
      static constexpr T getColumn(T key) { return (key & COL_MASK)   >> COL_SHIFT; }
 
      static constexpr T getRow(T key)    { return (key & ROW_MASK)   >> ROW_SHIFT; }
 
      static constexpr T getChip(T key)   { return (key & CHIP_MASK)  >> CHIP_SHIFT; }
 
      static constexpr T getMaskIdx(T key)  { return (key & MASK_SEL_MASK) >> MASK_SEL_SHIFT; }
 
      static constexpr unsigned int nMasks() { return std::max(1u,N_MASKS);}
 
      ModuleKeyHelper(std::array<T, N_MASKS> &&masks) requires (N_MASKS>0) : m_masks( masks) {}
      ModuleKeyHelper() = default;
 
      T getMask(T key) const {
         if constexpr(N_MASKS>0) {
            unsigned int idx;
            if constexpr(N_MASKS==1) {
               idx=0u;
            }
            else {
                  idx = getMaskIdx(key);
            }
            assert( idx < m_masks.size());
            return m_masks[idx];
         }
         else {
            return static_cast<T>(1u);
         }
      }
 
      unsigned int maskedKey([[maybe_unused]] unsigned int mask_idx, unsigned int chip, unsigned int col, unsigned int row=0u) const {
         if constexpr(N_MASKS>0) {
            assert( mask_idx < m_masks.size());
            return (m_masks[mask_idx] & makeKey(0u, chip, col, row)) | makeKey(mask_idx, 0u,0u,0u);
         }
         else {
            return makeKey(0u, chip, col, row);
         }
      }
 
      unsigned int maskedKey(unsigned int mask_idx, unsigned int key) const {
         if constexpr(N_MASKS>0) {
            assert( mask_idx < m_masks.size());
            return (m_masks[mask_idx] & key) | makeKey(mask_idx, 0u,0u,0u);
         }
         else {
            return key;
         }
      }
 
 
      bool isOverlapping(T key_ref, T key_test) const {
         if constexpr(N_MASKS>0) {
            unsigned int mask = getMask(key_ref);
            return (key_ref & mask) == (key_test & mask);
         }
         else {
            return key_ref == key_test;
         }
      }
 
   protected:
      struct Empty {};
      std::conditional< (N_MASKS>0), std::array<T, MASKS_SIZE>, Empty>::type m_masks; 
   };
 
}
#endif