ITS3: make segmentation class header only

Signed-off-by: Felix Schlepper <[email protected]>

Author: f3sch

Detectors/Upgrades/ITS3/base/CMakeLists.txt

@@ -9,11 +9,9 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-o2_add_library(ITS3Base
-               SOURCES src/SegmentationSuperAlpide.cxx
-                       src/ITS3Params.cxx
-               PUBLIC_LINK_LIBRARIES O2::CommonConstants O2::MathUtils O2::DetectorsBase)
+o2_add_library(
+  ITS3Base
+  SOURCES src/ITS3Params.cxx
+  PUBLIC_LINK_LIBRARIES O2::CommonConstants O2::MathUtils O2::DetectorsBase)
 
-o2_target_root_dictionary(ITS3Base
-                          HEADERS include/ITS3Base/SegmentationSuperAlpide.h
-                                  include/ITS3Base/ITS3Params.h)
+o2_target_root_dictionary(ITS3Base HEADERS include/ITS3Base/ITS3Params.h)

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

@@ -53,10 +53,10 @@ class SegmentationSuperAlpide
   // |           |          |
   // x----------------------x
  public:
-  virtual ~SegmentationSuperAlpide() = default;
+  ~SegmentationSuperAlpide() = default;
   SegmentationSuperAlpide(const SegmentationSuperAlpide&) = default;
   SegmentationSuperAlpide(SegmentationSuperAlpide&&) = delete;
-  SegmentationSuperAlpide& operator=(const SegmentationSuperAlpide&) = delete;
+  SegmentationSuperAlpide& operator=(const SegmentationSuperAlpide&) = default;
   SegmentationSuperAlpide& operator=(SegmentationSuperAlpide&&) = delete;
   constexpr SegmentationSuperAlpide(int layer) : mLayer{layer} {}
 
@@ -85,9 +85,8 @@ class SegmentationSuperAlpide
   {
     // MUST align the flat surface with the curved surface with the original pixel array is on
     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.;
+    xFlat = (mRadii[mLayer] * phi) - constants::pixelarray::width / 2.;
     yFlat = dist - mRadii[mLayer];
   }
 
@@ -105,9 +104,8 @@ class SegmentationSuperAlpide
   {
     // 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]);
+    xCurved = dist * std::cos((xFlat + constants::pixelarray::width / 2.) / mRadii[mLayer]);
+    yCurved = dist * std::sin((xFlat + constants::pixelarray::width / 2.) / mRadii[mLayer]);
   }
 
   /// Transformation from Geant detector centered local coordinates (cm) to
@@ -196,13 +194,9 @@ class SegmentationSuperAlpide
     }
   }
 
-  const int mLayer{0}; ///< chip layer
-
-  ClassDef(SegmentationSuperAlpide, 1);
+  int mLayer{0}; ///< chip layer
 };
 
-/// Segmentation array
-extern const std::array<SegmentationSuperAlpide, constants::nLayers> SuperSegmentations;
 } // namespace o2::its3
 
 #endif

Detectors/Upgrades/ITS3/base/src/ITS3BaseLinkDef.h

@@ -15,7 +15,6 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class o2::its3::SegmentationSuperAlpide + ;
 #pragma link C++ class o2::its3::ITS3Params + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its3::ITS3Params> + ;
 

Detectors/Upgrades/ITS3/base/src/SegmentationSuperAlpide.cxx

@@ -17,6 +17,7 @@
 
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "DataFormatsITSMFT/ClusterPattern.h"
+#include "ITS3Base/SegmentationSuperAlpide.h"
 
 namespace o2::its3
 {
@@ -125,7 +126,7 @@ class TopologyDictionary
 
   /// Returns the local position of a compact cluster
   template <typename T = float>
-  static math_utils::Point3D<T> getClusterCoordinates(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup = true);
+  math_utils::Point3D<T> getClusterCoordinates(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup = true) const;
 
   static TopologyDictionary* loadFrom(const std::string& fileName = "", const std::string& objName = "ccdb_object");
 
@@ -134,10 +135,11 @@ class TopologyDictionary
 
  private:
   static constexpr int STopoSize{8 * 255 + 1};
-  std::unordered_map<unsigned long, int> mCommonMap{}; ///< Map of pair <hash, position in mVectorOfIDs>
-  std::unordered_map<int, int> mGroupMap{};            ///< Map of pair <groudID, position in mVectorOfIDs>
-  int mSmallTopologiesLUT[STopoSize]{};                ///< Look-Up Table for the topologies with 1-byte linearised matrix
-  std::vector<itsmft::GroupStruct> mVectorOfIDs{};     ///< Vector of topologies and groups
+  std::unordered_map<unsigned long, int> mCommonMap{};                           ///< Map of pair <hash, position in mVectorOfIDs>
+  std::unordered_map<int, int> mGroupMap{};                                      ///< Map of pair <groudID, position in mVectorOfIDs>
+  int mSmallTopologiesLUT[STopoSize]{};                                          ///< Look-Up Table for the topologies with 1-byte linearised matrix
+  std::vector<itsmft::GroupStruct> mVectorOfIDs{};                               ///< Vector of topologies and groups
+  std::array<o2::its3::SegmentationSuperAlpide, 3> mSuperSegmentations{0, 1, 2}; ///< Segmentations for IB layers
 
   ClassDefNV(TopologyDictionary, 3);
 };

Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TopologyDictionary.h

@@ -143,18 +143,18 @@ math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::C
     locCl.SetZ(locCl.Z() + this->getZCOG(cl.getPatternID()) * itsmft::SegmentationAlpide::PitchCol);
   } else {
     auto layer = its3::constants::detID::getDetID2Layer(cl.getSensorID());
-    its3::SuperSegmentations[layer].detectorToLocalUnchecked(cl.getRow(), cl.getCol(), locCl);
+    mSuperSegmentations[layer].detectorToLocalUnchecked(cl.getRow(), cl.getCol(), locCl);
     locCl.SetX(locCl.X() + this->getXCOG(cl.getPatternID()) * its3::SegmentationSuperAlpide::mPitchRow);
     locCl.SetZ(locCl.Z() + this->getZCOG(cl.getPatternID()) * its3::SegmentationSuperAlpide::mPitchCol);
     float xCurved{0.f}, yCurved{0.f};
-    its3::SuperSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);
+    mSuperSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);
     locCl.SetXYZ(xCurved, yCurved, locCl.Z());
   }
   return locCl;
 }
 
 template <typename T>
-math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup)
+math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup) const
 {
   auto refRow = cl.getRow();
   auto refCol = cl.getCol();
@@ -169,9 +169,9 @@ math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::C
     o2::itsmft::SegmentationAlpide::detectorToLocalUnchecked(refRow + xCOG, refCol + zCOG, locCl);
   } else {
     auto layer = its3::constants::detID::getDetID2Layer(cl.getSensorID());
-    its3::SuperSegmentations[layer].detectorToLocalUnchecked(refRow + xCOG, refCol + zCOG, locCl);
+    mSuperSegmentations[layer].detectorToLocalUnchecked(refRow + xCOG, refCol + zCOG, locCl);
     float xCurved{0.f}, yCurved{0.f};
-    its3::SuperSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);
+    mSuperSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);
     locCl.SetXYZ(xCurved, yCurved, locCl.Z());
   }
   return locCl;
@@ -194,6 +194,6 @@ TopologyDictionary* TopologyDictionary::loadFrom(const std::string& fname, const
 
 // Explicitly instaniate templates
 template math_utils::Point3D<float> TopologyDictionary::getClusterCoordinates<float>(const itsmft::CompClusterExt& cl) const;
-template math_utils::Point3D<float> TopologyDictionary::getClusterCoordinates<float>(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup);
+template math_utils::Point3D<float> TopologyDictionary::getClusterCoordinates<float>(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup) const;
 
 } // namespace o2::its3

Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx

@@ -108,6 +108,8 @@ class Digitizer : public TObject
   uint32_t mEventROFrameMin = 0xffffffff; ///< lowest RO frame for processed events (w/o automatic noise ROFs)
   uint32_t mEventROFrameMax = 0;          ///< highest RO frame forfor processed events (w/o automatic noise ROFs)
 
+  const std::array<o2::its3::SegmentationSuperAlpide, 3> mSuperSegmentations{0, 1, 2};
+
   o2::itsmft::AlpideSimResponse* mAlpSimResp = nullptr; // simulated response
 
   const o2::its::GeometryTGeo* mGeometry = nullptr; ///< ITS3 geometry

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

@@ -26,7 +26,6 @@
 
 using o2::itsmft::Hit;
 using Segmentation = o2::itsmft::SegmentationAlpide;
-using SuperSegmentation = o2::its3::SegmentationSuperAlpide;
 using o2::itsmft::AlpideRespSimMat;
 using o2::itsmft::PreDigit;
 
@@ -143,7 +142,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
     for (size_t iChip{0}; iChip < mChips.size(); ++iChip) {
       auto& chip = mChips[iChip];
       if (constants::detID::isDetITS3(iChip)) { // Check if this is a chip of ITS3
-        chip.addNoise(mROFrameMin, mROFrameMin, &mParams, SuperSegmentation::mNRows, SuperSegmentation::mNCols);
+        chip.addNoise(mROFrameMin, mROFrameMin, &mParams, SegmentationSuperAlpide::mNRows, SegmentationSuperAlpide::mNCols);
       } else {
         chip.addNoise(mROFrameMin, mROFrameMin, &mParams);
       }
@@ -238,8 +237,8 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   if (innerBarrel) {
     // transform the point on the curved surface to a flat one
     float xFlatE{0.f}, yFlatE{0.f}, xFlatS{0.f}, yFlatS{0.f};
-    SuperSegmentations[layer].curvedToFlat(xyzLocS.X(), xyzLocS.Y(), xFlatS, yFlatS);
-    SuperSegmentations[layer].curvedToFlat(xyzLocE.X(), xyzLocE.Y(), xFlatE, yFlatE);
+    mSuperSegmentations[layer].curvedToFlat(xyzLocS.X(), xyzLocS.Y(), xFlatS, yFlatS);
+    mSuperSegmentations[layer].curvedToFlat(xyzLocE.X(), xyzLocE.Y(), xFlatE, yFlatE);
     // update the local coordinates with the flattened ones
     xyzLocS.SetXYZ(xFlatS, yFlatS, xyzLocS.Z());
     xyzLocE.SetXYZ(xFlatE, yFlatE, xyzLocE.Z());
@@ -255,14 +254,14 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   int rowS = -1, colS = -1, rowE = -1, colE = -1, nSkip = 0;
   if (innerBarrel) {
     // get entrance pixel row and col
-    while (!SuperSegmentations[layer].localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
+    while (!mSuperSegmentations[layer].localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
       if (++nSkip >= nSteps) {
         return; // did not enter to sensitive matrix
       }
       xyzLocS += step;
     }
     // get exit pixel row and col
-    while (!SuperSegmentations[layer].localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE)) { // guard-ring ?
+    while (!mSuperSegmentations[layer].localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE)) { // guard-ring ?
       if (++nSkip >= nSteps) {
         return; // did not enter to sensitive matrix
       }
@@ -298,8 +297,8 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
     rowS = 0;
   }
 
-  int maxNrows{innerBarrel ? SuperSegmentation::mNRows : Segmentation::NRows};
-  int maxNcols{innerBarrel ? SuperSegmentation::mNCols : Segmentation::NCols};
+  int maxNrows{innerBarrel ? SegmentationSuperAlpide::mNRows : Segmentation::NRows};
+  int maxNcols{innerBarrel ? SegmentationSuperAlpide::mNCols : Segmentation::NCols};
   if (rowE >= maxNrows) {
     rowE = maxNrows - 1;
   }
@@ -327,19 +326,19 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   // take into account that the AlpideSimResponse depth defintion has different min/max boundaries
   // although the max should coincide with the surface of the epitaxial layer, which in the chip
   // local coordinates has Y = +SensorLayerThickness/2
-  float thickness = innerBarrel ? SuperSegmentation::mSensorLayerThickness : Segmentation::SensorLayerThickness;
+  float thickness = innerBarrel ? SegmentationSuperAlpide::mSensorLayerThickness : Segmentation::SensorLayerThickness;
   xyzLocS.SetY(xyzLocS.Y() + mAlpSimResp->getDepthMax() - thickness / 2.);
   // collect charge in evey pixel which might be affected by the hit
   for (int iStep = nSteps; iStep--;) {
     // Get the pixel ID
     if (innerBarrel) {
-      SuperSegmentations[layer].localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
+      mSuperSegmentations[layer].localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
     } else {
       Segmentation::localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
     }
     if (row != rowPrev || col != colPrev) { // update pixel and coordinates of its center
       if (innerBarrel) {
-        if (!SuperSegmentations[layer].detectorToLocal(row, col, cRowPix, cColPix)) {
+        if (!mSuperSegmentations[layer].detectorToLocal(row, col, cRowPix, cColPix)) {
           continue;
         }
       } else if (!Segmentation::detectorToLocal(row, col, cRowPix, cColPix)) {
@@ -350,8 +349,8 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
     }
     bool flipCol = false, flipRow = false;
     // note that response needs coordinates along column row (locX) (locZ) then depth (locY)
-    double rowMax{0.5f * (innerBarrel ? SuperSegmentation::mPitchRow : Segmentation::PitchRow)};
-    double colMax{0.5f * (innerBarrel ? SuperSegmentation::mPitchCol : Segmentation::PitchCol)};
+    double rowMax{0.5f * (innerBarrel ? SegmentationSuperAlpide::mPitchRow : Segmentation::PitchRow)};
+    double colMax{0.5f * (innerBarrel ? SegmentationSuperAlpide::mPitchCol : Segmentation::PitchCol)};
     auto rspmat = mAlpSimResp->getResponse(xyzLocS.X() - cRowPix, xyzLocS.Z() - cColPix, xyzLocS.Y(), flipRow, flipCol, rowMax, colMax);
 
     xyzLocS += step;