PixelModuleHelper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
  */
#ifndef INDET_PIXELMODULEHELPER_H
#define INDET_PIXELMODULEHELPER_H
 
#include "PixelReadoutGeometry/PixelModuleDesign.h"
#include <cassert>
#include <array>
#include <stdexcept>
 
namespace InDet {
 
   namespace MaskUtils {
      template<unsigned int bit, unsigned int end>
      static consteval unsigned int createMask() {
         // assert(bit<end);
         // assert(end<31u);
         if constexpr(bit>31u) {
               return 0u;
            }
         else if constexpr(bit>=end) {
               return 0u;
            }
         else {
            return (1u<<bit) | createMask<bit+1u,end>();
         }
      }
   }
 
   class PixelModuleHelper {
   public:
 
      // hierarchy chosen such that the row has the least impact on sorting order
      // such that core column addresses of two adjacent core columns  enclose all pixel addresses (column, row) of the
      // first core column of this pair.
      static constexpr unsigned int COLGROUP_DEFECT_BIT_MASK = (1u<<31);
      static constexpr unsigned int CHIP_MASK = MaskUtils::createMask<24,28>(); // 16 chips max
      static constexpr unsigned int COL_MASK  = MaskUtils::createMask<12,24>(); // 4096 cols max
      static constexpr unsigned int ROW_MASK  = MaskUtils::createMask<0,12>();  // 4096 rows max
      static constexpr unsigned int CHIP_SHIFT = 24;
      static constexpr unsigned int COL_SHIFT  = 12;
      static constexpr unsigned int ROW_SHIFT  = 0;
 
      static constexpr unsigned int N_COLS_PER_GROUP = 8;
      static constexpr unsigned int COL_MASK_FOR_GROUP = MaskUtils::createMask<12,3+12>(); //8 columns per group
 
      PixelModuleHelper(const InDetDD::SiDetectorDesign &design)
         : m_pixelModuleDesign( dynamic_cast<const InDetDD::PixelModuleDesign *>(&design))
      {
         if (m_pixelModuleDesign->rowsPerCircuit()==400 /* @TODO find a better way to identify when to swap columns and rows*/ ) {
            // the front-ends of ITk ring triplet modules are rotated differently
            // wrt. the offline coordinate system compared to quads and
            // barrel triplets. Once these modules are identified, the translation
            // works in exactly the same way, but columns and rows need to be swapped,
            m_swapOfflineRowsColumns=true;
            m_columns = m_pixelModuleDesign->rows();
            m_rows = m_pixelModuleDesign->columns();
            m_columnsPerCircuit = m_pixelModuleDesign->rowsPerCircuit();
            m_rowsPerCircuit = m_pixelModuleDesign->columnsPerCircuit();
            m_circuitsPerColumn = m_pixelModuleDesign->numberOfCircuitsPerRow();
            m_circuitsPerRow = m_pixelModuleDesign->numberOfCircuitsPerColumn();
         }
         else {
            m_swapOfflineRowsColumns=false;
            m_rows = m_pixelModuleDesign->rows();
            m_columns = m_pixelModuleDesign->columns();
            m_rowsPerCircuit = m_pixelModuleDesign->rowsPerCircuit();
            m_columnsPerCircuit = m_pixelModuleDesign->columnsPerCircuit();
            m_circuitsPerRow = m_pixelModuleDesign->numberOfCircuitsPerRow();
            m_circuitsPerColumn = m_pixelModuleDesign->numberOfCircuitsPerColumn();
         }
 
      }
      operator bool () const { return m_pixelModuleDesign != nullptr; }
 
      unsigned int columns() const { return m_columns; }
      unsigned int rows() const { return m_rows; }
      unsigned int columnsPerCircuit() const { return m_columnsPerCircuit; }
      unsigned int rowsPerCircuit() const { return m_rowsPerCircuit; }
      unsigned int circuitsPerColumn() const { return m_circuitsPerColumn; }
      unsigned int circuitsPerRow() const { return m_circuitsPerRow; }
      bool swapOfflineRowsColumns() const { return m_swapOfflineRowsColumns; }
 
      unsigned int hardwareCoordinates(unsigned int row, unsigned int column) const {
         unsigned int chip =0;
         if (swapOfflineRowsColumns()) {
            unsigned int tmp=row;
            row=column;
            column=tmp;
         }
         if (circuitsPerColumn()>1) {
            assert( circuitsPerColumn() == 2);
            chip += (row/rowsPerCircuit()) * circuitsPerRow();
            row = row % rowsPerCircuit();
            if (chip>0) {
               row = rowsPerCircuit() - row -1;
               column = columns() - column -1;
            }
         }
         if (circuitsPerRow()>1) {
            chip += column/columnsPerCircuit();
            column = column%columnsPerCircuit();
         }
         assert( (chip   & (CHIP_MASK >> CHIP_SHIFT)) == chip);
         assert( (column & (COL_MASK  >> COL_SHIFT))  == column);
         assert( (row    & (ROW_MASK  >> ROW_SHIFT))  == row);
 
         return (chip << CHIP_SHIFT)  | (column << COL_SHIFT) | (row << ROW_SHIFT);
      }
 
      unsigned int columnGroupDefect(unsigned int row, unsigned int column) const {
         return (hardwareCoordinates(row,column) & ((~COL_MASK_FOR_GROUP) & (~ROW_MASK))) | COLGROUP_DEFECT_BIT_MASK;
      }
 
      unsigned int nPixels() const {
         return m_pixelModuleDesign->columns() * m_pixelModuleDesign->rows();
      }
      unsigned int nColumns() const {
         return m_pixelModuleDesign->columns();
      }
      unsigned int nRows() const {
         return m_pixelModuleDesign->rows();
      }
      static constexpr unsigned int getChip(unsigned int hardware_coordinates) {
         return (hardware_coordinates & CHIP_MASK) >> CHIP_SHIFT;
      }
      static constexpr unsigned int getRow(unsigned int hardware_coordinates) {
         return (hardware_coordinates & ROW_MASK) >> ROW_SHIFT;
      }
      static constexpr unsigned int getColumn(unsigned int hardware_coordinates) {
         return (hardware_coordinates & COL_MASK) >> COL_SHIFT;
      }
 
      static constexpr bool isColumnGroupDefect(unsigned int key) {
         return key & COLGROUP_DEFECT_BIT_MASK;
      }
 
      static constexpr bool inSameColumnGroup(unsigned int key_ref, unsigned int key_test) {
         constexpr unsigned int mask_out_rows_and_cols_per_group = (CHIP_MASK|(COL_MASK & (~COL_MASK_FOR_GROUP)));
         return     (key_ref  & mask_out_rows_and_cols_per_group)
            ==  (key_test & mask_out_rows_and_cols_per_group);
      }
 
      constexpr static bool isSameDefect( unsigned int key_ref, unsigned int key_test) {
         return (key_ref & (CHIP_MASK | ROW_MASK | COL_MASK)) == key_test;
      }
 
      constexpr static bool isSameDefectWithGroups( unsigned int key_ref, unsigned int key_test) {
         return isSameDefect(key_ref, key_test) || (isColumnGroupDefect(key_ref) && inSameColumnGroup(key_ref, key_test));
      }
 
      std::array<unsigned int,4> offlineRange(unsigned int key) const {
         if (isColumnGroupDefect(key)) {
            if (getRow(key) !=0) {
               throw std::runtime_error("invalid key");
            };
 
            unsigned int chip=getChip(key);
            unsigned int row=getRow(key);
            unsigned int row_end=row + rowsPerCircuit()-1;
            unsigned int column=getColumn(key);
            unsigned int column_end= column + N_COLS_PER_GROUP-1;
 
            unsigned int chip_row = chip / circuitsPerRow();
            unsigned int chip_column = chip % circuitsPerRow();
 
            column += chip_column * columnsPerCircuit();
            column_end += chip_column * columnsPerCircuit();
            if (chip_row>=1) {
               column = columns() - column -1;
               column_end = columns() - column_end -1;
 
               row = rowsPerCircuit() - row -1 + chip_row * rowsPerCircuit();
               row_end = rowsPerCircuit() - row_end -1 + chip_row * rowsPerCircuit();
            }
            if (swapOfflineRowsColumns()) {
               return std::array<unsigned int,4>{ std::min(column, column_end), std::max(column,column_end)+1,
                                                  std::min(row, row_end),       std::max(row, row_end)+1 };
            }
            else {
               return std::array<unsigned int,4>{ std::min(row, row_end),       std::max(row, row_end)+1,
                                                  std::min(column, column_end), std::max(column,column_end)+1 };
            }
         }
         else {
            unsigned int chip=getChip(key);
            unsigned int row=getRow(key);
            unsigned int column=getColumn(key);
 
            unsigned int chip_row = chip / circuitsPerRow();
            unsigned int chip_column = chip % circuitsPerRow();
 
            column += chip_column * columnsPerCircuit();
            if (chip_row>=1) {
               column = columns() - column -1;
 
               row = rowsPerCircuit() - row -1 + chip_row * rowsPerCircuit();
            }
            if (swapOfflineRowsColumns()) {
               return std::array<unsigned int,4 >{ column, column + 1,
                                                   row, row +1 };
            }
            else {
               return std::array<unsigned int,4>{ row, row + 1,
                                                  column, column +1 };
            }
         }
      }
 
   private:
      const InDetDD::PixelModuleDesign *m_pixelModuleDesign =nullptr;
      unsigned short m_rows = 0;
      unsigned short m_columns = 0;
      unsigned short m_rowsPerCircuit = 0;
      unsigned short m_columnsPerCircuit = 0;
      unsigned char m_circuitsPerRow = 0;
      unsigned char m_circuitsPerColumn = 0;
      bool m_swapOfflineRowsColumns=false;
   };
}
#endif