Update indexing scheme

Author: scannito

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

@@ -46,6 +46,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   static const char* getTRKPetalDiskPattern() { return sPetalDiskName.c_str(); }
   static const char* getTRKPetalLayerPattern() { return sPetalLayerName.c_str(); }
   static const char* getTRKStavePattern() { return sStaveName.c_str(); }
+  static const char* getTRKHalfStavePattern() { return sHalfStaveName.c_str(); }
   static const char* getTRKModulePattern() { return sModuleName.c_str(); }
   static const char* getTRKChipPattern() { return sChipName.c_str(); }
   static const char* getTRKSensorPattern() { return sSensorName.c_str(); }
@@ -64,6 +65,8 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   int extractNumberOfChipsPerPetalVD() const;
   int extractNumberOfStavesMLOT(int lay) const;
   int extractNumberOfHalfStavesMLOT(int lay) const;
+  int extractNumberOfModulesMLOT(int lay) const;
+  int extractNumberOfChipsMLOT(int lay) const;
 
   /// Extract number following the prefix in the name string
   int extractVolumeCopy(const char* name, const char* prefix) const;
@@ -85,6 +88,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   int getHalfStave(int index) const;
   int getDisk(int index) const;
   int getModule(int index) const;
+  int getChip(int index) const;
 
   /// This routine computes the chip index number from the subDetID, petal, disk, layer, stave /// TODO: retrieve also from chip when chips will be available
   /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
@@ -93,15 +97,19 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   /// \param int lay The layer number. Starting from 0 both for VD and MLOT
   /// \param int stave The stave number for MLOT. Starting from 0
   /// \param int halfstave The half stave number for MLOT. Can be 0 or 1
-  int getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const;
+  /// \param int module The module number for MLOT, from 0 to 10 (or 20)
+  /// \param int chip The chip number for MLOT, from 0 to 8
+  int getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave, int halfstave, int module, int chip) const;
 
   /// This routine computes the chip index number from the subDetID, volume, layer, stave /// TODO: retrieve also from chip when chips will be available
   /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
   /// \param int volume is needed only with the current configuration for VD where each single element is a volume. // TODO: when the geometry naming scheme will be changed, change this method
   /// \param int lay The layer number for the MLOT. In the current configuration for VD this is not needed. // TODO: when the geometry naming scheme will be changed, change this method
   /// \param int stave The stave number in each layer for MLOT. Starting from 0.
   /// \param int halfstave The half stave number for MLOT. Can be 0 or 1
-  int getChipIndex(int subDetID, int volume, int lay, int stave, int halfstave) const;
+  /// \param int module The module number for MLOT, from 0 to 10 (or 20)
+  /// \param int chip The chip number for MLOT, from 0 to 8
+  int getChipIndex(int subDetID, int volume, int lay, int stave, int halfstave, int module, int chip) const;
 
   /// This routine computes subDetID, petal, disk, layer, stave given the chip index number /// TODO: copute also from chip when chips will be available
   /// \param int index The chip index number, starting from 0
@@ -111,7 +119,9 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   /// \param int lay The layer number. Starting from 0 both for VD and MLOT
   /// \param int stave The stave number for MLOT. Starting from 0
   /// \param int halfstave The half stave number for MLOT. Can be 0 or 1
-  bool getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave, int& halfstave) const;
+  /// \param int module The module number for MLOT, from 0 to 10 (or 20)
+  /// \param int chip The chip number for MLOT, from 0 to 8
+  bool getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave, int& halfstave, int& module, int& chip) const;
 
   int getLastChipIndex(int lay) const { return mLastChipIndex[lay]; }
   int getFirstChipIndex(int lay, int petalcase, int subDetID) const
@@ -147,6 +157,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   static std::string sPetalDiskName;
   static std::string sPetalLayerName;
   static std::string sStaveName;
+  static std::string sHalfStaveName;
   static std::string sModuleName;
   static std::string sChipName;
   static std::string sSensorName;
@@ -159,16 +170,22 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   Int_t mNumberOfLayersVD;                     ///< number of layers
   Int_t mNumberOfPetalsVD;                     ///< number of Petals = chip in each VD layer
   Int_t mNumberOfDisksVD;                      ///< number of Disks = 6
-  std::vector<int> mLastChipIndex;             ///< max ID of the detctor in the petal(VD) or layer(MLOT)
-  std::vector<int> mLastChipIndexVD;           ///< max ID of the detctor in the layer for the VD
-  std::vector<int> mLastChipIndexMLOT;         ///< max ID of the detctor in the layer for the MLOT
+  std::vector<int> mNumberOfStaves;            ///< Number Of Staves per layer in ML/OT
+  std::vector<int> mNumberOfHalfStaves;        ///< Number Of Half staves in each stave of the layer in ML/OT
+  std::vector<int> mNumberOfModules;           ///< Number Of Modules per stave (half stave) in ML/OT
+  std::vector<int> mNumberOfChips;             ///< number of chips per module in ML/OT
   std::vector<int> mNumberOfChipsPerLayerVD;   ///< number of chips per layer VD ( =  number of petals)
-  std::vector<int> mNumberOfChipsPerLayerMLOT; ///< number of chips per layer MLOT ( = 1 for the moment)
+  std::vector<int> mNumberOfChipsPerLayerMLOT; ///< number of chips per layer MLOT
   std::vector<int> mNumbersOfChipPerDiskVD;    ///< numbersOfChipPerDiskVD
   std::vector<int> mNumberOfChipsPerPetalVD;   ///< numbersOfChipPerPetalVD
-  std::vector<int> mNumberOfStaves;            ///< Number Of Staves per layer in ML/OT
-  std::vector<int> mNumberOfHalfStaves;        ///< Number Of Staves in each stave of the layer in ML/OT
-  std::array<char, MAXLAYERS> mLayerToWrapper; ///< Layer to wrapper correspondence
+  // std::vector<int> mNumberOfChipsPerStave;     ///< number of chips per stave in ML/OT
+  // std::vector<int> mNumberOfChipsPerHalfStave; ///< number of chips per half stave in ML/OT
+  // std::vector<int> mNumberOfChipsPerModule; ///< number of chips per module in ML/OT
+  std::vector<int> mLastChipIndex;     ///< max ID of the detctor in the petal(VD) or layer(MLOT)
+  std::vector<int> mLastChipIndexVD;   ///< max ID of the detctor in the layer for the VD
+  std::vector<int> mLastChipIndexMLOT; ///< max ID of the detctor in the layer for the MLOT
+
+  std::array<char, MAXLAYERS> mLayerToWrapper; ///< Layer to wrapper correspondence, not implemented yet
 
   bool mOwner = true; //! is it owned by the singleton?
 

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

@@ -28,6 +28,7 @@ std::string GeometryTGeo::sPetalName = "PETALCASE";
 std::string GeometryTGeo::sPetalDiskName = "DISK";
 std::string GeometryTGeo::sPetalLayerName = "LAYER";
 std::string GeometryTGeo::sStaveName = "TRKStave";
+std::string GeometryTGeo::sHalfStaveName = "TRKHalfStave";
 std::string GeometryTGeo::sModuleName = "TRKModule";
 std::string GeometryTGeo::sChipName = "TRKChip";
 std::string GeometryTGeo::sSensorName = "TRKSensor";
@@ -78,18 +79,24 @@ void GeometryTGeo::Build(int loadTrans)
 
   mNumberOfStaves.resize(mNumberOfLayersMLOT);
   mNumberOfHalfStaves.resize(mNumberOfLayersMLOT);
-  mLastChipIndex.resize(mNumberOfPetalsVD + mNumberOfLayersMLOT);
-  mLastChipIndexVD.resize(mNumberOfPetalsVD);
-  mLastChipIndexMLOT.resize(mNumberOfLayersMLOT); /// ML and OT are part of TRK as the same detector, without disks
+  mNumberOfModules.resize(mNumberOfLayersMLOT);
+  mNumberOfChips.resize(mNumberOfLayersMLOT);
+
   mNumberOfChipsPerLayerVD.resize(mNumberOfLayersVD);
   mNumberOfChipsPerLayerMLOT.resize(mNumberOfLayersMLOT);
   mNumbersOfChipPerDiskVD.resize(mNumberOfDisksVD);
   mNumberOfChipsPerPetalVD.resize(mNumberOfPetalsVD);
 
+  mLastChipIndex.resize(mNumberOfPetalsVD + mNumberOfLayersMLOT);
+  mLastChipIndexVD.resize(mNumberOfPetalsVD);
+  mLastChipIndexMLOT.resize(mNumberOfLayersMLOT); /// ML and OT are part of TRK as the same detector, without disks
+
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
     std::cout << "Layer MLOT: " << i << std::endl;
     mNumberOfStaves[i] = extractNumberOfStavesMLOT(i);
     mNumberOfHalfStaves[i] = extractNumberOfHalfStavesMLOT(i);
+    mNumberOfModules[i] = extractNumberOfModulesMLOT(i);
+    mNumberOfChips[i] = extractNumberOfChipsMLOT(i);
   }
 
   int numberOfChipsTotal = 0;
@@ -104,13 +111,13 @@ void GeometryTGeo::Build(int loadTrans)
 
   /// filling the information for the MLOT
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
-    mNumberOfChipsPerLayerMLOT[i] = extractNumberOfStavesMLOT(i) * extractNumberOfHalfStavesMLOT(i); // for the moment, considering 1 half stave = 1 chip. TODO: add the final segmentation in chips
+    mNumberOfChipsPerLayerMLOT[i] = mNumberOfStaves[i] * mNumberOfHalfStaves[i] * mNumberOfModules[i] * mNumberOfChips[i];
     numberOfChipsTotal += mNumberOfChipsPerLayerMLOT[i];
     mLastChipIndex[i + mNumberOfPetalsVD] = numberOfChipsTotal - 1;
     mLastChipIndexMLOT[i] = numberOfChipsTotal - 1;
   }
 
-  setSize(numberOfChipsTotal); /// temporary, number of chips = number of staves and active parts
+  setSize(numberOfChipsTotal);
   fillMatrixCache(loadTrans);
 }
 
@@ -221,7 +228,15 @@ int GeometryTGeo::getModule(int index) const
 }
 
 //__________________________________________________________________________
-int GeometryTGeo::getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const
+int GeometryTGeo::getChip(int index) const
+{
+  int subDetID = getSubDetID(index);
+
+  return -1; /// not implemented yet
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave, int halfstave, int module, int chip) const
 {
   if (subDetID == 0) { // VD
     if (lay == -1) {   // disk
@@ -240,7 +255,7 @@ int GeometryTGeo::getChipIndex(int subDetID, int petalcase, int disk, int lay, i
 }
 
 //__________________________________________________________________________
-int GeometryTGeo::getChipIndex(int subDetID, int volume, int lay, int stave, int halfstave) const
+int GeometryTGeo::getChipIndex(int subDetID, int volume, int lay, int stave, int halfstave, int module, int chip) const
 {
   if (subDetID == 0) { // VD
     return volume;     /// In the current configuration for VD, each volume is the sensor element = chip. // TODO: when the geometry naming scheme will be changed, change this method
@@ -256,14 +271,16 @@ int GeometryTGeo::getChipIndex(int subDetID, int volume, int lay, int stave, int
 }
 
 //__________________________________________________________________________
-bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave, int& halfstave) const
+bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave, int& halfstave, int& module, int& chip) const
 {
   subDetID = getSubDetID(index);
   petalcase = getPetalCase(index);
   disk = getDisk(index);
   lay = getLayer(index);
   stave = getStave(index);
   halfstave = getHalfStave(index);
+  module = getModule(index);
+  chip = getChip(index);
 
   return kTRUE;
 }
@@ -272,8 +289,8 @@ bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk
 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);
+  int subDetID, petalcase, disk, layer, stave, halfstave, module, chip; //// TODO: add chips in a second step
+  getChipID(index, subDetID, petalcase, disk, layer, stave, halfstave, module, chip);
 
   // PrintChipID(index, subDetID, petalcase, disk, layer, stave, halfstave);
 
@@ -662,13 +679,69 @@ int GeometryTGeo::extractNumberOfHalfStavesMLOT(int lay) const
   for (int j = 0; j < nNodes; j++) {
     auto nd = dynamic_cast<TGeoNode*>(nodes->At(j)); /// layer node
     const char* name = nd->GetName();
-    if (strstr(name, getTRKChipPattern()) != nullptr) {
+    if (strstr(name, getTRKHalfStavePattern()) != nullptr) {
       numberOfHalfStaves++;
     }
   }
+
+  if (numberOfHalfStaves == 0) {
+    numberOfHalfStaves = 1; /// in case of turbo geometry, there is no half stave volume, but only stave volume
+  }
   return numberOfHalfStaves;
 }
 
+//__________________________________________________________________________
+int GeometryTGeo::extractNumberOfModulesMLOT(int lay) const
+{
+  int numberOfModules = 0;
+
+  std::string staveName = Form("%s%d", getTRKStavePattern(), lay);
+  TGeoVolume* staveV = gGeoManager->GetVolume(staveName.c_str());
+
+  if (staveV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKStavePattern() << " is not in the geometry";
+  }
+
+  // Loop on all staveV nodes, count Module volumes by checking names
+  TObjArray* nodes = staveV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+
+  for (int j = 0; j < nNodes; j++) {
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j)); /// stave node
+    const char* name = nd->GetName();
+    if (strstr(name, getTRKModulePattern()) != nullptr) {
+      numberOfModules++;
+    }
+  }
+  return numberOfModules;
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::extractNumberOfChipsMLOT(int lay) const
+{
+  int numberOfChips = 0;
+
+  std::string moduleName = Form("%s%d", getTRKModulePattern(), lay);
+  TGeoVolume* moduleV = gGeoManager->GetVolume(moduleName.c_str());
+
+  if (moduleV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKModulePattern() << " is not in the geometry";
+  }
+
+  // Loop on all moduleV nodes, count Chip volumes by checking names
+  TObjArray* nodes = moduleV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+
+  for (int j = 0; j < nNodes; j++) {
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j)); /// module node
+    const char* name = nd->GetName();
+    if (strstr(name, getTRKChipPattern()) != nullptr) {
+      numberOfChips++;
+    }
+  }
+  return numberOfChips;
+}
+
 //__________________________________________________________________________
 void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const
 {