Add Staggered layers

Author: danielbattistini

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

@@ -23,6 +23,7 @@ namespace trk
 enum eLayout {
   kCylinder = 0,
   kTurboStaves,
+  kStaggered,
 };
 
 struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {

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

@@ -39,8 +39,8 @@ class TRKLayer
   auto getNumber() const { return mLayerNumber; }
   auto getName() const { return mLayerName; }
 
-  TGeoVolume* createSensor(std::string type);
-  TGeoVolume* createChip(std::string type);
+  TGeoVolume* createSensor(std::string type, double width=-1);
+  TGeoVolume* createChip(std::string type, double width=-1);
   TGeoVolume* createStave(std::string type);
   void createLayer(TGeoVolume* motherVolume);
 

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

@@ -41,7 +41,7 @@ TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, float zLe
   LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, mZ, mX2X0);
 }
 
-TGeoVolume* TRKLayer::createSensor(std::string type)
+TGeoVolume* TRKLayer::createSensor(std::string type, double width)
 {
   TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
   std::string sensName = Form("%s%d", GeometryTGeo::getTRKSensorPattern(), this->mLayerNumber);
@@ -51,7 +51,7 @@ TGeoVolume* TRKLayer::createSensor(std::string type)
   if (type == "cylinder") {
     sensor = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
   } else if (type == "flat") {
-    double width = mModuleWidth * 2; // Each stave has two modules (based on the LOI design)
+    if (width < 0) LOGP(fatal, "Attempting to create sensor with invalid width");
     sensor = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
   } else {
     LOGP(fatal, "Sensor of type '{}' is not implemented", type);
@@ -63,7 +63,7 @@ TGeoVolume* TRKLayer::createSensor(std::string type)
   return sensVol;
 };
 
-TGeoVolume* TRKLayer::createChip(std::string type)
+TGeoVolume* TRKLayer::createChip(std::string type, double width)
 {
   TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
   std::string chipName = o2::trk::GeometryTGeo::getTRKChipPattern() + std::to_string(mLayerNumber);
@@ -75,9 +75,9 @@ TGeoVolume* TRKLayer::createChip(std::string type)
     chip = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
     sensVol = createSensor("cylinder");
   } else if (type == "flat") {
-    double width = mModuleWidth * 2; // Each stave has two modules (based on the LOI design)
+    if (width < 0) LOGP(fatal, "Attempting to create chip with invalid width");
     chip = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
-    sensVol = createSensor("flat");
+    sensVol = createSensor("flat", width);
   } else {
     LOGP(fatal, "Sensor of type '{}' is not implemented", type);
   }
@@ -96,22 +96,42 @@ TGeoVolume* TRKLayer::createStave(std::string type)
   std::string staveName = o2::trk::GeometryTGeo::getTRKStavePattern() + std::to_string(mLayerNumber);
 
   TGeoShape* stave;
+  TGeoVolume* staveVol;
   TGeoVolume* chipVol;
 
   if (type == "cylinder") {
     stave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
     chipVol = createChip("cylinder");
+    staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
+    LOGP(info, "Inserting {} in {} ", chipVol->GetName(), staveVol->GetName());
+    staveVol->AddNode(chipVol, 1, nullptr);
   } else if (type == "flat") {
     double width = mModuleWidth * 2; // Each stave has two modules (based on the LOI design)
     stave = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
-    chipVol = createChip("flat");
+    chipVol = createChip("flat", width);
+    staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
+    LOGP(info, "Inserting {} in {} ", chipVol->GetName(), staveVol->GetName());
+    staveVol->AddNode(chipVol, 1, nullptr);
+  } else if (type == "staggered") {
+    double width = mModuleWidth * 2; // Each stave has two modules (based on the LOI design)
+    stave = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
+    TGeoVolume *chipVolLeft = createChip("flat", mModuleWidth);
+    TGeoVolume *chipVolRight = createChip("flat", mModuleWidth);
+    staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
+
+    TGeoCombiTrans* transLeft = new TGeoCombiTrans();
+    transLeft->SetTranslation(-mModuleWidth/2, 0, 0);
+    LOGP(info, "Inserting {} in {} ", chipVolLeft->GetName(), staveVol->GetName());
+    staveVol->AddNode(chipVolLeft, 0, transLeft);
+
+    TGeoCombiTrans* transRight = new TGeoCombiTrans();
+    transRight->SetTranslation(mModuleWidth/2, 0.2, 0);
+    LOGP(info, "Inserting {} in {} ", chipVolRight->GetName(), staveVol->GetName());
+    staveVol->AddNode(chipVolRight, 1, transRight);
   } else {
     LOGP(fatal, "Chip of type '{}' is not implemented", type);
   }
 
-  TGeoVolume* staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
-  LOGP(info, "Inserting {} in {} ", chipVol->GetName(), staveVol->GetName());
-  staveVol->AddNode(chipVol, 1, nullptr);
   staveVol->SetLineColor(kYellow);
 
   return staveVol;
@@ -160,6 +180,34 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       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 {} ", staveVol->GetName(), layerVol->GetName());
+      layerVol->AddNode(staveVol, iStave, trans);
+    }
+  } else if (mLayout == kStaggered) {
+    // 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++) {
+      TGeoVolume* staveVol = createStave("staggered");
+
+      // 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, 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 {} ", staveVol->GetName(), layerVol->GetName());
       layerVol->AddNode(staveVol, iStave, trans);
     }