Add option to use a segmented OT (#13325)

* [WIP] Add staves in the naming

[WIP] Add staves to the tracker

* [WIP] Add segmentation of the layers into staves

Add possibility to switch on/off the layer segmentation

* Minor format changes

* Update Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h

---------

Co-authored-by: Matteo Concas <mconcas@cern.ch>

Author: danielbattistini

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

@@ -29,6 +29,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
 
   static const char* getTRKVolPattern() { return sVolumeName.c_str(); }
   static const char* getTRKLayerPattern() { return sLayerName.c_str(); }
+  static const char* getTRKStavePattern() { return sStaveName.c_str(); }
   static const char* getTRKChipPattern() { return sChipName.c_str(); }
   static const char* getTRKSensorPattern() { return sSensorName.c_str(); }
 
@@ -37,12 +38,14 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
     return Form("%s_%d", o2::detectors::DetID(o2::detectors::DetID::TRK).getName(), d);
   }
   static const char* composeSymNameLayer(int d, int layer);
+  static const char* composeSymNameStave(int d, int layer);
   static const char* composeSymNameChip(int d, int lr);
   static const char* composeSymNameSensor(int d, int layer);
 
  protected:
   static std::string sVolumeName;
   static std::string sLayerName;
+  static std::string sStaveName;
   static std::string sChipName;
   static std::string sSensorName;
 

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

@@ -20,9 +20,15 @@ namespace o2
 namespace trk
 {
 
+enum eLayout {
+  kCylinder = 0,
+  kTurboStaves,
+};
+
 struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
   std::string configFile = "";
   float serviceTubeX0 = 0.02f; // X0 Al2O3
+  eLayout layout = kCylinder;  // Type of segmentation of the layers into staves
 
   O2ParamDef(TRKBaseParam, "TRKBase");
 };

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

@@ -20,6 +20,7 @@ std::unique_ptr<o2::trk::GeometryTGeo> GeometryTGeo::sInstance;
 
 // Names
 std::string GeometryTGeo::sVolumeName = "TRKV";
+std::string GeometryTGeo::sStaveName = "TRKStave";
 std::string GeometryTGeo::sLayerName = "TRKLayer";
 std::string GeometryTGeo::sChipName = "TRKChip";
 std::string GeometryTGeo::sSensorName = "TRKSensor";
@@ -65,9 +66,14 @@ const char* GeometryTGeo::composeSymNameLayer(int d, int lr)
   return Form("%s/%s%d", composeSymNameTRK(d), getTRKLayerPattern(), lr);
 }
 
+const char* GeometryTGeo::composeSymNameStave(int d, int lr)
+{
+  return Form("%s/%s%d", composeSymNameLayer(d, lr), getTRKStavePattern(), lr);
+}
+
 const char* GeometryTGeo::composeSymNameChip(int d, int lr)
 {
-  return Form("%s/%s%d", composeSymNameLayer(d, lr), getTRKChipPattern(), lr);
+  return Form("%s/%s%d", composeSymNameStave(d, lr), getTRKChipPattern(), lr);
 }
 
 const char* GeometryTGeo::composeSymNameSensor(int d, int lr)

Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h

@@ -15,6 +15,8 @@
 #include <TGeoManager.h>
 #include <Rtypes.h>
 
+#include "TRKBase/TRKBaseParam.h"
+
 namespace o2
 {
 namespace trk
@@ -27,6 +29,8 @@ class TRKLayer
   TRKLayer(int layerNumber, std::string layerName, float rInn, float zLength, float thick);
   ~TRKLayer() = default;
 
+  void setLayout(eLayout layout) { mLayout = layout; };
+
   auto getInnerRadius() const { return mInnerRadius; }
   auto getOuterRadius() const { return mOuterRadius; }
   auto getZ() const { return mZ; }
@@ -45,8 +49,10 @@ class TRKLayer
   float mZ;
   float mX2X0;
   float mChipThickness;
+  float mModuleWidth; // u.m. = cm
+  eLayout mLayout;
 
-  ClassDef(TRKLayer, 0);
+  ClassDef(TRKLayer, 1);
 };
 
 } // namespace trk

Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx

@@ -114,6 +114,11 @@ void Detector::buildTRKNewVacuumVessel()
   mLayers.emplace_back(8, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(8)}, 45.f, 258.f, 100.e-3);
   mLayers.emplace_back(9, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(9)}, 60.f, 258.f, 100.e-3);
   mLayers.emplace_back(10, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(10)}, 80.f, 258.f, 100.e-3);
+
+  auto& trkPars = TRKBaseParam::Instance();
+  mLayers[8].setLayout(trkPars.layout);
+  mLayers[9].setLayout(trkPars.layout);
+  mLayers[10].setLayout(trkPars.layout);
 }
 
 void Detector::configFromFile(std::string fileName)

Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx

@@ -15,22 +15,25 @@
 #include "Framework/Logger.h"
 
 #include <TGeoTube.h>
+#include <TGeoBBox.h>
 #include <TGeoVolume.h>
 
+#include <TMath.h>
+
 namespace o2
 {
 namespace trk
 {
 TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, float rOut, float zLength, float layerX2X0)
-  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mOuterRadius(rOut), mZ(zLength), mX2X0(layerX2X0)
+  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mOuterRadius(rOut), mZ(zLength), mX2X0(layerX2X0), mModuleWidth(4.54), mLayout(kCylinder)
 {
   float Si_X0 = 9.5f;
   mChipThickness = mX2X0 * Si_X0;
   LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, mZ, mX2X0);
 }
 
 TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, float zLength, float thick)
-  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mZ(zLength), mChipThickness(thick)
+  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mZ(zLength), mChipThickness(thick), mModuleWidth(4.54), mLayout(kCylinder)
 {
   float Si_X0 = 9.5f;
   mOuterRadius = rInn + thick;
@@ -40,29 +43,84 @@ TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, float zLe
 
 void TRKLayer::createLayer(TGeoVolume* motherVolume)
 {
-  std::string chipName = o2::trk::GeometryTGeo::getTRKChipPattern() + std::to_string(mLayerNumber),
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+
+  std::string staveName = o2::trk::GeometryTGeo::getTRKStavePattern() + std::to_string(mLayerNumber),
+              chipName = o2::trk::GeometryTGeo::getTRKChipPattern() + std::to_string(mLayerNumber),
               sensName = Form("%s%d", GeometryTGeo::getTRKSensorPattern(), mLayerNumber);
 
-  TGeoTube* sensor = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
-  TGeoTube* chip = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
   TGeoTube* layer = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
 
-  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
-  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
-
-  TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
-  sensVol->SetLineColor(kYellow);
-  TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
-  chipVol->SetLineColor(kYellow);
   TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
   layerVol->SetLineColor(kYellow);
 
-  LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
-  chipVol->AddNode(sensVol, 1, nullptr);
+  if (mLayout == eLayout::kCylinder) {
+    TGeoTube* stave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
+    TGeoTube* chip = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
+    TGeoTube* sensor = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
+
+    TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
+    sensVol->SetLineColor(kYellow);
+    TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+    chipVol->SetLineColor(kYellow);
+    TGeoVolume* staveVol = new TGeoVolume(staveName.c_str(), stave, medSi);
+    staveVol->SetLineColor(kYellow);
+
+    LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(sensVol, 1, nullptr);
+
+    LOGP(info, "Inserting {} in {} ", chipVol->GetName(), staveVol->GetName());
+    staveVol->AddNode(chipVol, 1, nullptr);
+
+    LOGP(info, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
+    layerVol->AddNode(staveVol, 1, nullptr);
+  } else if (mLayout == eLayout::kTurboStaves) {
+    // Compute the number of staves
+    double width = mModuleWidth * 2; // Each stave has two modules (based on the LOI design)
+    int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / width);
+    nStaves += nStaves % 2; // Require an even number of staves
+
+    // Compute the size of the overlap region
+    double theta = 2 * TMath::Pi() / nStaves;
+    double theta1 = std::atan(width / 2 / mInnerRadius);
+    double st = std::sin(theta);
+    double ct = std::cos(theta);
+    double theta2 = std::atan((mInnerRadius * st - width / 2 * ct) / (mInnerRadius * ct + width / 2 * st));
+    double overlap = (theta1 - theta2) * mInnerRadius;
+    LOGP(info, "Creating a layer with {} staves and {} mm overlap", nStaves, overlap * 10);
+
+    for (int iStave = 0; iStave < nStaves; iStave++) {
+      TGeoBBox* sensor = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
+      TGeoBBox* chip = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
+      TGeoBBox* stave = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
+
+      TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
+      sensVol->SetLineColor(kYellow);
+      TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+      chipVol->SetLineColor(kYellow);
+      TGeoVolume* staveVol = new TGeoVolume(staveName.c_str(), stave, medSi);
+      staveVol->SetLineColor(kYellow);
+
+      // Put the staves in the correct position and orientation
+      TGeoCombiTrans* trans = new TGeoCombiTrans();
+      double theta = 360. * iStave / nStaves;
+      TGeoRotation* rot = new TGeoRotation("rot", theta + 90 + 2, 0, 0);
+      trans->SetRotation(rot);
+      trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
+
+      LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+      chipVol->AddNode(sensVol, 1, nullptr);
 
-  LOGP(info, "Inserting {} in {} ", chipVol->GetName(), layerVol->GetName());
-  layerVol->AddNode(chipVol, 1, nullptr);
+      LOGP(info, "Inserting {} in {} ", chipVol->GetName(), staveVol->GetName());
+      staveVol->AddNode(chipVol, 1, nullptr);
 
+      LOGP(info, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
+      layerVol->AddNode(staveVol, iStave, trans);
+    }
+  } else {
+    LOGP(fatal, "Layout not implemented");
+  }
   LOGP(info, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
   motherVolume->AddNode(layerVol, 1, nullptr);
 }