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/SegmentationMosaix.h

@@ -12,6 +12,7 @@
 /// \file SegmentationMosaix.h
 /// \brief Definition of the SegmentationMosaix class
 /// \author felix.schlepper@cern.ch
+/// \author chunzheng.wang@cern.ch
 
 #ifndef ALICEO2_ITS3_SEGMENTATIONMOSAIX_H_
 #define ALICEO2_ITS3_SEGMENTATIONMOSAIX_H_
@@ -43,24 +44,22 @@ class SegmentationMosaix
   // 3. The detector coordinate system. Defined by the row and column segmentation
   //    defined at the upper edge in the flat coord.
 
-  // row,col=0
-  // |
-  // v
-  // x----------------------x
+  // O----------------------|
   // |           |          |
+  // |           |          |  ^ x
+  // |           |          |  |
+  // |           |          |  |
+  // |           |          |  |
+  // |           |          |  X----> z   X marks (x,z)=(0,0)
+  // |-----------X----------|
+  // |           |          |  O----> col O marks (row,col)=(0,0)
+  // |           |          |  |
+  // |           |          |  |
+  // |           |          |  v
+  // |           |          |  row
   // |           |          |
-  // |           |          |                        ^ x
-  // |           |          |                        |
-  // |           |          |                        |
-  // |           |          |                        |
-  // |-----------X----------|  X marks (x,z)=(0,0)   X----> z
-  // |           |          |
-  // |           |          |
-  // |           |          |
-  // |           |          |
-  // |           |          |
-  // |           |          |
-  // x----------------------x
+  // |----------------------|
+
  public:
   constexpr SegmentationMosaix(int layer) : mRadius(static_cast<float>(constants::radiiMiddle[layer])) {}
   constexpr ~SegmentationMosaix() = default;
@@ -79,7 +78,7 @@ class SegmentationMosaix
   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};
+  static constexpr float NominalYShift{0.0f};
 
   /// Transformation from the curved surface to a flat surface.
   /// Additionally a shift in the flat coordinates must be applied because
@@ -102,9 +101,9 @@ class SegmentationMosaix
     // stack
     float dist = std::hypot(xCurved, yCurved);
     float phi = std::atan2(yCurved, xCurved);
-    xFlat = (mRadius * phi) - WidthH;
     // 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;
   }
 
@@ -122,11 +121,12 @@ class SegmentationMosaix
   {
     // 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
-    float dist = yFlat - NominalYShift + mRadius;
-    xCurved = dist * std::cos((xFlat + WidthH) / mRadius);
-    yCurved = dist * std::sin((xFlat + WidthH) / mRadius);
+    xCurved = dist * std::cos(phi);
+    yCurved = dist * std::sin(phi);
   }
 
   /// Transformation from Geant detector centered local coordinates (cm) to
@@ -142,8 +142,11 @@ class SegmentationMosaix
   /// \param int iCol Detector z cell coordinate.
   constexpr bool localToDetector(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
   {
+    if (!isValidLoc(xRow, zCol)) {
+      return false;
+    }
     localToDetectorUnchecked(xRow, zCol, iRow, iCol);
-    if (!isValid(iRow, iCol)) {
+    if (!isValidDet(iRow, iCol)) {
       iRow = iCol = -1;
       return false;
     }
@@ -167,24 +170,27 @@ class SegmentationMosaix
   /// 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.
-  constexpr bool detectorToLocal(int const iRow, int const iCol, float& xRow, float& zCol) const noexcept
+  template <typename T>
+  constexpr bool detectorToLocal(T const row, T const col, float& xRow, float& zCol) const noexcept
   {
-    if (!isValid(iRow, iCol)) {
+    if (!isValidDet(row, col)) {
       return false;
     }
-    detectorToLocalUnchecked(iRow, iCol, xRow, zCol);
-    return isValid(xRow, zCol);
+    detectorToLocalUnchecked(row, col, xRow, zCol);
+    return isValidLoc(xRow, zCol);
   }
 
   // Same as detectorToLocal w.o. checks.
   // We position ourself in the middle of the pixel.
-  constexpr void detectorToLocalUnchecked(int const iRow, int const iCol, float& xRow, float& zCol) const noexcept
+  template <typename T>
+  constexpr void detectorToLocalUnchecked(T const row, T const col, float& xRow, float& zCol) const noexcept
   {
-    xRow = -(static_cast<float>(iRow) + 0.5f) * PitchRow + WidthH;
-    zCol = (static_cast<float>(iCol) + 0.5f) * PitchCol - LengthH;
+    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)) {
@@ -194,22 +200,28 @@ class SegmentationMosaix
     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, NominalYShift, zCol);
   }
 
  private:
+  // Check local coordinates (cm) validity.
   template <typename T>
-  [[nodiscard]] constexpr bool isValid(T const row, T const col) const noexcept
+  constexpr bool isValidLoc(T const x, T const z) const noexcept
   {
-    if constexpr (std::is_floating_point_v<T>) { // compares in local coord.
-      return (-WidthH < row && row < WidthH && -LengthH < col && col < LengthH);
-    } else { // compares in rows/cols
-      return !static_cast<bool>(row < 0 || row >= static_cast<int>(NRows) || col < 0 || col >= static_cast<int>(NCols));
-    }
+    return (-WidthH < x && x < WidthH && -LengthH < z && z < LengthH);
+  }
+
+  // Check detector coordinates validity.
+  template <typename T>
+  constexpr bool isValidDet(T const row, T const col) const noexcept
+  {
+    return (row >= 0 && row < static_cast<T>(NRows) &&
+            col >= 0 && col < static_cast<T>(NCols));
   }
 
   float mRadius;

Detectors/Upgrades/ITS3/simulation/CMakeLists.txt

@@ -15,8 +15,10 @@ o2_add_library(ITS3Simulation
                        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
@@ -25,6 +27,8 @@ o2_target_root_dictionary(ITS3Simulation
                                   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)

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_

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

@@ -19,7 +19,28 @@ namespace o2::its3
 
 class DigiParams final : public o2::itsmft::DigiParams
 {
+ private:
+  float mIBNoisePerPixel = 1.e-8;
+  int mIBChargeThreshold = 150;   ///< charge threshold in Nelectrons
+  int mIBMinChargeToAccount = 15; ///< minimum charge contribution to account
+  int mIBNSimSteps = 18;          ///< number of steps in response simulation
+  float mIBNSimStepsInv = 0;      ///< its inverse
+
  public:
+  DigiParams();
+
+  void setIBNoisePerPixel(float v) { mIBNoisePerPixel = v; }
+  float getIBNoisePerPixel() const { return mIBNoisePerPixel; }
+
+  void setIBChargeThreshold(int v, float frac2Account = 0.1);
+  int getIBChargeThreshold() const { return mIBChargeThreshold; }
+
+  void setIBNSimSteps(int v);
+  int getIBNSimSteps() const { return mIBNSimSteps; }
+  float getIBNSimStepsInv() const { return mIBNSimStepsInv; }
+
+  int getIBMinChargeToAccount() const { return mIBMinChargeToAccount; }
+
   const o2::itsmft::AlpideSimResponse* getAlpSimResponse() const = delete;
   void setAlpSimResponse(const o2::itsmft::AlpideSimResponse* par) = delete;
 
@@ -37,7 +58,7 @@ class DigiParams final : public o2::itsmft::DigiParams
   const o2::itsmft::AlpideSimResponse* mOBSimResponse = nullptr; //!< pointer to external response
   const o2::itsmft::AlpideSimResponse* mIBSimResponse = nullptr; //!< pointer to external response
 
-  ClassDef(DigiParams, 1);
+  ClassDefNV(DigiParams, 1);
 };
 
 } // namespace o2::its3

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

@@ -21,12 +21,12 @@
 #include "Rtypes.h"
 #include "TObject.h"
 
-#include "ITSMFTSimulation/ChipDigitsContainer.h"
 #include "ITSMFTSimulation/AlpideSimResponse.h"
 #include "ITSMFTSimulation/Hit.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITS3Base/SegmentationMosaix.h"
 #include "ITS3Simulation/DigiParams.h"
+#include "ITS3Simulation/ChipDigitsContainer.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "CommonDataFormat/InteractionRecord.h"
@@ -78,7 +78,7 @@ class Digitizer : public TObject
 
  private:
   void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID);
-  void registerDigits(o2::itsmft::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
+  void registerDigits(o2::its3::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
                       uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
 
   ExtraDig* getExtraDigBuffer(uint32_t roFrame)
@@ -118,7 +118,7 @@ class Digitizer : public TObject
 
   const o2::its::GeometryTGeo* mGeometry = nullptr; ///< ITS3 geometry
 
-  std::vector<o2::itsmft::ChipDigitsContainer> mChips; ///< Array of chips digits containers
+  std::vector<o2::its3::ChipDigitsContainer> mChips;   ///< Array of chips digits containers
   std::deque<std::unique_ptr<ExtraDig>> mExtraBuff;    ///< burrer (per roFrame) for extra digits
 
   std::vector<o2::itsmft::Digit>* mDigits = nullptr;                       //! output digits

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

@@ -0,0 +1,31 @@
+// 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".
+
+#ifndef ALICEO2_ITS3DPLDIGITIZERPARAM_H_
+#define ALICEO2_ITS3DPLDIGITIZERPARAM_H_
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+namespace o2
+{
+namespace its3
+{
+
+struct ITS3DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<ITS3DPLDigitizerParam> {
+  float IBNoisePerPixel = 1.e-8; ///< MOSAIX Noise per channel
+  int IBChargeThreshold = 150;   ///< charge threshold in Nelectrons for IB
+  int IBMinChargeToAccount = 15; ///< minimum charge contribution to account for IB
+  int nIBSimSteps = 18;          ///< number of steps in response for IB
+
+  O2ParamDef(ITS3DPLDigitizerParam, "ITS3DPLDigitizerParam");
+};
+
+} // namespace its3
+} // namespace o2
+
+#endif