[ALICE3] IOTOF: allow reduced sensor thickness wihout reducing chip size (#15247)

* Enhance Layer class with sensor thickness handling

Added sensor thickness parameter and validation checks.

* Add sensor thickness to Layer class

Added sensor thickness parameter to Layer constructor and updated member variables accordingly.

* Modify configLayers to include sensorThickness

Added sensorThickness parameter to configLayers function for ITOF and OTOF layers.

* Update Detector.h

* Modify thickness parameters in IOTOFBaseParam.h

Updated the radiation length thickness and added sensor thickness parameter.

* Revise options table in README for IOTOF

Updated options table with new sensor thickness parameter and corrected default value for x2x0.

* Simplify chip size calculation in Layer.cxx

Removed sensor thickness adjustment for chip size calculation.

* Update sensor size calculation in Layer.cxx

Author: njacazio

Detectors/Upgrades/ALICE3/IOTOF/README.md

@@ -14,16 +14,18 @@ Configurables for various sub-detectors are presented in the following Table:
 
 [link to definitions](./base/include/IOTOFBase/IOTOFBaseParam.h)
 
-| Options                       | Choices                                                          | Comments                                       |
-| ----------------------------- | ---------------------------------------------------------------- | ---------------------------------------------- |
-| `IOTOFBase.enableInnerTOF`    | `true` (default), `false`                                        | Enable inner TOF barrel layer                  |
-| `IOTOFBase.enableOuterTOF`    | `true` (default), `false`                                        | Enable outer TOF barrel layer                  |
-| `IOTOFBase.enableForwardTOF`  | `true` (default), `false`                                        | Enable forward TOF endcap                      |
-| `IOTOFBase.enableBackwardTOF` | `true` (default), `false`                                        | Enable backward TOF endcap                     |
-| `IOTOFBase.segmentedInnerTOF` | `false` (default), `true`                                        | Use segmented geometry for inner TOF           |
-| `IOTOFBase.segmentedOuterTOF` | `false` (default), `true`                                        | Use segmented geometry for outer TOF           |
-| `IOTOFBase.detectorPattern`   | ` ` (default), `v3b`, `v3b1a`, `v3b1b`, `v3b2a`, `v3b2b`, `v3b3` | Optional layout pattern                        |
-| `IOTOFBase.x2x0`              | `0.000527` (default)                                             | Chip thickness in fractions of the rad. lenght |
+| Options                       | Choices                                                          | Comments                                                                   |
+| ----------------------------- | ---------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| `IOTOFBase.enableInnerTOF`    | `true` (default), `false`                                        | Enable inner TOF barrel layer                                              |
+| `IOTOFBase.enableOuterTOF`    | `true` (default), `false`                                        | Enable outer TOF barrel layer                                              |
+| `IOTOFBase.enableForwardTOF`  | `true` (default), `false`                                        | Enable forward TOF endcap                                                  |
+| `IOTOFBase.enableBackwardTOF` | `true` (default), `false`                                        | Enable backward TOF endcap                                                 |
+| `IOTOFBase.segmentedInnerTOF` | `false` (default), `true`                                        | Use segmented geometry for inner TOF                                       |
+| `IOTOFBase.segmentedOuterTOF` | `false` (default), `true`                                        | Use segmented geometry for outer TOF                                       |
+| `IOTOFBase.detectorPattern`   | ` ` (default), `v3b`, `v3b1a`, `v3b1b`, `v3b2a`, `v3b2b`, `v3b3` | Optional layout pattern                                                    |
+| `IOTOFBase.x2x0`              | `0.02` (default)                                                 | Chip thickness in fractions of the rad. lenght                             |
+| `IOTOFBase.sensorThickness`   | `0.0050` (default)                                               | Sensor thickness in cm, can be at maximum equivalent to the chip thickness |
+
 
 
 For example, a geometry with fully cylindrical tracker barrel (for all layers in VD, ML and OT) can be obtained by

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

@@ -28,7 +28,8 @@ struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam>
   std::string detectorPattern = ""; // Layouts of the detector
   bool segmentedInnerTOF = false;   // If the inner TOF layer is segmented
   bool segmentedOuterTOF = false;   // If the outer TOF layer is segmented
-  float x2x0 = 0.000527f;           // thickness expressed in radiation length, for all layers for the moment
+  float x2x0 = 0.02f;               // thickness expressed in radiation length, for all layers for the moment
+  float sensorThickness = 0.0050f;  // thickness of the sensor in cm, for all layers for the moment, the default is set to 50 microns
 
   O2ParamDef(IOTOFBaseParam, "IOTOFBase");
 };

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

@@ -60,7 +60,7 @@ class Detector : public o2::base::DetImpl<Detector>
     return nullptr;
   }
 
-  void configLayers(bool itof = true, bool otof = true, bool ftof = true, bool btof = true, std::string pattern = "", bool itofSegmented = false, bool otofSegmented = false, const float x2x0 = 0.02f);
+  void configLayers(bool itof = true, bool otof = true, bool ftof = true, bool btof = true, std::string pattern = "", bool itofSegmented = false, bool otofSegmented = false, const float x2x0 = 0.02f, const float sensorThickness = 0.0050f);
 
   void configServices();
   void createMaterials();
@@ -104,4 +104,4 @@ struct UseShm<o2::iotof::Detector> {
 } // namespace base
 } // namespace o2
 #endif
-#endif
+#endif

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

@@ -26,7 +26,7 @@ class Layer
  public:
   Layer() = default;
   Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0,
-        int layout = kBarrel, int nStaves = 0, float staveSize = 0.0, double staveTiltAngle = 0.0, int modulesPerStave = 0);
+        int layout = kBarrel, int nStaves = 0, float staveSize = 0.0, double staveTiltAngle = 0.0, int modulesPerStave = 0, float sensorThickness = 0.0f);
   ~Layer() = default;
 
   auto getInnerRadius() const { return mInnerRadius; }
@@ -52,8 +52,9 @@ class Layer
   float mZLength;
   float mZOffset{0.f}; // Of use when fwd layers
   float mX2X0;
-  float mChipThickness;
-  int mLayout{kBarrel}; // Identifier of the type of layer layout (barrel, disk, barrel segmented, disk segmented)
+  float mChipThickness;   // Thickness of the chip in cm, derived from mX2X0 and the radiation length of silicon
+  float mSensorThickness; // Thickness of the sensor in cm, to be subtracted from the chip thickness to get the total module thickness
+  int mLayout{kBarrel};   // Identifier of the type of layer layout (barrel, disk, barrel segmented, disk segmented)
   // To be used only in case of the segmented layout, to define the number of staves in phi (for barrel) or in r (for disk)
   std::pair<int, float> mStaves{0, 0.0f}; // Number and size of staves in phi (for barrel) or in r (for disk) in case of segmented layout
   int mModulesPerStave{0};                // Number of modules along a stave
@@ -92,4 +93,4 @@ class BTOFLayer : public Layer
 
 } // namespace iotof
 } // namespace o2
-#endif // ALICEO2_IOTOF_LAYER_H
+#endif // ALICEO2_IOTOF_LAYER_H

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

@@ -58,7 +58,7 @@ void Detector::ConstructGeometry()
 }
 
 void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::string pattern, bool itofSegmented, bool otofSegmented,
-                            const float x2x0)
+                            const float x2x0, const float sensorThickness)
 {
 
   const std::pair<float, float> dInnerTof = {21.f, 129.f}; // Radius and length
@@ -102,7 +102,7 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
     const int modulesPerStave = itofSegmented ? 10 : 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,
-                           nStaves, staveWidth, staveTiltAngle, modulesPerStave);
+                           nStaves, staveWidth, staveTiltAngle, modulesPerStave, itofSegmented ? sensorThickness : 0.0f);
   }
   if (otof) { // oTOF
     const std::string name = GeometryTGeo::getOTOFLayerPattern();
@@ -112,7 +112,7 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
     const int modulesPerStave = otofSegmented ? 54 : 0;      // number of modules per stave in segmented case
     mOTOFLayer = OTOFLayer(name,
                            dOuterTof.first, 0.f, dOuterTof.second, 0.f, x2x0, otofSegmented ? OTOFLayer::kBarrelSegmented : OTOFLayer::kBarrel,
-                           nStaves, staveWidth, staveTiltAngle, modulesPerStave);
+                           nStaves, staveWidth, staveTiltAngle, modulesPerStave, otofSegmented ? sensorThickness : 0.0f);
   }
   if (ftof) {
     const std::string name = GeometryTGeo::getFTOFLayerPattern();

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

@@ -28,19 +28,20 @@ namespace o2
 namespace iotof
 {
 Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0,
-             int layout, int nStaves, float staveSize, double staveTiltAngle, int modulesPerStave)
+             int layout, int nStaves, float staveSize, double staveTiltAngle, int modulesPerStave, float sensorThickness)
   : mLayerName(layerName),
     mInnerRadius(rInn),
     mOuterRadius(rOut),
     mZLength(zLength),
     mZOffset(zOffset),
+    mSensorThickness(sensorThickness),
     mX2X0(layerX2X0),
     mLayout(layout),
     mStaves(nStaves, staveSize),
     mModulesPerStave(modulesPerStave),
     mTiltAngle(staveTiltAngle)
 {
-  const float Si_X0 = 9.5f;
+  const float Si_X0 = 9.5f; // cm, radiation length of silicon
   mChipThickness = mX2X0 * Si_X0;
   std::string name = "";
   switch (layout) {
@@ -76,6 +77,12 @@ Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float
   if ((mTiltAngle < 0.0 || mTiltAngle > 90.0) && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
     LOG(fatal) << "Invalid configuration: tilt angle " << mTiltAngle << " is too large, it must be between 0 and 90 degrees";
   }
+  if (mSensorThickness < 0.0f || mSensorThickness > mChipThickness) {
+    LOG(fatal) << "Invalid configuration: sensor thickness " << mSensorThickness << " cm is out of range (0, " << mChipThickness << ") cm";
+  }
+  if (sensorThickness > 0.0f && (layout == kBarrel || layout == kDisk)) {
+    LOG(fatal) << "Invalid configuration: sensor thickness " << mSensorThickness << " cm is set for non-segmented layout, it should be 0";
+  }
 
   LOGP(info, "TOF: Creating {} layer: rInner: {} (cm) rOuter: {} (cm) zLength: {} (cm) zOffset: {} x2X0: {}", name.c_str(), mInnerRadius, mOuterRadius, mZLength, mZOffset, mX2X0);
 }
@@ -193,7 +200,7 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
       const int sensorsPerChipX = 2;                          // we assume that each chip is divided in 2 sensors along the x direction
       const int sensorsPerChipZ = 2;                          // we assume that each chip is divided in 2 sensors along the z direction
       const double sensorSizeX = chipSizeX / sensorsPerChipX; // cm
-      const double sensorSizeY = chipSizeY;                   // cm
+      const double sensorSizeY = mSensorThickness;            // cm
       const double sensorSizeZ = chipSizeZ / sensorsPerChipZ; // cm
       TGeoBBox* sensor = new TGeoBBox(sensorSizeX * 0.5, sensorSizeY * 0.5, sensorSizeZ * 0.5);
       TGeoVolume* sensVol = new TGeoVolume(sensName, sensor, medSi);
@@ -327,7 +334,7 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
       const int sensorsPerChipX = 2;                          // we assume that each chip is divided in 2 sensors along the x direction
       const int sensorsPerChipZ = 2;                          // we assume that each chip is divided in 2 sensors along the z direction
       const double sensorSizeX = chipSizeX / sensorsPerChipX; // cm
-      const double sensorSizeY = chipSizeY;                   // cm
+      const double sensorSizeY = mSensorThickness;            // cm
       const double sensorSizeZ = chipSizeZ / sensorsPerChipZ; // cm
       TGeoBBox* sensor = new TGeoBBox(sensorSizeX * 0.5, sensorSizeY * 0.5, sensorSizeZ * 0.5);
       TGeoVolume* sensVol = new TGeoVolume(sensName, sensor, medSi);