ALICE3-TRK: improving segmentation, dealing with different silicon depth and pixel size wrt the APTS response

Author: atriolo

Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h

@@ -28,15 +28,17 @@ namespace o2::trk
 /// This is a work-in-progress code derived from the ITS2 and ITS3 segmentations.
 class SegmentationChip
 {
-  // This class defines the segmenation of the TRK chips in the ALICE3 upgrade. 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 stave/layer/disk to TGeo
-  // coordinates.
+  // 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 flat coordinate system. This is the tube segment projected onto a flat
+  // 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
@@ -58,17 +60,15 @@ class SegmentationChip
   static constexpr float PitchColVD{constants::VD::petal::layer::pitchZ};
   static constexpr float PitchRowVD{constants::VD::petal::layer::pitchX};
 
-  static constexpr float PitchColML{constants::moduleMLOT::chip::pitchZ};
-  static constexpr float PitchRowML{constants::moduleMLOT::chip::pitchX};
-
-  static constexpr float PitchColOT{constants::moduleMLOT::chip::pitchZ};
-  static constexpr float PitchRowOT{constants::moduleMLOT::chip::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 SiliconTickness = constants::silicon::thickness; // effective thickness of sensitive part
+  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;
 
@@ -86,24 +86,25 @@ class SegmentationChip
   /// \param int subDetID Sub-detector ID (0 for VD, 1 for ML/OT)
   /// \param int layer Layer number (0 to 2 for VD, 0 to 7 for ML/OT)
   /// \param int disk Disk number (0 to 5 for VD)
-  static bool globalToDetector(float xRow, float zCol, int& iRow, int& iCol, int subDetID, int layer, int disk) noexcept
+  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(info, "Global coordinates not valid: row = {} cm, col = {} cm", xRow, zCol);
+      LOGP(debug, "Local coordinates not valid: row = {} cm, col = {} cm", xRow, zCol);
       return false;
     }
+    localToDetectorUnchecked(xRow, zCol, iRow, iCol, subDetID, layer, disk);
 
-    globalToDetectorUnchecked(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(info, "Detector coordinates not valid: iRow = {}, iCol = {}", iRow, iCol);
+      LOGP(debug, "Detector coordinates not valid: iRow = {}, iCol = {}", iRow, iCol);
       return false;
     }
     return true;
   };
   /// same but w/o check for row/column range
-  static void globalToDetectorUnchecked(float xRow, float zCol, int& iRow, int& iCol, int subDetID, int layer, int disk) noexcept
+  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);
@@ -116,13 +117,13 @@ class SegmentationChip
       maxLength = constants::VD::petal::layer::length;
       // TODO: change this to use the layer and disk
     } else if (subDetID == 1 && layer <= 3) { // ML
-      pitchRow = PitchRowML;
-      pitchCol = PitchColML;
+      pitchRow = PitchRowMLOT;
+      pitchCol = PitchColMLOT;
       maxWidth = constants::ML::width;
       maxLength = constants::ML::length;
     } else if (subDetID == 1 && layer >= 4) { // OT
-      pitchRow = PitchRowOT;
-      pitchCol = PitchColOT;
+      pitchRow = PitchRowMLOT;
+      pitchCol = PitchColMLOT;
       maxWidth = constants::OT::width;
       maxLength = constants::OT::length;
     }
@@ -131,7 +132,7 @@ class SegmentationChip
     iCol = static_cast<int>(std::floor((zCol + maxLength / 2) / pitchCol));
   };
 
-  // Check global coordinates (cm) validity.
+  // Check local coordinates (cm) validity.
   static constexpr bool isValidGlob(float x, float z, int subDetID, int layer) noexcept
   {
     float maxWidth(0), maxLength(0);
@@ -165,8 +166,7 @@ class SegmentationChip
       nRows = constants::OT::nRows;
       nCols = constants::OT::nCols;
     }
-    return (row >= 0 && row < static_cast<float>(nRows) &&
-            col >= 0 && col < static_cast<float>(nCols));
+    return (row >= 0 && row < static_cast<float>(nRows) && col >= 0 && col < static_cast<float>(nCols));
   }
 
   /// Transformation from Detector cell coordinates to Geant detector centered
@@ -182,34 +182,37 @@ class SegmentationChip
   /// \param int subDetID Sub-detector ID (0 for VD, 1 for ML/OT)
   /// \param int layer Layer number (0 to 2 for VD, 0 to 7 for ML/OT)
   /// \param int disk Disk number (0 to 5 for VD)
-  static constexpr bool detectorToGlobal(int iRow, int iCol, float& xRow, float& zCol, int subDetID, int layer, int disk) noexcept
+  static constexpr bool detectorToLocal(int iRow, int iCol, float& xRow, float& zCol, int subDetID, int layer, int disk) noexcept
   {
-    if (!isValidDet(xRow, zCol, subDetID, layer)) {
+    if (!isValidDet(iRow, iCol, subDetID, layer)) {
       LOGP(debug, "Detector coordinates not valid: iRow = {}, iCol = {}", iRow, iCol);
       return false;
     }
-    detectorToGlobalUnchecked(iRow, iCol, xRow, zCol, subDetID, layer, disk);
+    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, "Global coordinates not valid: row = {} cm, col = {} cm", xRow, zCol);
+      LOGP(debug, "Local coordinates not valid: row = {} cm, col = {} cm", xRow, zCol);
       return false;
     }
     return true;
   };
 
-  // Same as detectorToGlobal w.o. checks.
+  // Same as detectorToLocal w.o. checks.
   // We position ourself in the middle of the pixel.
-  static void detectorToGlobalUnchecked(int& row, int& col, float xRow, float zCol, int subDetID, int layer, int disk) noexcept
+  static void detectorToLocalUnchecked(int row, int col, float& xRow, float& zCol, int subDetID, int layer, int disk) noexcept
   {
+    /// xRow = half chip width - iRow(center) * pitch
+    /// zCol = iCol * pitch - half chip lenght
     if (subDetID == 0) {
-      xRow = -(row + 0.5f) * PitchRowVD + constants::VD::petal::layer::width[layer] / 2;
-      zCol = (col + 0.5f) * PitchColVD - constants::VD::petal::layer::length / 2;
+      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 = -(row + 0.5f) * PitchRowML + constants::ML::width / 2;
-      zCol = (col + 0.5f) * PitchColML - constants::ML::length / 2;
+      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 = -(row + 0.5f) * PitchRowOT + constants::OT::width / 2;
-      zCol = (col + 0.5f) * PitchColOT - constants::OT::length / 2;
+      xRow = 0.5 * (constants::OT::width - PitchRowMLOT) - (row * PitchRowMLOT);
+      zCol = col * PitchColMLOT + 0.5 * (PitchColMLOT - constants::OT::length);
     }
   }
 
@@ -225,7 +228,6 @@ class SegmentationChip
   /// the center of the sensitive volume.
   /// \return math_utils::Vector2D<float>: x and y represent the detector local flat coordinates x and y
   // 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)
@@ -259,8 +261,22 @@ class SegmentationChip
     float yCurved = dist * std::sin(phi);
     return math_utils::Vector2D<float>(xCurved, yCurved);
   }
+
+  /// Print segmentation info
+  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
+#endif

Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h

@@ -30,13 +30,16 @@ constexpr double cm{1};
 constexpr double mu{1e-4};
 constexpr double mm{1e-1};
 
-// namespace metalstack /// still to be defined
-// {
-// constexpr double thickness{5 * mu}; // physical thickness of the copper metal stack
-// }
-
 namespace VD // TODO: add a primitive segmentation with more granularity wrt 1/4 layer = 1 chip
 {
+namespace silicon
+{
+constexpr double thickness{30 * mu}; // thickness of the silicon (should be 10 um epitaxial layer + 20 um substrate)?
+} // namespace silicon
+namespace metalstack
+{
+constexpr double thickness{0 * mu}; // thickness of the copper metal stack - for the moment it is not implemented
+} // namespace metalstack
 namespace petal
 {
 constexpr int nLayers{3}; // number of layers in each VD petal
@@ -45,12 +48,12 @@ namespace layer
 {
 constexpr double pitchX{10 * mu};                                                                                                                        // pitch of the row
 constexpr double pitchZ{10 * mu};                                                                                                                        // pitch of the column
-constexpr double totalThickness{30 * mu};                                                                                                                // total thickness of the chip
-constexpr std::array<double, nLayers> radii{0.5 * cm, 1.2 * cm, 2.5 * cm};                                                                               // width of the quarter of layer in cm
+constexpr double totalThickness{silicon::thickness + metalstack::thickness};                                                                             // total thickness of the chip
+constexpr std::array<double, nLayers> radii{0.5 * cm, 1.2 * cm, 2.5 * cm};                                                                               // radius of layer in cm
 constexpr std::array<double, nLayers> width{radii[0] * 2 * M_PI / 4, radii[1] * 2 * M_PI / 4, radii[2] * 2 * M_PI / 4};                                  // width of the quarter of layer in cm
 constexpr double length{50 * cm};                                                                                                                        // length of the layer
 constexpr int nCols{static_cast<int>(length / pitchZ)};                                                                                                  // number of columns in the chip
-constexpr std::array<int, nLayers> nRows{static_cast<int>(width[0] / pitchX), static_cast<int>(width[1] / pitchX), static_cast<int>(width[2] / pitchX)}; // number of rows in the chip
+constexpr std::array<int, nLayers> nRows{static_cast<int>(width[0] / pitchX), static_cast<int>(width[1] / pitchX), static_cast<int>(width[2] / pitchX)}; // number of rows in the chip. For the moment is different for each layer since a siner segmentation in repetitive units is stil to be implemented
 
 } // namespace layer
 namespace disk
@@ -62,16 +65,24 @@ constexpr double radiusOut{2.5 * cm};
 } // namespace VD
 
 namespace moduleMLOT /// same for ML and OT for the moment
-{                    /// TODO: account for different modules in case of change
+{                    /// TODO: account for different modules in case of changes
+namespace silicon
+{
+constexpr double thickness{100 * mu}; // thickness of the silicon (should be 10 um epitaxial layer + 90 um substrate)?
+} // namespace silicon
+namespace metalstack
+{
+constexpr double thickness{0 * mu}; // thickness of the copper metal stack - for the moment it is not implemented
+} // namespace metalstack
 namespace chip
 {
-constexpr double width{25 * mm};                        // width of the chip
-constexpr double length{32 * mm};                       // length of the chip
-constexpr double pitchX{50 * mu};                       // pitch of the row
-constexpr double pitchZ{50 * mu};                       // pitch of the column
-constexpr int nRows{static_cast<int>(width / pitchX)};  // number of columns in the chip
-constexpr int nCold{static_cast<int>(length / pitchZ)}; // number of rows in the chipù
-constexpr double totalThickness{100 * mu};              // total thickness of the chip
+constexpr double width{25 * mm};                                             // width of the chip
+constexpr double length{32 * mm};                                            // length of the chip
+constexpr double pitchX{50 * mu};                                            // pitch of the row
+constexpr double pitchZ{50 * mu};                                            // pitch of the column
+constexpr int nRows{static_cast<int>(width / pitchX)};                       // number of columns in the chip
+constexpr int nCols{static_cast<int>(length / pitchZ)};                      // number of rows in the chip
+constexpr double totalThickness{silicon::thickness + metalstack::thickness}; // total thickness of the chip
 /// Set to 0 for the moment, to be adjusted with the actual design of the chip if needed
 static constexpr float PassiveEdgeReadOut = 0.f; // width of the readout edge (Passive bottom)
 static constexpr float PassiveEdgeTop = 0.f;     // Passive area on top
@@ -86,7 +97,7 @@ constexpr double outerEdgeShortSide{0.1 * mm}; // gap between the chips and the
 constexpr double width{chip::width * 2 + gaps::interChips + 2 * gaps::outerEdgeLongSide};        // width of the module
 constexpr double length{chip::length * 4 + 3 * gaps::interChips + 2 * gaps::outerEdgeShortSide}; // length of the module
 constexpr int nRows{static_cast<int>(width / chip::pitchX)};                                     // number of columns in the module
-constexpr int nCold{static_cast<int>(length / chip::pitchZ)};                                    // number of rows in the module
+constexpr int nCols{static_cast<int>(length / chip::pitchZ)};                                    // number of rows in the module
 } // namespace moduleMLOT
 
 namespace ML
@@ -98,17 +109,21 @@ constexpr int nCols{static_cast<int>(length / constants::moduleMLOT::chip::pitch
 } // namespace ML
 
 namespace OT
-{
+{                                                                         //// TODO: add shorter lenght of the stave of L4
 constexpr double width{moduleMLOT::width * 2};                            // width of the stave
 constexpr double length{moduleMLOT::length * 20};                         // length of the stave
 constexpr int nRows{static_cast<int>(width / moduleMLOT::chip::pitchX)};  // number of rows in the stave
 constexpr int nCols{static_cast<int>(length / moduleMLOT::chip::pitchZ)}; // number of columns in the stave
 } // namespace OT
 
-namespace silicon
+namespace apts /// parameters for the APTS response
 {
-constexpr double thickness{10 * mu}; // thickness of active material
-} // namespace silicon
+constexpr double pitchX{15.0 * mu};
+constexpr double pitchZ{15.0 * mu};
+constexpr double responseYShift{15.5 * mu};
+constexpr double thickness{45 * mu};
+} // namespace apts
+
 } // namespace o2::trk::constants
 
-#endif
+#endif

Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx

@@ -266,7 +266,7 @@ TString GeometryTGeo::getMatrixPath(int index) const
   int subDetID, petalcase, disk, layer, stave, halfstave; //// TODO: add chips in a second step
   getChipID(index, subDetID, petalcase, disk, layer, stave, halfstave);
 
-  PrintChipID(index, subDetID, petalcase, disk, layer, stave, halfstave);
+  // PrintChipID(index, subDetID, petalcase, disk, layer, stave, halfstave);
 
   // TString path = "/cave_1/barrel_1/TRKV_2/TRKLayer0_1/TRKStave0_1/TRKChip0_1/TRKSensor0_1/"; /// dummy path, to be used for tests
   TString path = Form("/cave_1/barrel_1/%s_2/", GeometryTGeo::getTRKVolPattern());
@@ -709,4 +709,4 @@ void GeometryTGeo::Print(Option_t*) const
 }
 
 } // namespace trk
-} // namespace o2
+} // namespace o2

Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt

@@ -24,6 +24,7 @@ o2_add_library(TRKSimulation
                PUBLIC_LINK_LIBRARIES O2::TRKBase
                                      O2::FT3Simulation
                                      O2::ITSMFTSimulation
+                                     O2::DetectorsRaw
                                      O2::SimulationDataFormat)
 
 o2_target_root_dictionary(TRKSimulation