add staggered ITOF layout

Author: maciacco

Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h

@@ -49,6 +49,7 @@ struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam>
   bool enableOuterTOF = true;       // Enable Outer TOF layer
   bool enableForwardTOF = false;    // Enable Forward TOF layer
   bool enableBackwardTOF = false;   // Enable Backward TOF layer
+  bool itofTurbo = true;            // Segmented ITOF turbo or staggered
   std::string detectorPattern = ""; // Layouts of the detector
   bool segmentedInnerTOF = true;    // If the inner TOF layer is segmented
   bool segmentedOuterTOF = true;    // If the outer TOF layer is segmented

Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h

@@ -42,6 +42,7 @@ class Layer
   static constexpr int kDisk = 1;
   static constexpr int kBarrelSegmented = 2;
   static constexpr int kDiskSegmented = 3;
+  static constexpr int kBarrelStaggered = 4;
 
   virtual void createLayer(TGeoVolume* motherVolume) {};
 
@@ -74,6 +75,8 @@ class ITOFLayer : public Layer
   virtual void createLayer(TGeoVolume* motherVolume) override;
   static std::vector<std::string> mRegister;
 
+  static const double sStaggerRadialShift;
+
  private:
 };
 

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

@@ -130,7 +130,7 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
     const double staveTiltAngle = itofSegmented ? iotofPars.itofStaveTilt : 0.0; // degrees
     const int modulesPerStave = itofSegmented ? 7 : 0;                           // number of modules per stave in segmented case
     mITOFLayer = ITOFLayer(name,
-                           dInnerTof.first, 0.f, dInnerTof.second, 0.f, x2x0, itofSegmented ? ITOFLayer::kBarrelSegmented : ITOFLayer::kBarrel,
+                           dInnerTof.first, 0.f, dInnerTof.second, 0.f, x2x0, itofSegmented ? (iotofPars.itofTurbo ? ITOFLayer::kBarrelSegmented : ITOFLayer::kBarrelStaggered) : ITOFLayer::kBarrel,
                            nStaves, staveWidth, staveTiltAngle, modulesPerStave, itofSegmented ? sensorThickness : 0.0f);
   }
   if (otof) { // oTOF

Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx

@@ -35,6 +35,8 @@ const double Layer::sChipGap = 200.e-4;       // cm
 const double Layer::sModuleGap = 200.e-4;     // cm
 const double Layer::sChipThickness = 300.e-4; // cm
 
+const double ITOFLayer::sStaggerRadialShift = 0.4; // cm
+
 const double OTOFLayer::sSubStavesDistanceY = 0.3; // cm
 const double OTOFLayer::sSubStavesOverlapX = 1.1;  // cm
 
@@ -54,10 +56,12 @@ Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float
 {
   const float Si_X0 = 9.5f; // cm, radiation length of silicon
   mLayerThickness = mX2X0 * Si_X0;
+  const bool isSegmented = (layout == kBarrelSegmented || layout == kDiskSegmented || layout == kBarrelStaggered);
   std::string name = "";
   switch (layout) {
     case kBarrel:
     case kBarrelSegmented:
+    case kBarrelStaggered:
       name = "barrel";
       mOuterRadius = mInnerRadius + mLayerThickness;
       break;
@@ -73,21 +77,28 @@ Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float
   if (mInnerRadius > mOuterRadius) {
     LOG(fatal) << "Invalid layer dimensions: rInner " << mInnerRadius << " cm is larger than rOuter " << mOuterRadius << " cm";
   }
-  if ((mStaves.first != 0 || mStaves.second != 0.0f) && (layout != kBarrelSegmented && layout != kDiskSegmented)) {
+  if ((mStaves.first != 0 || mStaves.second != 0.0f) && !isSegmented) {
     LOG(fatal) << "Invalid configuration: number of segments " << mStaves.first << " is set for non-segmented layout " << layout;
   }
-  if ((mStaves.first <= 1 || mStaves.second <= 0.0f) && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
+  if ((mStaves.first <= 1 || mStaves.second <= 0.0f) && isSegmented) {
     LOG(fatal) << "Invalid configuration: number of segments " << mStaves.first << " must be positive for segmented layout " << layout;
   }
-  if (mModulesPerStave <= 0 && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
+  if (mModulesPerStave <= 0 && isSegmented) {
     LOG(fatal) << "Invalid configuration: number of sensors per segment " << mModulesPerStave << " must be positive for segmented layout " << layout;
   }
-  if (std::abs(mTiltAngle) > 0.1 && (layout != kBarrelSegmented && layout != kDiskSegmented)) {
+  if (std::abs(mTiltAngle) > 0.1 && !isSegmented) {
     LOG(fatal) << "Invalid configuration: tilt angle " << mTiltAngle << " is set for non-segmented layout " << layout;
   }
-  if ((mTiltAngle < 0.0 || mTiltAngle > 90.0) && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
+  if ((mTiltAngle < 0.0 || mTiltAngle > 90.0) && isSegmented) {
     LOG(fatal) << "Invalid configuration: tilt angle " << mTiltAngle << " is too large, it must be between 0 and 90 degrees";
   }
+  // Staggered and tilted ("turbo") layouts are alternatives
+  if (layout == kBarrelStaggered && std::abs(mTiltAngle) > 1.e-6) {
+    LOG(fatal) << "Invalid configuration: staggered layout requires tilt angle = 0, got " << mTiltAngle;
+  }
+  if (layout == kBarrelStaggered && (mStaves.first % 2) != 0) {
+    LOG(fatal) << "Invalid configuration: staggered layout requires an even number of staves, got " << mStaves.first;
+  }
   if (mSensorThickness < 0.0f || mSensorThickness > mLayerThickness) {
     LOG(fatal) << "Invalid configuration: sensor thickness " << mSensorThickness << " cm is out of range (0, " << mLayerThickness << ") cm";
   }
@@ -177,28 +188,38 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
       motherVolume->AddNode(layerVol, 1, nullptr);
       return;
     }
-    case kBarrelSegmented: {
+    case kBarrelSegmented:
+    case kBarrelStaggered: {
+      // kBarrelSegmented: staves tilted by mTiltAngle, all at the same radius ("turbo" layout)
+      // kBarrelStaggered: untilted staves alternating between an inner and an outer radius
+      const bool staggered = (mLayout == kBarrelStaggered);
+      const double halfShift = staggered ? 0.5 * sStaggerRadialShift : 0.; // cm
+
       // First we create the volume for the whole layer, which will be used as mother volume for the segments
       const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
       const double staveSizeX = mStaves.second;              // cm
       const double staveSizeY = mOuterRadius - mInnerRadius; // cm
       const double staveSizeZ = mZLength;                    // cm
 
-      // Build the mother layer tube from the exact inscribed/outscribed radii of a tilted stave rectangle.
+      // Build the mother layer tube from the exact inscribed/circumscribed radii of the tilted stave rectangle.
+      // For the staggered layout both the inner and the outer stave radii are taken into account.
       const double alpha = mTiltAngle * TMath::DegToRad();
-      const double u0 = -avgRadius * std::cos(alpha);
-      const double v0 = avgRadius * std::sin(alpha);
-      const double uClamped = std::max(-0.5 * staveSizeY, std::min(0.5 * staveSizeY, u0));
-      const double vClamped = std::max(-0.5 * staveSizeX, std::min(0.5 * staveSizeX, v0));
-      const double radiusMin = std::hypot(uClamped - u0, vClamped - v0);
-
       const double uCorners[4] = {-0.5 * staveSizeY, 0.5 * staveSizeY, 0.5 * staveSizeY, -0.5 * staveSizeY};
       const double vCorners[4] = {-0.5 * staveSizeX, -0.5 * staveSizeX, 0.5 * staveSizeX, 0.5 * staveSizeX};
+      double radiusMin = 1.e10;
       double radiusMax = 0.0;
-      for (int i = 0; i < 4; ++i) {
-        radiusMax = std::max(radiusMax, std::hypot(uCorners[i] - u0, vCorners[i] - v0));
+      for (const int s : {-1, 1}) {
+        const double rStave = avgRadius + s * halfShift;
+        const double u0 = -rStave * std::cos(alpha);
+        const double v0 = rStave * std::sin(alpha);
+        const double uClamped = std::max(-0.5 * staveSizeY, std::min(0.5 * staveSizeY, u0));
+        const double vClamped = std::max(-0.5 * staveSizeX, std::min(0.5 * staveSizeX, v0));
+        radiusMin = std::min(radiusMin, std::hypot(uClamped - u0, vClamped - v0));
+        for (int i = 0; i < 4; ++i) {
+          radiusMax = std::max(radiusMax, std::hypot(uCorners[i] - u0, vCorners[i] - v0));
+        }
       }
-      TGeoTube* layer = new TGeoTube(radiusMin, radiusMax, mZLength / 2); // cm, small margins to ensure staves are fully encapsulated in the layer volume
+      TGeoTube* layer = new TGeoTube(radiusMin, radiusMax, mZLength / 2); // cm, encapsulates all staves
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
       setLayerStyle(layerVol);
 
@@ -246,15 +267,17 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
       for (int i = 0; i < mStaves.first; ++i) {
         LOGP(info, "iTOF: Creating stave {}/{} for layer {}", i + 1, mStaves.first, layerVol->GetName());
         const double phi = TMath::TwoPi() * i / mStaves.first;
-        const double x = avgRadius * TMath::Cos(phi);
-        const double y = avgRadius * TMath::Sin(phi);
+        // staggered: even staves on the inner radius, odd staves on the outer radius
+        const double rStave = avgRadius + (staggered ? ((i % 2 == 0) ? -halfShift : halfShift) : 0.);
+        const double x = rStave * TMath::Cos(phi);
+        const double y = rStave * TMath::Sin(phi);
         auto* rotation = new TGeoRotation(Form("segmentRot%d", i + 1), phi * TMath::RadToDeg() + 90 + mTiltAngle, 0, 0);
         auto* transformation = new TGeoCombiTrans(x, y, 0, rotation);
 
-        LOGP(info, "Inserting Barrel {} in {} ", chipVol->GetName(), layerVol->GetName());
+        LOGP(info, "Inserting Barrel {} in {} ", staveVol->GetName(), layerVol->GetName());
         layerVol->AddNode(staveVol, 1 + i, transformation);
       }
-      LOGP(info, "Inserting Barrel {} in {} at r={} cm", layerVol->GetName(), motherVolume->GetName(), avgRadius);
+      LOGP(info, "Inserting Barrel {} in {} at r={} cm{}", layerVol->GetName(), motherVolume->GetName(), avgRadius, staggered ? " (staggered)" : "");
       motherVolume->AddNode(layerVol, 1, nullptr);
       return;
     }