ITS3 digitization: parameters, segmentation and container fixes

- Add digitization parameter sets
- Fix C2F/F2C conversion in SegmentationMosaix
- Set scale function for Alpide as IB
- Fix chip digits container initialization
- Correct ordering of maxRows and maxCols
- Add support for floating row/column numbers in D2L

Author: ChunzhengLab

Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationSuperAlpide.h

@@ -9,30 +9,39 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file SegmentationSuperAlpide.h
-/// \brief Definition of the SegmentationSuperAlpide class
+/// \file SegmentationMosaix.h
+/// \brief Definition of the SegmentationMosaix class
 /// \author felix.schlepper@cern.ch
 
-#ifndef ALICEO2_ITS3_SEGMENTATIONSUPERALPIDE_H_
-#define ALICEO2_ITS3_SEGMENTATIONSUPERALPIDE_H_
+#ifndef ALICEO2_ITS3_SEGMENTATIONMOSAIX_H_
+#define ALICEO2_ITS3_SEGMENTATIONMOSAIX_H_
+
+#include <type_traits>
 
 #include "MathUtils/Cartesian.h"
 #include "ITS3Base/SpecsV2.h"
-#include "Rtypes.h"
-
-#include <type_traits>
 
 namespace o2::its3
 {
 
 /// Segmentation and response for pixels in ITS3 upgrade
-class SegmentationSuperAlpide
+class SegmentationMosaix
 {
   // This class defines the segmenation of the pixelArray in the tile. We define
   // two coordinate systems, one width x,z detector local coordianates (cm) and
   // the more natural row,col layout: Also all the transformation between these
   // two. The class provides the transformation from the tile to TGeo
   // coordinates.
+  // In fact there exist three coordinate systems and one is transient.
+  // 1. The curved coordinate system. The chip's local coordinate system is
+  //    defined with its center at the the mid-point of the tube.
+  // 2. The 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.
+  //    Additionally, there is a difference between the flat geometrical center
+  //    and the phyiscal center defined by the metal layer.
+  // 3. The detector coordinate system. Defined by the row and column segmentation
+  //    defined at the upper edge in the flat coord.
 
   // row,col=0
   // |
@@ -53,25 +62,32 @@ class SegmentationSuperAlpide
   // |           |          |
   // x----------------------x
  public:
-  virtual ~SegmentationSuperAlpide() = default;
-  SegmentationSuperAlpide(const SegmentationSuperAlpide&) = default;
-  SegmentationSuperAlpide(SegmentationSuperAlpide&&) = delete;
-  SegmentationSuperAlpide& operator=(const SegmentationSuperAlpide&) = delete;
-  SegmentationSuperAlpide& operator=(SegmentationSuperAlpide&&) = delete;
-  constexpr SegmentationSuperAlpide(int layer) : mLayer{layer} {}
-
-  static constexpr int mNCols{constants::pixelarray::nCols};
-  static constexpr int mNRows{constants::pixelarray::nRows};
-  static constexpr int nPixels{mNCols * mNRows};
-  static constexpr float mLength{constants::pixelarray::length};
-  static constexpr float mWidth{constants::pixelarray::width};
-  static constexpr float mPitchCol{constants::pixelarray::length / static_cast<float>(mNCols)};
-  static constexpr float mPitchRow{constants::pixelarray::width / static_cast<float>(mNRows)};
-  static constexpr float mSensorLayerThickness{constants::thickness};
-  static constexpr float mSensorLayerThicknessEff{constants::effThickness};
-  static constexpr std::array<float, constants::nLayers> mRadii{constants::radii};
-
-  /// Transformation from the curved surface to a flat surface
+  constexpr SegmentationMosaix(int layer) : mRadius(static_cast<float>(constants::radiiMiddle[layer])) {}
+  constexpr ~SegmentationMosaix() = default;
+  constexpr SegmentationMosaix(const SegmentationMosaix&) = default;
+  constexpr SegmentationMosaix(SegmentationMosaix&&) = delete;
+  constexpr SegmentationMosaix& operator=(const SegmentationMosaix&) = default;
+  constexpr SegmentationMosaix& operator=(SegmentationMosaix&&) = delete;
+
+  static constexpr int NCols{constants::pixelarray::nCols};
+  static constexpr int NRows{constants::pixelarray::nRows};
+  static constexpr int NPixels{NCols * NRows};
+  static constexpr float Length{constants::pixelarray::length};
+  static constexpr float LengthH{Length / 2.f};
+  static constexpr float Width{constants::pixelarray::width};
+  static constexpr float WidthH{Width / 2.f};
+  static constexpr float PitchCol{constants::pixelarray::pixels::mosaix::pitchZ};
+  static constexpr float PitchRow{constants::pixelarray::pixels::mosaix::pitchX};
+  static constexpr float SensorLayerThickness{constants::totalThickness};
+  static constexpr float NominalYShift{constants::nominalYShift};
+
+  /// Transformation from the curved surface to a flat surface.
+  /// Additionally a shift in the flat coordinates must be applied because
+  /// the center of the TGeoShap when projected will be higher than the
+  /// physical thickness of the chip (we add an additional hull to account for
+  /// the copper metal interconnection which is in reality part of the chip but in our
+  /// simulation the silicon and metal layer are separated). Thus we shift the projected center
+  /// down by this difference to align the coordinate systems.
   /// \param xCurved Detector local curved coordinate x in cm with respect to
   /// the center of the sensitive volume.
   /// \param yCurved Detector local curved coordinate y in cm with respect to
@@ -80,18 +96,20 @@ class SegmentationSuperAlpide
   /// the center of the sensitive volume.
   /// \param yFlat Detector local flat coordinate y in cm with respect to
   /// the center of the sensitive volume.
-  void curvedToFlat(const float xCurved, const float yCurved, float& xFlat, float& yFlat) const noexcept
+  constexpr void curvedToFlat(const float xCurved, const float yCurved, float& xFlat, float& yFlat) const noexcept
   {
-    // MUST align the flat surface with the curved surface with the original pixel array is on
+    // MUST align the flat surface with the curved surface with the original pixel array is on and account for metal
+    // stack
     float dist = std::hypot(xCurved, yCurved);
-    float phiReadout = constants::tile::readout::width / constants::radii[mLayer];
     float phi = std::atan2(yCurved, xCurved);
-    xFlat = mRadii[mLayer] * (phi - phiReadout) - constants::pixelarray::width / 2.;
-    yFlat = dist - mRadii[mLayer];
+    // the y position is in the silicon volume however we need the chip volume (silicon+metalstack)
+    // this is accounted by a y shift
+    xFlat = WidthH - mRadius * phi;
+    yFlat = dist - mRadius + NominalYShift;
   }
 
   /// Transformation from the flat surface to a curved surface
-  /// It works only if the detector is not rototraslated
+  /// It works only if the detector is not rototraslated.
   /// \param xFlat Detector local flat coordinate x in cm with respect to
   /// the center of the sensitive volume.
   /// \param yFlat Detector local flat coordinate y in cm with respect to
@@ -100,13 +118,16 @@ class SegmentationSuperAlpide
   /// the center of the sensitive volume.
   /// \param yCurved Detector local curved coordinate y in cm with respect to
   /// the center of the sensitive volume.
-  void flatToCurved(float xFlat, float yFlat, float& xCurved, float& yCurved) const noexcept
+  constexpr void flatToCurved(float xFlat, float yFlat, float& xCurved, float& yCurved) const noexcept
   {
-    // MUST align the flat surface with the curved surface with the original pixel array is on
-    float dist = yFlat + mRadii[mLayer];
-    float phiReadout = constants::tile::readout::width / mRadii[mLayer];
-    xCurved = dist * std::cos(phiReadout + (xFlat + constants::pixelarray::width / 2.) / mRadii[mLayer]);
-    yCurved = dist * std::sin(phiReadout + (xFlat + constants::pixelarray::width / 2.) / mRadii[mLayer]);
+    // MUST align the flat surface with the curved surface with the original pixel array is on and account for metal
+    // stack
+    float dist = yFlat - NominalYShift + mRadius;
+    float phi = (WidthH - xFlat) / mRadius;
+    // the y position is in the chip volume however we need the silicon volume
+    // this is accounted by a -y shift
+    xCurved = dist * std::cos(phi);
+    yCurved = dist * std::sin(phi);
   }
 
   /// Transformation from Geant detector centered local coordinates (cm) to
@@ -120,7 +141,7 @@ class SegmentationSuperAlpide
   /// the center of the sensitive volume.
   /// \param int iRow Detector x cell coordinate.
   /// \param int iCol Detector z cell coordinate.
-  bool localToDetector(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
+  constexpr bool localToDetector(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
   {
     localToDetectorUnchecked(xRow, zCol, iRow, iCol);
     if (!isValid(iRow, iCol)) {
@@ -131,11 +152,10 @@ class SegmentationSuperAlpide
   }
 
   // Same as localToDetector w.o. checks.
-  void localToDetectorUnchecked(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
+  constexpr void localToDetectorUnchecked(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
   {
-    namespace cp = constants::pixelarray;
-    iRow = std::floor((cp::width / 2. - xRow) / mPitchRow);
-    iCol = std::floor((zCol + cp::length / 2.) / mPitchCol);
+    iRow = static_cast<int>(std::floor((WidthH - xRow) / PitchRow));
+    iCol = static_cast<int>(std::floor((zCol + LengthH) / PitchCol));
   }
 
   /// Transformation from Detector cell coordinates to Geant detector centered
@@ -148,60 +168,55 @@ class SegmentationSuperAlpide
   /// center of the sensitive volume.
   /// If iRow and or iCol is outside of the segmentation range a value of -0.5*Dx()
   /// or -0.5*Dz() is returned.
-  bool detectorToLocal(int const iRow, int const iCol, float& xRow, float& zCol) const noexcept
-  {
-    if (!isValid(iRow, iCol)) {
+  template <typename T>
+  constexpr bool detectorToLocal(T const row, T const col, float& xRow, float& zCol) const noexcept {
+    if (!isValid(row, col)) {
       return false;
     }
-    detectorToLocalUnchecked(iRow, iCol, xRow, zCol);
+    detectorToLocalUnchecked(row, col, xRow, zCol);
     return isValid(xRow, zCol);
   }
 
   // Same as detectorToLocal w.o. checks.
   // We position ourself in the middle of the pixel.
-  void detectorToLocalUnchecked(int const iRow, int const iCol, float& xRow, float& zCol) const noexcept
-  {
-    namespace cp = constants::pixelarray;
-    xRow = -(iRow + 0.5) * mPitchRow + cp::width / 2.;
-    zCol = (iCol + 0.5) * mPitchCol - cp::length / 2.;
+  template <typename T>
+  constexpr void detectorToLocalUnchecked(T const row, T const col, float& xRow, float& zCol) const noexcept {
+    xRow = -(static_cast<float>(row) + 0.5f) * PitchRow + WidthH;
+    zCol = (static_cast<float>(col) + 0.5f) * PitchCol - LengthH;
   }
 
-  bool detectorToLocal(int const row, int const col, math_utils::Point3D<float>& loc) const noexcept
-  {
+
+  template <typename T>
+  constexpr bool detectorToLocal(T const row, T const col, math_utils::Point3D<float>& loc) const noexcept {
     float xRow{0.}, zCol{0.};
     if (!detectorToLocal(row, col, xRow, zCol)) {
       return false;
     }
-    loc.SetCoordinates(xRow, 0., zCol);
+    loc.SetCoordinates(xRow, NominalYShift, zCol);
     return true;
   }
 
-  void detectorToLocalUnchecked(int const row, int const col, math_utils::Point3D<float>& loc) const noexcept
-  {
+  template <typename T>
+  constexpr void detectorToLocalUnchecked(T const row, T const col, math_utils::Point3D<float>& loc) const noexcept {
     float xRow{0.}, zCol{0.};
     detectorToLocalUnchecked(row, col, xRow, zCol);
-    loc.SetCoordinates(xRow, 0., zCol);
+    loc.SetCoordinates(xRow, NominalYShift, zCol);
   }
 
  private:
   template <typename T>
-  [[nodiscard]] bool isValid(T const row, T const col) const noexcept
+  [[nodiscard]] constexpr bool isValid(T const row, T const col) const noexcept
   {
     if constexpr (std::is_floating_point_v<T>) { // compares in local coord.
-      namespace cp = constants::pixelarray;
-      return !static_cast<bool>(row <= -cp::width / 2. || cp::width / 2. <= row || col <= -cp::length / 2. || cp::length / 2. <= col);
+      return (-WidthH < row && row < WidthH && -LengthH < col && col < LengthH);
     } else { // compares in rows/cols
-      return !static_cast<bool>(row < 0 || row >= static_cast<int>(mNRows) || col < 0 || col >= static_cast<int>(mNCols));
+      return !static_cast<bool>(row < 0 || row >= static_cast<int>(NRows) || col < 0 || col >= static_cast<int>(NCols));
     }
   }
 
-  const int mLayer{0}; ///< chip layer
-
-  ClassDef(SegmentationSuperAlpide, 1);
+  float mRadius;
 };
 
-/// Segmentation array
-extern const std::array<SegmentationSuperAlpide, constants::nLayers> SuperSegmentations;
 } // namespace o2::its3
 
 #endif

Detectors/Upgrades/ITS3/simulation/CMakeLists.txt

@@ -14,15 +14,21 @@ o2_add_library(ITS3Simulation
                        src/ITS3Services.cxx
                        src/DescriptorInnerBarrelITS3.cxx
                        src/Digitizer.cxx
+                       src/DigiParams.cxx
+                       src/ITS3DPLDigitizerParam.cxx
+                       src/ChipDigitsContainer.cxx
                PUBLIC_LINK_LIBRARIES O2::SimulationDataFormat
-                                     O2::ITSBase O2::ITSMFTSimulation
+                                     O2::ITSBase O2::ITSMFTSimulation O2::ITSMFTBase
                                      ROOT::Physics)
 
 o2_target_root_dictionary(ITS3Simulation
                           HEADERS include/ITS3Simulation/ITS3Layer.h
                                   include/ITS3Simulation/ITS3Services.h
                                   include/ITS3Simulation/DescriptorInnerBarrelITS3.h
                                   include/ITS3Simulation/Digitizer.h
+                                  include/ITS3Simulation/DigiParams.h
+                                  include/ITS3Simulation/ITS3DPLDigitizerParam.h
+                                  include/ITS3Simulation/ChipDigitsContainer.h
                                   )
 
-o2_data_file(COPY data  DESTINATION Detectors/ITS3/simulation)
+o2_data_file(COPY data  DESTINATION Detectors/ITS3/simulation)

Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipDigitsContainer.h

@@ -0,0 +1,63 @@
+// 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_ITS3_CHIPDIGITSCONTAINER_
+#define ALICEO2_ITS3_CHIPDIGITSCONTAINER_
+
+#include "ITSMFTBase/SegmentationAlpide.h"        // Base class in o2::itsmft namespace
+#include "ITSMFTSimulation/ChipDigitsContainer.h" // Base class in o2::itsmft namespace
+#include "ITS3Base/SegmentationMosaix.h"          // OB segmentation implementation
+#include "ITS3Base/SpecsV2.h"                     // Provides SpecsV2::isDetITS3() interface
+#include "ITS3Simulation/DigiParams.h"            // ITS3-specific DigiParams interface
+#include <TRandom.h>
+
+namespace o2
+{
+namespace its3
+{
+
+// IB uses the Alpide segmentation,
+// OB uses the Mosaix segmentation.
+using SegmentationIB = SegmentationMosaix;
+using SegmentationOB = o2::itsmft::SegmentationAlpide;
+class ChipDigitsContainer : public o2::itsmft::ChipDigitsContainer
+{
+ private:
+  bool innerBarrel; ///< true if the chip belongs to the inner barrel (IB), false if outer barrel (OB)
+  int maxRows;      ///< maximum number of rows
+  int maxCols;      ///< maximum number of columns
+
+ public:
+  explicit ChipDigitsContainer(UShort_t idx = 0);
+
+  /// Returns whether the chip is in the inner barrel (IB)
+  void setChipIndex(UShort_t idx)
+  {
+    o2::itsmft::ChipDigitsContainer::setChipIndex(idx);
+    innerBarrel = constants::detID::isDetITS3(getChipIndex());
+    maxRows = innerBarrel ? SegmentationIB::NRows : SegmentationOB::NRows;
+    maxCols = innerBarrel ? SegmentationIB::NCols : SegmentationOB::NCols;
+  }
+
+  int getMaxRows() const { return maxRows; }
+  int getMaxCols() const { return maxCols; }
+  bool isIB() const;
+  /// Adds noise digits, deleted the one using the itsmft::DigiParams interface
+  void addNoise(UInt_t rofMin, UInt_t rofMax, const o2::itsmft::DigiParams* params, int maxRows = o2::itsmft::SegmentationAlpide::NRows, int maxCols = o2::itsmft::SegmentationAlpide::NCols) = delete;
+  void addNoise(UInt_t rofMin, UInt_t rofMax, const o2::its3::DigiParams* params);
+
+  ClassDefNV(ChipDigitsContainer, 1);
+};
+
+} // namespace its3
+} // namespace o2
+
+#endif // ALICEO2_ITS3_CHIPDIGITSCONTAINER_