SegmentationChip.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_TRK_SEGMENTATIONCHIP_H_
#define ALICEO2_TRK_SEGMENTATIONCHIP_H_
 
#include <type_traits>
#include <fairlogger/Logger.h>
 
#include "MathUtils/Cartesian.h"
#include "TRKBase/Specs.h"
 
namespace o2::trk
{
 
class SegmentationChip
{
  // This class defines the segmenation of the TRK chips in the ALICE3 upgrade.
  // The "global coordinate system" refers to the hit position in cm in the global coordinate system centered in 0,0,0
  // The "local coordinate system" refers to the hit position in cm in the coordinate system of the sensor, which
  // is centered in 0,0,0 in the case of curved layers, and in the middle of the chip in the case of flat layers
  // The "detector coordinate system" refers to the hit position in row,col inside the sensor
  // This class provides the transformations from the local and detector coordinate systems
  // The conversion between global and local coordinate systems is operated by the transformation matrices
  // For the curved VD layers there exist three coordinate systems and one is transient.
  // 1. The global (curved) coordinate system. The chip's center of coordinate system is
  //    defined at the the mid-point of the detector.
  // 2. The local (flat) coordinate system. This is the tube segment projected onto a flat
  //    surface. In the projection we implicitly assume that the inner and outer
  //    stretch does not depend on the radius.
  // 3. The detector coordinate system. Defined by the row and column segmentation
  //    defined at the upper edge in the flat coord.
  // For the flat ML and OT layers, there exist two coordinate systems:
  // 1. The global (flat) coordinate system. The chip's center of coordinate system is
  //    defined at the the mid-point of the detector.
  // 2. The detector coordinate system. Defined by the row and column segmentation
  // TODO: add segmentation for VD disks
 
 public:
  constexpr SegmentationChip() = default;
  ~SegmentationChip() = default;
  constexpr SegmentationChip(const SegmentationChip&) = default;
  constexpr SegmentationChip(SegmentationChip&&) = delete;
  constexpr SegmentationChip& operator=(const SegmentationChip&) = default;
  constexpr SegmentationChip& operator=(SegmentationChip&&) = delete;
 
  static constexpr float PitchColVD{constants::VD::petal::layer::pitchZ};
  static constexpr float PitchRowVD{constants::VD::petal::layer::pitchX};
 
  static constexpr float PitchColMLOT{constants::moduleMLOT::chip::pitchZ};
  static constexpr float PitchRowMLOT{constants::moduleMLOT::chip::pitchX};
 
  static constexpr float SensorLayerThicknessVD = {constants::VD::petal::layer::totalThickness}; // physical thickness of sensitive part = 30 um
  static constexpr float SensorLayerThicknessML = {constants::moduleMLOT::chip::totalThickness}; // physical thickness of sensitive part = 100 um
  static constexpr float SensorLayerThicknessOT = {constants::moduleMLOT::chip::totalThickness}; // physical thickness of sensitive part = 100 um
 
  static constexpr float SiliconThicknessVD = constants::VD::silicon::thickness;           // effective thickness of sensitive part
  static constexpr float SiliconThicknessMLOT = constants::moduleMLOT::silicon::thickness; // effective thickness of sensitive part
 
  static constexpr std::array<double, constants::VD::petal::nLayers> radiiVD = constants::VD::petal::layer::radii;
 
  static bool localToDetector(float xRow, float zCol, int& iRow, int& iCol, int subDetID, int layer, int disk) noexcept
  {
    if (!isValidGlob(xRow, zCol, subDetID, layer)) {
      LOGP(debug, "Local coordinates not valid: row = {} cm, col = {} cm", xRow, zCol);
      return false;
    }
    localToDetectorUnchecked(xRow, zCol, iRow, iCol, subDetID, layer, disk);
 
    LOG(debug) << "Result from localToDetectorUnchecked: xRow " << xRow << " -> iRow " << iRow << ", zCol " << zCol << " -> iCol " << iCol << " on subDetID, layer, disk: " << subDetID << " " << layer << " " << disk;
 
    if (!isValidDet(iRow, iCol, subDetID, layer)) {
      iRow = iCol = -1;
      LOGP(debug, "Detector coordinates not valid: iRow = {}, iCol = {}", iRow, iCol);
      return false;
    }
    return true;
  };
  static void localToDetectorUnchecked(float xRow, float zCol, int& iRow, int& iCol, int subDetID, int layer, int disk) noexcept
  {
    // convert to row/col w/o over/underflow check
    float pitchRow(0), pitchCol(0);
    float maxWidth(0), maxLength(0);
 
    if (subDetID == 0) {
      pitchRow = PitchRowVD;
      pitchCol = PitchColVD;
      maxWidth = constants::VD::petal::layer::width[layer];
      maxLength = constants::VD::petal::layer::length;
      // TODO: change this to use the layer and disk
    } else if (subDetID == 1 && layer <= 3) { // ML
      pitchRow = PitchRowMLOT;
      pitchCol = PitchColMLOT;
      maxWidth = constants::ML::width;
      maxLength = constants::ML::length;
    } else if (subDetID == 1 && layer >= 4) { // OT
      pitchRow = PitchRowMLOT;
      pitchCol = PitchColMLOT;
      maxWidth = constants::OT::width;
      maxLength = constants::OT::length;
    }
    // convert to row/col
    iRow = static_cast<int>(std::floor((maxWidth / 2 - xRow) / pitchRow));
    iCol = static_cast<int>(std::floor((zCol + maxLength / 2) / pitchCol));
  };
 
  // Check local coordinates (cm) validity.
  static constexpr bool isValidGlob(float x, float z, int subDetID, int layer) noexcept
  {
    float maxWidth(0), maxLength(0);
    if (subDetID == 0) {
      maxWidth = constants::VD::petal::layer::width[layer];
      maxLength = constants::VD::petal::layer::length;
      // TODO: change this to use the layer and disk
    } else if (subDetID == 1 && layer <= 3) { // ML
      maxWidth = constants::ML::width;
      maxLength = constants::ML::length;
    } else if (subDetID == 1 && layer >= 4) { // OT
      maxWidth = constants::OT::width;
      maxLength = constants::OT::length;
    }
    return (-maxWidth / 2 < x && x < maxWidth / 2 && -maxLength / 2 < z && z < maxLength / 2);
  }
 
  // Check detector coordinates validity.
  static constexpr bool isValidDet(float row, float col, int subDetID, int layer) noexcept
  {
    // Check if the row and column are within the valid range
    int nRows(0), nCols(0);
    if (subDetID == 0) {
      nRows = constants::VD::petal::layer::nRows[layer];
      nCols = constants::VD::petal::layer::nCols;
      // TODO: change this to use the layer and disk
    } else if (subDetID == 1 && layer <= 3) { // ML
      nRows = constants::ML::nRows;
      nCols = constants::ML::nCols;
    } else if (subDetID == 1 && layer >= 4) { // OT
      nRows = constants::OT::nRows;
      nCols = constants::OT::nCols;
    }
    return (row >= 0 && row < static_cast<float>(nRows) && col >= 0 && col < static_cast<float>(nCols));
  }
 
  static constexpr bool detectorToLocal(int iRow, int iCol, float& xRow, float& zCol, int subDetID, int layer, int disk) noexcept
  {
    if (!isValidDet(iRow, iCol, subDetID, layer)) {
      LOGP(debug, "Detector coordinates not valid: iRow = {}, iCol = {}", iRow, iCol);
      return false;
    }
    detectorToLocalUnchecked(iRow, iCol, xRow, zCol, subDetID, layer, disk);
    LOG(debug) << "Result from detectorToLocalUnchecked: iRow " << iRow << " -> xRow " << xRow << ", iCol " << iCol << " -> zCol " << zCol << " on subDetID, layer, disk: " << subDetID << " " << layer << " " << disk;
 
    if (!isValidGlob(xRow, zCol, subDetID, layer)) {
      LOGP(debug, "Local coordinates not valid: row = {} cm, col = {} cm", xRow, zCol);
      return false;
    }
    return true;
  };
 
  // Same as detectorToLocal w.o. checks.
  // We position ourself in the middle of the pixel.
  static void detectorToLocalUnchecked(int row, int col, float& xRow, float& zCol, int subDetID, int layer, int disk) noexcept
  {
    if (subDetID == 0) {
      xRow = 0.5 * (constants::VD::petal::layer::width[layer] - PitchRowVD) - (row * PitchRowVD);
      zCol = col * PitchColVD + 0.5 * (PitchColVD - constants::VD::petal::layer::length);
    } else if (subDetID == 1 && layer <= 3) { // ML
      xRow = 0.5 * (constants::ML::width - PitchRowMLOT) - (row * PitchRowMLOT);
      zCol = col * PitchRowMLOT + 0.5 * (PitchRowMLOT - constants::ML::length);
    } else if (subDetID == 1 && layer >= 4) { // OT
      xRow = 0.5 * (constants::OT::width - PitchRowMLOT) - (row * PitchRowMLOT);
      zCol = col * PitchColMLOT + 0.5 * (PitchColMLOT - constants::OT::length);
    }
  }
 
  // in cm with respect to the center of the sensitive volume.
  static math_utils::Vector2D<float> curvedToFlat(const int layer, const float xCurved, const float yCurved) noexcept
  {
    // Align the flat surface with the curved survace of the original chip (and account for metal stack, TODO)
    float dist = std::hypot(xCurved, yCurved);
    float phi = std::atan2(yCurved, xCurved);
 
    // the y position is in the silicon volume however we need the chip volume (silicon+metalstack)
    // this is accounted by a y shift
    float xFlat = constants::VD::petal::layer::radii[layer] * phi; 
    float yFlat = constants::VD::petal::layer::radii[layer] - dist;
    return math_utils::Vector2D<float>(xFlat, yFlat);
  }
 
  // in cm with respect to the center of the sensitive volume.
  static constexpr math_utils::Vector2D<float> flatToCurved(int layer, float xFlat, float yFlat) noexcept
  {
    // Revert the curvedToFlat transformation
    float dist = constants::VD::petal::layer::radii[layer] - yFlat;
    float phi = xFlat / constants::VD::petal::layer::radii[layer];
    // the y position is in the chip volume however we need the silicon volume
    // this is accounted by a -y shift
    float xCurved = dist * std::cos(phi);
    float yCurved = dist * std::sin(phi);
    return math_utils::Vector2D<float>(xCurved, yCurved);
  }
 
  static const void Print() noexcept
  {
    LOG(info) << "Number of rows:\nVD L0: " << constants::VD::petal::layer::nRows[0]
              << "\nVD L1: " << constants::VD::petal::layer::nRows[1]
              << "\nVD L2: " << constants::VD::petal::layer::nRows[2]
              << "\nML stave: " << constants::ML::nRows
              << "\nOT stave: " << constants::OT::nRows;
 
    LOG(info) << "Number of cols:\nVD: " << constants::VD::petal::layer::nCols
              << "\nML stave: " << constants::ML::nCols
              << "\nOT stave: " << constants::OT::nCols;
  }
};
 
} // namespace o2::trk
 
#endif