CTPPSPixelIndices.h

Go to the documentation of this file.

#ifndef CTPPS_PIXELINDICES_H
#define CTPPS_PIXELINDICES_H

#include <iostream>
#include "FWCore/MessageLogger/interface/MessageLogger.h"
/*

  sensor side = bump bonding side = wire bonding side


  ^   sim y
  |
  |
  |
  0-----------------------------------
  |                |                  |
  |        2      |       3         |
  |                |                  0
  --------------------------------------
  0-----------------------------------
  |                |                  |
  |       1       |-------4---------|--------------> sim x        
  |                |                  0
  --------------------------------------
  0-----------------------------------   ^
  |                |                  |    | det cols 
  |      0        |        5        |    |
  |                |                  0   |
  --------------------------------------   |
  |
  <------------------------------------------ 0,0
  det rows x
  0  beam

*/

namespace {

  // The maximum number of ROCs in the X (row) direction per sensor.
  constexpr int maxROCsInX = 2;  //
  // The maximum number of ROCs in the Y (column) direction per sensor.
  constexpr int maxROCsInY = 3;  //
  // The nominal number of double columns per ROC is 26.
  constexpr int DColsPerROC = 26;
  // Default ROC size
  constexpr int ROCSizeInX = 80;  // ROC row size in pixels
  constexpr int ROCSizeInY = 52;  // ROC col size in pixels
  // Default DET barrel size
  constexpr int defaultDetSizeInX = 160;  // Det row size in pixels (2 ROCs)
  constexpr int defaultDetSizeInY = 156;  //  Det col size in pixels (3 ROCs)

  // Check the limits
  constexpr bool CTPPS_CHECK_LIMITS = true;
}  // namespace

class CTPPSPixelIndices {
public:
  //*********************************************************************
  // Constructor with the ROC size fixed to the default.

  CTPPSPixelIndices() : theColsInDet(defaultDetSizeInY), theRowsInDet(defaultDetSizeInX) {
    theChipsInX = theRowsInDet / ROCSizeInX;  // number of ROCs in X
    theChipsInY = theColsInDet / ROCSizeInY;  // number of ROCs in Y

    if (CTPPS_CHECK_LIMITS) {
      if (theChipsInX < 1 || theChipsInX > maxROCsInX)
        edm::LogError("RPix") << " CTPPSPixelIndices: Error in ROCsInX " << theChipsInX << " " << theRowsInDet << " "
                              << ROCSizeInX;
      if (theChipsInY < 1 || theChipsInY > maxROCsInY)
        edm::LogError("RPix") << " CTPPSPixelIndices: Error in ROCsInY " << theChipsInY << " " << theColsInDet << " "
                              << ROCSizeInY;
    }
  }

  CTPPSPixelIndices(const int colsInDet, const int rowsInDet) : theColsInDet(colsInDet), theRowsInDet(rowsInDet) {
    theChipsInX = theRowsInDet / ROCSizeInX;  // number of ROCs in X
    theChipsInY = theColsInDet / ROCSizeInY;  // number of ROCs in Y

    if (CTPPS_CHECK_LIMITS) {
      if (theChipsInX < 1 || theChipsInX > maxROCsInX)
        edm::LogError("RPix") << " CTPPSPixelIndices: Error in ROCsInX " << theChipsInX << " " << theRowsInDet << " "
                              << ROCSizeInX;
      if (theChipsInY < 1 || theChipsInY > maxROCsInY)
        edm::LogError("RPix") << " CTPPSPixelIndices: Error in ROCsInY " << theChipsInY << " " << theColsInDet << " "
                              << ROCSizeInY;
    }
  }

  ~CTPPSPixelIndices() {}

  inline int numberOfROCsInX(void) { return theChipsInX; }
  inline int numberOfROCsInY(void) { return theChipsInY; }

  void print(void) const {
    edm::LogInfo("RPix") << " Pixel det with " << theChipsInX << " chips in x and " << theChipsInY << " in y ";
    edm::LogInfo("RPix") << " Pixel rows " << theRowsInDet << " and columns " << theColsInDet;
    edm::LogInfo("RPix") << " Rows in one chip " << ROCSizeInX << " and columns " << ROCSizeInY;
    edm::LogInfo("RPix") << " Double columns per ROC " << DColsPerROC;
  }

  //********************************************************************
  // Convert dcol & pix indices to ROC col and row
  // Decoding from "Weber" pixel addresses to rows for PSI46
  // dcol = 0 - 25
  // pix = 2 - 161, zigzag pattern.
  // colAdd = 0-51   ! col&row start from 0
  // rowAdd = 0-79
  inline static int convertDcolToCol(const int dcol, const int pix, int& colROC, int& rowROC) {
    if (CTPPS_CHECK_LIMITS) {
      if (dcol < 0 || dcol >= DColsPerROC || pix < 2 || pix > 161) {
        edm::LogError("RPix") << "CTPPSPixelIndices: wrong dcol or pix " << dcol << " " << pix;
        rowROC = -1;  // dummy row Address
        colROC = -1;  // dummy col Address
        return -1;    // Signal error
      }
    }

    // First find if we are in the first or 2nd col of a dcol.
    int colEvenOdd = pix % 2;  // module(2), 0-1st sol, 1-2nd col.
    // Transform
    colROC = dcol * 2 + colEvenOdd;   // col address, starts from 0
    rowROC = abs(int(pix / 2) - 80);  // row addres, starts from 0

    if (CTPPS_CHECK_LIMITS) {
      if (colROC < 0 || colROC >= ROCSizeInY || rowROC < 0 || rowROC >= ROCSizeInX) {
        edm::LogError("RPix") << "CTPPSPixelIndices: wrong col or row " << colROC << " " << rowROC << " " << dcol << " "
                              << pix;
        rowROC = -1;  // dummy row Address
        colROC = -1;  // dummy col Address
        return -1;
      }
    }
    return 0;
  }

  //********************************************************************
  // colROC, rowROC are coordinates in the ROC frame, for ROC=rocId
  // (Start from 0).
  // cols, row are coordinates in the module frame, start from 0.
  // row is X, col is Y.
  // At the moment this works only for modules read with a single TBM.
  int transformToModule(const int colROC, const int rowROC, const int rocId, int& col, int& row) const {
    if (CTPPS_CHECK_LIMITS) {
      if (colROC < 0 || colROC >= ROCSizeInY || rowROC < 0 || rowROC >= ROCSizeInX) {
        edm::LogError("RPix") << "CTPPSPixelIndices: wrong index " << colROC << " " << rowROC;
        return -1;
      }
    }

    // The transformation depends on the ROC-ID
    if (rocId >= 0 && rocId < 3) {
      row = 159 - rowROC;

      col = (rocId + 1) * ROCSizeInY - colROC - 1;
    } else if (rocId >= 3 && rocId < 6) {
      row = rowROC;

      col = (5 - rocId) * ROCSizeInY + colROC;
    } else {
      edm::LogError("RPix") << "CTPPSPixelIndices: wrong ROC ID " << rocId;
      return -1;
    }
    if (CTPPS_CHECK_LIMITS) {
      if (col < 0 || col >= (ROCSizeInY * theChipsInY) || row < 0 || row >= (ROCSizeInX * theChipsInX)) {
        edm::LogError("RPix") << "CTPPSPixelIndices: wrong index " << col << " " << row;
        return -1;
      }
    }

    return 0;
  }
  //**************************************************************************
  // Transform from the module indixes to the ROC indices.
  // col, row - indices in the Module
  // rocId - roc index
  // colROC, rowROC - indices in the ROC frame.
  int transformToROC(const int col, const int row, int& rocId, int& colROC, int& rowROC) const {
    if (CTPPS_CHECK_LIMITS) {
      if (col < 0 || col >= (ROCSizeInY * theChipsInY) || row < 0 || row >= (ROCSizeInX * theChipsInX)) {
        edm::LogError("RPix") << "CTPPSPixelIndices: wrong index 3 ";
        return -1;
      }
    }

    // Get the 2d ROC coordinate
    int chipX = row / ROCSizeInX;  // row index of the chip 0-1
    int chipY = col / ROCSizeInY;  // col index of the chip 0-2

    // Get the ROC id from the 2D index
    rocId = rocIndex(chipX, chipY);
    if (CTPPS_CHECK_LIMITS && (rocId < 0 || rocId >= 6)) {
      edm::LogError("RPix") << "CTPPSPixelIndices: wrong roc index " << rocId;
      return -1;
    }
    // get the local ROC coordinates
    rowROC = (row % ROCSizeInX);  // row in chip
    colROC = (col % ROCSizeInY);  // col in chip

    if (rocId < 3) {
      colROC = 51 - colROC;
      rowROC = 79 - rowROC;
    }

    if (CTPPS_CHECK_LIMITS) {
      if (colROC < 0 || colROC >= ROCSizeInY || rowROC < 0 || rowROC >= ROCSizeInX) {
        edm::LogError("RPix") << "CTPPSPixelIndices: wrong index " << colROC << " " << rowROC;
        return -1;
      }
    }

    return 0;
  }

  // get ROC ID from module row and column

  int getROCId(const int col, const int row) const {
    int rocId = -1;

    if (CTPPS_CHECK_LIMITS) {
      if (col < 0 || col >= (ROCSizeInY * theChipsInY) || row < 0 || row >= (ROCSizeInX * theChipsInX)) {
        edm::LogError("RPix") << "CTPPSPixelIndices: wrong index ";
        return -1;
      }
    }

    // Get the 2d ROC coordinate
    int chipX = row / ROCSizeInX;  // row index of the chip 0-1
    int chipY = col / ROCSizeInY;  // col index of the chip 0-2

    // Get the ROC id from the 2D index
    rocId = rocIndex(chipX, chipY);
    if (CTPPS_CHECK_LIMITS && (rocId < 0 || rocId >= 6)) {
      edm::LogError("RPix") << "CTPPSPixelIndices: wrong roc index " << rocId;
      return -1;
    }

    return rocId;
  }

  // is pixel on the edge?
  bool isOnEdge(const int col, const int row) const {
    if (col == 0 || row == 0 || col == (defaultDetSizeInY - 1) || row == (defaultDetSizeInX - 1))
      return true;
    return false;
  }

  //***********************************************************************
  // Calculate a single number ROC index from the 2 ROC indices (coordinates)
  // chipX and chipY.
  // Goes from 0 to 5.
  inline static int rocIndex(const int chipX, const int chipY) {
    int rocId = -1;
    if (CTPPS_CHECK_LIMITS) {
      if (chipX < 0 || chipX >= 2 || chipY < 0 || chipY >= 3) {
        edm::LogError("RPix") << "PixelChipIndices: wrong index " << chipX << " " << chipY;
        return -1;
      }
    }
    if (chipX == 0)
      rocId = 5 - chipY;  // should be 3-5
    else if (chipX == 1)
      rocId = chipY;  // should be 0-2

    if (CTPPS_CHECK_LIMITS) {
      if (rocId < 0 || rocId >= (maxROCsInX * maxROCsInY)) {
        edm::LogError("RPix") << "CTPPSPixelIndices: Error in ROC index " << rocId;
        return -1;
      }
    }
    return rocId;
  }
  //**************************************************************************
  // Calculate the dcol in ROC from the col in ROC frame.
  // dcols go from 0 to 25.
  inline static int DColumn(const int colROC) {
    int dColumnId = (colROC) / 2;  // double column 0-25
    if (CTPPS_CHECK_LIMITS) {
      if (dColumnId < 0 || dColumnId >= 26) {
        edm::LogError("RPix") << "CTPPSPixelIndices: wrong dcol index  " << dColumnId << " " << colROC;
        return -1;
      }
    }
    return dColumnId;
  }
  //*************************************************************************
  // Calcuulate the global dcol index within a module
  // Usefull only forin efficiency calculations.
  inline static int DColumnInModule(const int dcol, const int chipIndex) {
    int dcolInMod = dcol + chipIndex * 26;
    return dcolInMod;
  }

  // This is routines to generate ROC channel number
  // Only limited use to store ROC pixel indices for calibration
  inline static int pixelToChannelROC(const int rowROC, const int colROC) {
    return (rowROC << 6) | colROC;  // reserve 6 bit for col ROC index 0-52
  }
  inline static std::pair<int, int> channelToPixelROC(const int chan) {
    int rowROC = (chan >> 6) & 0x7F;  // reserve 7 bits for row ROC index 0-79
    int colROC = chan & 0x3F;
    return std::pair<int, int>(rowROC, colROC);
  }

  inline int getDefaultRowDetSize() const { return defaultDetSizeInX; }
  inline int getDefaultColDetSize() const { return defaultDetSizeInY; }

  //***********************************************************************
private:
  int theColsInDet;  // Columns per Det
  int theRowsInDet;  // Rows per Det
  int theChipsInX;   // Chips in det in X (column direction)
  int theChipsInY;   // Chips in det in Y (row direction)
};

#endif