ModuleKeyHelper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 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_TYPE_BITS=0u>
   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 RANGE_FLAG_BITS = 1u;
      static constexpr unsigned int TYPE_BITS = T_TYPE_BITS;
      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 RANGE_FLAG_SHIFT = ROW_BITS + COL_BITS + CHIP_BITS;
      static constexpr T TYPE_SHIFT  = RANGE_FLAG_SHIFT + RANGE_FLAG_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 RANGE_FLAG_MASK  = MaskUtils::createMask<ROW_BITS+COL_BITS+CHIP_BITS,ROW_BITS+COL_BITS+CHIP_BITS+RANGE_FLAG_BITS>();
      static constexpr T TYPE_MASK   = MaskUtils::createMask<TYPE_SHIFT,TYPE_SHIFT+TYPE_BITS>();
      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);
         }
      }
 
   public:
      static constexpr T makeKey(bool is_range, unsigned int chip, unsigned int col, unsigned int row=0u) {
         return   static_cast<T>(is_range) << RANGE_FLAG_SHIFT
            | makeKeyPart<CHIP_SHIFT,CHIP_MASK>(chip)
            | makeKeyPart<COL_SHIFT,COL_MASK>(col)
            | makeKeyPart<ROW_SHIFT,ROW_MASK>(row);
      }

      //coverity[CONSTANT_EXPRESSION_RESULT]
      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 getLimitRowMax()     { return ROW_MASK; }

      static constexpr T getLimitColumnMax()  { return COL_MASK; }

      //coverity[CONSTANT_EXPRESSION_RESULT]
      static constexpr T getChip(T key)   { return (key & CHIP_MASK)  >> CHIP_SHIFT; }

      static constexpr T getDefectType(T key) {
         if constexpr(TYPE_BITS>0) {
            return (key & TYPE_MASK)  >> TYPE_SHIFT;
         }
         else {
            return T{};
         }
      }

      static constexpr T getDefectTypeComponent(T key) {
         if constexpr(TYPE_BITS>0) {
            return key & TYPE_MASK;
         }
         else {
            return T{};
         }
      }

      static constexpr T makeDefectTypeKey(unsigned int defect_type)
      {
         if constexpr(TYPE_BITS>0) {
            assert( (((defect_type << TYPE_SHIFT ) & TYPE_MASK) >> TYPE_SHIFT) == defect_type);
            return (defect_type << TYPE_SHIFT ) & TYPE_MASK;
         }
         else {
            return T{};
         }
      }

      static constexpr bool isRangeKey(T key) {
         if constexpr(TYPE_MASK) {
            return ((key & RANGE_FLAG_MASK)>>RANGE_FLAG_SHIFT);
         }
         else {
            return ((key>>RANGE_FLAG_SHIFT) );
         }
      }

      static constexpr T makeRangeKey(T key) { return key | RANGE_FLAG_MASK; }

      static constexpr T makeBaseKey(T key) { return key & (~(RANGE_FLAG_MASK|TYPE_MASK)); }

      static constexpr std::pair<T, T> makeRangeForMask( T key, T mask) {
         return std::make_pair( key & mask, (key | ((~mask) & (CHIP_MASK|COL_MASK|ROW_MASK))) );
      }

      static constexpr bool isMatchingDefect(T defect_key, T key) {
         return  (key == makeBaseKey(defect_key) || isRangeKey(defect_key));
      }
 
   };
 
}
#endif