Segmentation.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef ALICEO2_IOTOF_SEGMENTATION_H
#define ALICEO2_IOTOF_SEGMENTATION_H
 
#include <Rtypes.h>
#include <memory>
#include "MathUtils/Cartesian.h"
#include "IOTOFBase/IOTOFBaseParam.h"
 
namespace o2
{
namespace iotof
{
 
class Segmentation
{
 private:
  Segmentation();
  static std::unique_ptr<o2::iotof::Segmentation> sInstance;
 
 public:
  static Segmentation* Instance();
 
  ~Segmentation() = default;
 
  bool localToDetector(float x, float z, int& iRow, int& iCol, const int subDetectorID) const;
  void localToDetectorUnchecked(float xRow, float zCol, int& iRow, int& iCol, const int subDetectorID) const;
 
 
  // w/o check for row/col range
  template <typename T = float, typename L = float>
  void detectorToLocalUnchecked(L row, L col, T& xRow, T& zCol, const int subDetectorID) const
  {
    if (subDetectorID != 0 && subDetectorID != 1) {
      row = col = -1;
      return;
    }
    const auto& specsConfig = ChipSpecificsParam::Instance();
    xRow = getFirstRowCoordinate(subDetectorID) - row * specsConfig.PitchRow;
    zCol = col * specsConfig.PitchCol + getFirstColCoordinate(subDetectorID);
  }
  template <typename T = float, typename L = float>
  void detectorToLocalUnchecked(L row, L col, math_utils::Point3D<T>& loc, const int subDetectorID) const
  {
    if (subDetectorID != 0 && subDetectorID != 1) {
      row = col = -1;
      return;
    }
    const auto& specsConfig = ChipSpecificsParam::Instance();
    loc.SetCoordinates(getFirstRowCoordinate(subDetectorID) - row * specsConfig.PitchRow, T(0.), col * specsConfig.PitchCol + getFirstColCoordinate(subDetectorID));
  }
  template <typename T = float, typename L = float>
  void detectorToLocalUnchecked(L row, L col, std::array<T, 3>& loc, const int subDetectorID) const
  {
    if (subDetectorID != 0 && subDetectorID != 1) {
      row = col = -1;
      return;
    }
    const auto& specsConfig = ChipSpecificsParam::Instance();
    loc[0] = getFirstRowCoordinate(subDetectorID) - row * specsConfig.PitchRow;
    loc[1] = T(0);
    loc[2] = col * specsConfig.PitchCol + getFirstColCoordinate(subDetectorID);
  }
 
  // same but with check for row/col range
 
  template <typename T = float, typename L = float>
  bool detectorToLocal(L row, L col, T& xRow, T& zCol, const int subDetectorID) const
  {
    if (subDetectorID != 0 && subDetectorID != 1) {
      row = col = -1;
      return false;
    }
    const auto& specsConfig = ChipSpecificsParam::Instance();
    if (row < 0 || row >= specsConfig.NRows || col < 0 || col >= specsConfig.NCols) {
      return false;
    }
    detectorToLocalUnchecked(row, col, xRow, zCol, subDetectorID);
    return true;
  }
 
  template <typename T = float, typename L = float>
  bool detectorToLocal(L row, L col, math_utils::Point3D<T>& loc, const int subDetectorID) const
  {
    if (subDetectorID != 0 && subDetectorID != 1) {
      row = col = -1;
      return false;
    }
    const auto& specsConfig = ChipSpecificsParam::Instance();
    if (row < 0 || row >= specsConfig.NRows || col < 0 || col >= specsConfig.NCols) {
      return false;
    }
    detectorToLocalUnchecked(row, col, loc, subDetectorID);
    return true;
  }
  template <typename T = float, typename L = float>
  bool detectorToLocal(L row, L col, std::array<T, 3>& loc, const int subDetectorID) const
  {
    if (subDetectorID != 0 && subDetectorID != 1) {
      row = col = -1;
      return false;
    }
    const auto& specsConfig = ChipSpecificsParam::Instance();
    if (row < 0 || row >= specsConfig.NRows || col < 0 || col >= specsConfig.NCols) {
      return false;
    }
    detectorToLocalUnchecked(row, col, loc, subDetectorID);
    return true;
  }
 
  float getFirstRowCoordinate(const int subDetectorID) const
  {
    const auto& specsConfig = ChipSpecificsParam::Instance();
    return 0.5 * ((specsConfig.ActiveMatrixSizeRows() - specsConfig.PassiveEdgeTop + specsConfig.PassiveEdgeReadOut) - specsConfig.PitchRow);
  }
  float getFirstColCoordinate(const int subDetectorID) const
  {
    const auto& specsConfig = ChipSpecificsParam::Instance();
    return 0.5 * (specsConfig.PitchCol - specsConfig.ActiveMatrixSizeCols());
  }
 
  ClassDefNV(Segmentation, 1); // Segmentation class upgrade pixels
};
 
//_________________________________________________________________________________________________
inline void Segmentation::localToDetectorUnchecked(float xRow, float zCol, int& iRow, int& iCol, const int subDetectorID) const
{
  // convert to row/col w/o over/underflow check
  if (subDetectorID != 0 && subDetectorID != 1) {
    iRow = iCol = -1;
    return;
  }
  const auto& specsConfig = ChipSpecificsParam::Instance();
  xRow = 0.5 * (specsConfig.ActiveMatrixSizeRows() - specsConfig.PassiveEdgeTop + specsConfig.PassiveEdgeReadOut) - xRow; // coordinate wrt top edge of Active matrix
  zCol += 0.5 * specsConfig.ActiveMatrixSizeCols();                                                                       // coordinate wrt left edge of Active matrix
  iRow = int(xRow / specsConfig.PitchRow);
  iCol = int(zCol / specsConfig.PitchCol);
  // check pixel passive region
  if (std::abs(xRow - (iRow + 0.5) * specsConfig.PitchRow) > (0.5 * specsConfig.PitchRow - specsConfig.PixelPassiveEdgeX) || std::abs(zCol - (iCol + 0.5) * specsConfig.PitchCol) > (0.5 * specsConfig.PitchCol - specsConfig.PixelPassiveEdgeZ)) {
    iRow = iCol = -1;
    return;
  }
  if (xRow < 0) {
    iRow -= 1;
  }
  if (zCol < 0) {
    iCol -= 1;
  }
}
 
//_________________________________________________________________________________________________
inline bool Segmentation::localToDetector(float xRow, float zCol, int& iRow, int& iCol, const int subDetectorID) const
{
  // convert to row/col
  if (subDetectorID != 0 && subDetectorID != 1) {
    iRow = iCol = -1;
    return false;
  }
  const auto& specsConfig = ChipSpecificsParam::Instance();
  xRow = 0.5 * (specsConfig.ActiveMatrixSizeRows() - specsConfig.PassiveEdgeTop + specsConfig.PassiveEdgeReadOut) - xRow; // coordinate wrt top edge of Active matrix
  zCol += 0.5 * specsConfig.ActiveMatrixSizeCols();                                                                       // coordinate wrt left edge of Active matrix
  if (xRow < 0 || xRow >= specsConfig.ActiveMatrixSizeRows() || zCol < 0 || zCol >= specsConfig.ActiveMatrixSizeCols()) {
    iRow = iCol = -1;
    return false;
  }
  iRow = int(xRow / specsConfig.PitchRow);
  iCol = int(zCol / specsConfig.PitchCol);
  // check pixel passive region
  // if (specsConfig.PixelPassiveEdgeX > 1e-6 && specsConfig.PixelPassiveEdgeZ > 1e-6) {
  if (std::abs(xRow - (iRow + 0.5) * specsConfig.PitchRow) > (0.5 * specsConfig.PitchRow - specsConfig.PixelPassiveEdgeX) || std::abs(zCol - (iCol + 0.5) * specsConfig.PitchCol) > (0.5 * specsConfig.PitchCol - specsConfig.PixelPassiveEdgeZ)) {
    iRow = iCol = -1;
    return false;
  }
  // }
  return true;
}
 
} // namespace iotof
} // namespace o2
 
#endif