Make stave geometry available with middle layer disks as well. Currently use simple calculated values for stave placements, these are subject to change. Hence the existence of kSegmentedOTOnly

JustusRudolph · JustusRudolph · commit 8f131f87856c · 2026-04-28T18:56:33.000+02:00
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Module.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Module.h
@@ -56,7 +56,8 @@ class FT3Module
 
   void createModule_staveGeo(
     double mZ, int layerNumber, int direction, double Rin,
-    double Rout, double z_offset_local, TGeoVolume* motherVolume);
+    double Rout, double z_offset_local, const Constants::StaveConfig& staveConfig,
+    TGeoVolume* motherVolume);
 
  private:
   static void create_layout(
@@ -66,7 +67,8 @@ class FT3Module
 
   void create_layout_staveGeo(
     double mZ, int layerNumber, int direction, double Rin,
-    double Rout, double z_offset_local, TGeoVolume* motherVolume);
+    double Rout, double z_offset_local, const Constants::StaveConfig& staveConfig,
+    TGeoVolume* motherVolume);
 
   // Helper functions
   void fill_stave(PosNegPositionTypes& y_positions, double Rin, double Rout,
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3ModuleConstants.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3ModuleConstants.h
@@ -59,52 +59,11 @@ namespace o2::ft3::ModuleConstants
     return nSensorsPerStack * sensor2x1_height +
           (nSensorsPerStack - 1) * sensor2x1_gap;
   }
-  /* 
-   * Constants for staves are written for both positive
-   * and negative x even though they are just mirrored now,
-   * because there might be design changes in the future
-   * that require a non-mirrored layout, making it easier to
-   * change here if so required, even though it looks uglier now.
-   * 
-   * The second element in the mapping pair is whether the stave
-   * with a certain ID should be mirrored around the x-axis.
-   */
-  // map from Stave ID (1-indexed from other documents) to midpoint
-  // Do NOT add any zero midpoints, this is taken off separately
-  const std::map<int, std::pair<double, bool>> staveID_to_y_midpoint = {
-    {-2, {39.0, true}},
-    {-1, {41.4, true}},
-    {1, {41.4, true}},
-    {2, {39.0, true}}
-  };
-  // lengths of staves, their midpoint, and their face
-  const std::vector<double> y_lengths = {
-    52.8, 66.0, 79.2, 92.4, 99.0, 105.6, 118.8, 118.8,
-    128.7, 132.0, 132.0, 138.6, 138.6, 56.1, 52.8,
-    52.8, 56.1, 138.6, 138.6, 132.0, 132.0, 128.7,
-    118.8, 118.8, 105.6, 99.0, 92.4, 79.2, 66.0, 52.8
-  };
-  const std::vector<double> x_midpoints = {
-    -65.25, -60.75, -56.25, -51.75, -47.25, -42.75, -38.25,  // L
-    -33.75, -29.25, -24.75, -20.25, -15.75, -11.25, -6.75, -2.25,  // L
-    2.25, 6.75, 11.25, 15.75, 20.25, 24.75, 29.25, 33.75,  // R
-    38.25, 42.75, 47.25, 51.75, 56.25, 60.75, 65.25  // R
-  };
-  const double x_midpoint_spacing = 4.5; // assume constant for now
-  // which side of the disc do we place the stave?
-  // used for kSegmentedMarch26 for front/back face, and for
-  // kSegmentedStave for staggering staves in z (see z_offsetStave)
-  // accessed via stave index, NOT stave ID
-  const std::vector<bool> staveOnFront =
-  {
-     1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,  // L
-     0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0  // R
-  };
 
   // small helper function to get 1-indexed stave ID, counting from the middle outwards,
   // with negative IDs on the left and positive IDs on the right
-  inline const int staveIdxToID(int staveIdx) {
-    unsigned nStavesOneSide = y_lengths.size() / 2;
+  inline const int staveIdxToID(int staveIdx, unsigned nStavesPerDisc) {
+    unsigned nStavesOneSide = nStavesPerDisc / 2;
     bool isRight = staveIdx >= nStavesOneSide;
     return staveIdx - nStavesOneSide + isRight;
   }
@@ -132,15 +91,117 @@ namespace o2::ft3::ModuleConstants
    */
   // If midpoint spacing becomes non constant, this becomes a function
   // TODO: add some tolerance to avoid overlaps?
-  const double z_offsetStave =
-    staveTriangleHeight * (2 - x_midpoint_spacing / ( sensor2x1_width / 2 + staveSensorGap ) );
+  inline const double z_offsetStave(double x_midpoint_spacing) {
+    return staveTriangleHeight *
+           (2 - x_midpoint_spacing / ( sensor2x1_width / 2 + staveSensorGap ) );
+  }
 
   const int SiColor = kGreen;
   const int SiInactiveColor = kRed;
   const int glueColor = kBlue;
   const int CuColor = kOrange;
   const int kaptonColor = kYellow;
   const int carbonColor = kBlack;
-}
+
+  // Struct for stave position configuration (varies between IT/OT)
+  struct StaveConfig {
+    /* 
+     * Constants for staves are written for both positive
+     * and negative x even though they are just mirrored now,
+     * because there might be design changes in the future
+     * that require a non-mirrored layout, making it easier to
+     * change here if so required, even though it looks uglier now.
+     * 
+     * The second element in the mapping pair is whether the stave
+     * with a certain ID should be mirrored around the x-axis.
+     */
+    // map from Stave ID (1-indexed from other documents) to midpoint
+    // Do NOT add any zero midpoints, this is taken off separately
+    const std::map<int, std::pair<double, bool>>& staveID_to_y_midpoint;
+    // lengths of staves, their midpoint, and their face
+    const std::vector<double>& y_lengths;
+    const std::vector<double>& x_midpoints;
+    double x_midpoint_spacing;
+    // which side of the disc do we place the stave?
+    // kSegmentedStave: staggering staves in z (see z_offsetStave)
+    // accessed via stave index, NOT stave ID
+    const std::vector<bool>& staveOnFront;
+  };
+
+  namespace OT_StavePositions {
+    const std::map<int, std::pair<double, bool>> staveID_to_y_midpoint = {
+      {-2, {39.0, true}},
+      {-1, {41.4, true}},
+      {1, {41.4, true}},
+      {2, {39.0, true}}
+    };
+    const std::vector<double> y_lengths = {
+      52.8, 66.0, 79.2, 92.4, 99.0, 105.6, 118.8, 118.8,
+      128.7, 132.0, 132.0, 138.6, 138.6, 56.1, 52.8,
+      52.8, 56.1, 138.6, 138.6, 132.0, 132.0, 128.7,
+      118.8, 118.8, 105.6, 99.0, 92.4, 79.2, 66.0, 52.8
+    };
+    const std::vector<double> x_midpoints = {
+      -65.25, -60.75, -56.25, -51.75, -47.25, -42.75, -38.25,  // L
+      -33.75, -29.25, -24.75, -20.25, -15.75, -11.25, -6.75, -2.25,  // L
+      2.25, 6.75, 11.25, 15.75, 20.25, 24.75, 29.25, 33.75,  // R
+      38.25, 42.75, 47.25, 51.75, 56.25, 60.75, 65.25  // R
+    };
+    const double x_midpoint_spacing = 4.5; // assume constant for now
+    const std::vector<bool> staveOnFront =
+    {
+      1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,  // L
+      0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0  // R
+    };
+  }  // namespace OT_StavePositions
+
+  namespace ML_StavePositions {
+    // Use prelim numbers for now, these will change! TODO
+    const std::map<int, std::pair<double, bool>> staveID_to_y_midpoint = {
+      {-3, {19.1, true}},
+      {-2, {21.8, true}},
+      {-1, {22.5, true}},
+      {1, {22.5, true}},
+      {2, {21.8, true}},
+      {3, {19.1, true}}
+    };
+    const std::vector<double> y_lengths = {
+      30.5, 44.5, 53.6, 60.0, 64.6, 29.5, 25.8, 25.0,
+      25.0, 25.8, 29.5, 64.6, 60.0, 53.6, 44.5, 30.5
+    };
+    const std::vector<double> x_midpoints = {
+      -33.75, -29.25, -24.75, -20.25, -15.75, -11.25, -6.75, -2.25,  // L
+      2.25, 6.75, 11.25, 15.75, 20.25, 24.75, 29.25, 33.75  // R
+    };
+    const double x_midpoint_spacing = 4.5;
+    const std::vector<bool> staveOnFront =
+    {
+      1, 0, 1, 0, 1, 0, 1, 0, // L
+      0, 1, 0, 1, 0, 1, 0, 1  // R
+    };
+  }  // namespace ML_StavePositions
+
+  // Get stave configuration based on tracker type
+  inline StaveConfig getStaveConfig(bool isInnerDisk) {
+    if (isInnerDisk) {
+      return StaveConfig{
+        ML_StavePositions::staveID_to_y_midpoint,
+        ML_StavePositions::y_lengths,
+        ML_StavePositions::x_midpoints,
+        ML_StavePositions::x_midpoint_spacing,
+        ML_StavePositions::staveOnFront
+      };
+    } else {
+      return StaveConfig{
+        OT_StavePositions::staveID_to_y_midpoint,
+        OT_StavePositions::y_lengths,
+        OT_StavePositions::x_midpoints,
+        OT_StavePositions::x_midpoint_spacing,
+        OT_StavePositions::staveOnFront
+      };
+    }
+  }
+
+}  // namespace o2::ft3::ModuleConstants
 
 #endif // FT3MODULECONSTANTS_H
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
@@ -403,7 +403,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
     LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
     motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
   } else if (ft3Params.layoutFT3 == kSegmented ||
-             ft3Params.layoutFT3 == kSegmentedStave) {
+              (ft3Params.layoutFT3 == kSegmentedStaveOTOnly && mIsMiddleLayer)) {
     FT3Module module;
 
     // layer structure
@@ -413,42 +413,64 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
 
     TGeoMedium* medAir = gGeoManager->GetMedium("FT3_AIR$");
     TGeoVolume* layerVol = nullptr;
+      // Add a little additional room in radius
+    TGeoTube* layer = new TGeoTube(mInnerRadius - 0.1, mOuterRadius + 0.1, 1.5);
+    layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+    layerVol->SetLineColor(kYellow + 2);
+    // createSeparationLayer_waterCooling(motherVolume, separationLayerName);
+    createSeparationLayer(layerVol, separationLayerName);
+    module.createModule(0, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "front", "rectangular", layerVol);
+    module.createModule(0, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "back", "rectangular", layerVol);
+
+    // Finally put everything in the mother volume
+    auto* FwdDiskRotation = new TGeoRotation("FwdDiskRotation", 0, 0, 180);
+    // need to shift outwards always, so + forwards and - backwards
+    auto* FwdDiskCombiTrans = new TGeoCombiTrans(0, 0, mZ + 0, FwdDiskRotation);
+
+    LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
+    motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
+  } else if (ft3Params.layoutFT3 == kSegmentedStave ||
+             ft3Params.layoutFT3 == kSegmentedStaveOTOnly) {
+    FT3Module module;
+
+    // layer structure
+    std::string frontLayerName = o2::ft3::GeometryTGeo::getFT3LayerPattern() + std::to_string(mDirection) + std::to_string(mLayerNumber) + "_Front";
+    std::string backLayerName = o2::ft3::GeometryTGeo::getFT3LayerPattern() + std::to_string(mDirection) + std::to_string(mLayerNumber) + "_Back";
+    std::string separationLayerName = "FT3SeparationLayer" + std::to_string(mDirection) + std::to_string(mLayerNumber);
+
+    TGeoMedium* medAir = gGeoManager->GetMedium("FT3_AIR$");
+    TGeoVolume* layerVol = nullptr;
+
+    // set up stave config, differs between ML and OT disks
+    const Constants::StaveConfig& staveConfig = Constants::getStaveConfig(mIsMiddleLayer);
+
+    // need a thicker air layer to encompass the staves (4.5cm high, 1.2cm offsets)
+    // stave face is at z=0 (or +-z_offset_stave), meaning that volumes are at
+    // ~-+1cm < z < ~+-6cm, the +- referring forward/backward discs
+    double z_layer_thickness =  // need to shift internally with this
+      o2::ft3::ModuleConstants::staveTriangleHeight +
+      o2::ft3::ModuleConstants::z_offsetStave(staveConfig.x_midpoint_spacing) +
+      o2::ft3::ModuleConstants::siliconThickness +
+      o2::ft3::ModuleConstants::copperThickness +
+      o2::ft3::ModuleConstants::kaptonThickness +
+      o2::ft3::ModuleConstants::epoxyThickness * 2 +
+      0.5; // add some extra room to ensure all volumes are encapsulated
+
     // shift stave volumes into layer volume, since nominal z_{stave face} = 0
-    double z_local_offset = 0;
-    if (ft3Params.layoutFT3 == kSegmented) {
-       // Add a little additional room in radius
-      TGeoTube* layer = new TGeoTube(mInnerRadius - 0.1, mOuterRadius + 0.1, 1.5);
-      layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-      layerVol->SetLineColor(kYellow + 2);
-      // createSeparationLayer_waterCooling(motherVolume, separationLayerName);
-      createSeparationLayer(layerVol, separationLayerName);
-      module.createModule(0, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "front", "rectangular", layerVol);
-      module.createModule(0, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "back", "rectangular", layerVol);
-    } else if (ft3Params.layoutFT3 == kSegmentedStave) {
-      // need a thicker air layer to encompass the staves (4.5cm high, 1.2cm offsets)
-      // stave face is at z=0 (or +-z_offset_stave), meaning that volumes are at
-      // ~-+1cm < z < ~+-6cm, the +- referring forward/backward discs
-      double z_layer_thickness =  // need to shift internally with this
-        o2::ft3::ModuleConstants::staveTriangleHeight +
-        o2::ft3::ModuleConstants::z_offsetStave +
-        o2::ft3::ModuleConstants::siliconThickness +
-        o2::ft3::ModuleConstants::copperThickness +
-        o2::ft3::ModuleConstants::kaptonThickness +
-        o2::ft3::ModuleConstants::epoxyThickness * 2 +
-        0.5; // add some extra room to ensure all volumes are encapsulated
-      z_local_offset = z_layer_thickness / 2.0;
-      TGeoTube* layer = new TGeoTube(mInnerRadius - 12, mOuterRadius + 5, z_layer_thickness / 2);
-      layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-      if (ft3Params.drawReferenceCircles) {
-        std::string referenceCirclesName = "ReferenceCircles_Dir" + std::to_string(mDirection)
-                                       + "_Layer" + std::to_string(mLayerNumber);
-        createReferenceCircles(layerVol, referenceCirclesName); // for visualization purposes
-      }
-      // need the -0.5 added to local offset to ensure all sensor modules are inside the layer
-      module.createModule_staveGeo(0., mLayerNumber, mDirection, mInnerRadius,
-                                   mOuterRadius, z_local_offset, layerVol);
+    double z_local_offset = z_layer_thickness / 2.0;
+    TGeoTube* layer = new TGeoTube(mInnerRadius - 12, mOuterRadius + 5, z_layer_thickness / 2);
+    layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+
+    if (ft3Params.drawReferenceCircles) {
+      std::string referenceCirclesName = "ReferenceCircles_Dir" + std::to_string(mDirection)
+                                      + "_Layer" + std::to_string(mLayerNumber);
+      createReferenceCircles(layerVol, referenceCirclesName); // for visualization purposes
     }
-    // Finally put everything in the mother volume
+
+    // need the -0.5 added to local offset to ensure all sensor modules are inside the layer
+    module.createModule_staveGeo(0., mLayerNumber, mDirection, mInnerRadius,
+                                  mOuterRadius, z_local_offset, staveConfig, layerVol);
+  // Finally put everything in the mother volume
     auto* FwdDiskRotation = new TGeoRotation("FwdDiskRotation", 0, 0, 180);
     // need to shift outwards always, so + forwards and - backwards
     double z_offset_directional = mDirection ? z_local_offset : -z_local_offset;
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
