FCT Segmentation in trapezoids

Author: Cas1997

Detectors/Upgrades/ALICE3/FCT/base/include/FCTBase/FCTBaseParam.h

@@ -26,7 +26,8 @@ namespace fct
 
 enum FCTGeometry {
   Default = 0,
-  Telescope = 1
+  Telescope = 1,
+  Segmented = 2
 };
 
 struct FCTBaseParam : public o2::conf::ConfigurableParamHelper<FCTBaseParam> {
@@ -42,6 +43,10 @@ struct FCTBaseParam : public o2::conf::ConfigurableParamHelper<FCTBaseParam> {
   Float_t etaOut = 1.5;
   Float_t Layerx2X0 = 0.01;
 
+  // FCTGeometry::Segmented parameters
+  Int_t nRadSeg = 2;
+  Int_t nAziSeg = 5;
+
   // FCTGeometry::External file
   std::string configFile = ""; // Overrides geoModel parameter when provided
 

Detectors/Upgrades/ALICE3/FCT/base/include/FCTBase/GeometryTGeo.h

@@ -101,7 +101,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   static const char* composeSymNameSensor(Int_t d, Int_t lr);
 
  protected:
-  static constexpr int MAXLAYERS = 15; ///< max number of active layers
+  static constexpr int MAXLAYERS = 200; ///< max number of active layers/segments
 
   Int_t mNumberOfLayers;               ///< number of layers
   static std::string sInnerVolumeName; ///< Mother inner volume name

Detectors/Upgrades/ALICE3/FCT/simulation/CMakeLists.txt

@@ -11,13 +11,15 @@
 
 o2_add_library(FCTSimulation
                SOURCES src/FCTLayer.cxx
+                       src/FCTSegment.cxx
                        src/Detector.cxx
                PUBLIC_LINK_LIBRARIES O2::FCTBase
                                      O2::ITSMFTSimulation
                                      ROOT::Physics)
 
 o2_target_root_dictionary(FCTSimulation
                           HEADERS include/FCTSimulation/Detector.h
-                                  include/FCTSimulation/FCTLayer.h)
+                                  include/FCTSimulation/FCTLayer.h
+                                  include/FCTSimulation/FCTSegment.h)
 
 o2_data_file(COPY data  DESTINATION Detectors/FCT/simulation)

Detectors/Upgrades/ALICE3/FCT/simulation/include/FCTSimulation/Detector.h

@@ -46,6 +46,7 @@ namespace o2
 namespace fct
 {
 class FCTLayer;
+class FCTSegment;
 }
 } // namespace o2
 
@@ -54,6 +55,7 @@ namespace o2
 namespace fct
 {
 class FCTLayer;
+class FCTSegment;
 
 class Detector : public o2::base::DetImpl<Detector>
 {
@@ -113,6 +115,7 @@ class Detector : public o2::base::DetImpl<Detector>
 
   void buildBasicFCT(const FCTBaseParam& param);
   void buildFCTV1();
+  void buildSegmentedFCT(const FCTBaseParam& param);
   void buildFCTFromFile(std::string);
 
   GeometryTGeo* mGeometryTGeo; //! access to geometry details
@@ -154,6 +157,7 @@ class Detector : public o2::base::DetImpl<Detector>
 
   std::vector<FCTLayer> mLayers;
   std::vector<FCTLayer> mConverterLayers;
+  std::vector<o2::fct::FCTSegment> mSegments;
   bool mIsPipeActivated = true; //! If Alice 3 pipe is present append inner disks to vacuum volume to avoid overlaps
 
   template <typename Det>

Detectors/Upgrades/ALICE3/FCT/simulation/include/FCTSimulation/FCTSegment.h

@@ -0,0 +1,85 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file FCTSegment.h
+/// \brief Definition of the FCTSegment class
+
+#ifndef ALICEO2_FCT_SEGMENT_H_
+#define ALICEO2_FCT_SEGMENT_H_
+
+#include "Rtypes.h"                 // for Double_t, Int_t, Bool_t, etc
+#include "FCTSimulation/Detector.h" // for Detector, Detector::Model
+
+class TGeoVolume;
+
+namespace o2
+{
+namespace fct
+{
+
+/// This class defines the Geometry for the FCT segment TGeo. This is a work class used
+/// to study different configurations during the development of the ALICE3 EndCaps
+class FCTSegment : public TObject
+{
+ public:
+  // Default constructor
+  FCTSegment() = default;
+
+  // Segment constructor
+  FCTSegment(Int_t segmentNumber, std::string segmentName, Double_t x, Double_t y, Double_t z, Double_t vertL, Double_t innerL, Double_t outerL, Double_t rotX, Double_t rotY, Double_t rotZ, Float_t segmentx2X0);
+
+  /// Copy constructor
+  FCTSegment(const FCTSegment&) = default;
+
+  /// Assignment operator
+  FCTSegment& operator=(const FCTSegment&) = default;
+
+  /// Default destructor
+  ~FCTSegment() override;
+
+  /// getters
+  auto getSegmentNumber() const { return mSegmentNumber; }
+  auto getX() const { return mX; }
+  auto getY() const { return mY; }
+  auto getZ() const { return mZ; }
+  auto getXRot() const { return mX; }
+  auto getYRot() const { return mY; }
+  auto getZRot() const { return mZ; }
+  auto getVertL() const { return mVertL; }
+  auto getInnerL() const { return mInnerL; }
+  auto getOuterL() const { return mOuterL; }
+  auto getx2X0() const { return mx2X0; }
+
+  /// Creates the actual Segment and places inside its mother volume
+  /// \param motherVolume the TGeoVolume owing the volume structure
+  virtual void createSegment(TGeoVolume* motherVolume);
+
+ private:
+  Int_t mSegmentNumber = -1; 				///< Current segment number
+  std::string mSegmentName;  			///< Current segment name
+  Double_t mVertL;                 ///< Vertical length of the trapezoid
+  Double_t mInnerL;                ///< Inner side length of the trapezoid
+  Double_t mOuterL;                ///< Outer side length of the trapezoid
+  Double_t mX;             				///< X position of the segment
+  Double_t mY;             				///< Y position of the segment
+  Double_t mZ;             				///< Z position of the segment
+  Double_t mRotX;                  ///< X rotation of the segment
+  Double_t mRotY;                  ///< X rotation of the segment
+  Double_t mRotZ;                  ///< X rotation of the segment
+  Double_t mChipThickness; 				///< Chip thickness
+  Double_t mx2X0;          				///< segment material budget x/X0
+
+  ClassDefOverride(FCTSegment, 0); // ALICE 3 EndCaps geometry
+};
+} // namespace fct
+} // namespace o2
+
+#endif

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

@@ -16,6 +16,7 @@
 #include "FCTBase/GeometryTGeo.h"
 #include "FCTSimulation/Detector.h"
 #include "FCTSimulation/FCTLayer.h"
+#include "FCTSimulation/FCTSegment.h"
 #include "FCTBase/FCTBaseParam.h"
 
 #include "DetectorsBase/Stack.h"
@@ -203,6 +204,58 @@ void Detector::buildBasicFCT(const FCTBaseParam& param)
   }
 }
 
+void Detector::buildSegmentedFCT(const FCTBaseParam& param){
+  // Build the FCT with its layers segmented in trapezoids. The z distance is the same as the default configuration
+  LOG(info) << "Building FCT Detector: Segmented Telescope";
+  
+  int numberOfLayers = 11;
+  Float_t layersx2X0 = 1.e-2;
+  std::vector<std::array<Float_t, 4>> layersConfig{
+    {442.0, 5.0, 17.0, layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
+    {444.0, 5.0, 17.0, layersx2X0},
+    {446.0, 5.0, 17.0, layersx2X0},
+    {448.0, 5.0, 17.0, layersx2X0},
+    {450.0, 5.0, 17.0, layersx2X0},
+    {452.0, 5.0, 17.0, layersx2X0},
+    {460.0, 5.0, 17.0, layersx2X0},
+    {470.0, 5.0, 18.0, layersx2X0},
+    {480.0, 5.0, 18.0, layersx2X0},
+    {490.0, 5.0, 19.0, layersx2X0},
+    {500.0, 5.0, 19.0, layersx2X0}};
+
+  mLayerID.clear();
+  mLayerName.clear();
+  mLayers.clear();
+
+  Double_t segAngle = 2.*TMath::Pi() / (Double_t)param.nAziSeg;
+  const Float_t kRadDeg = 180./TMath::Pi();
+  int segmentNumber = 0;
+  for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
+    Double_t zPosTrap = layersConfig[layerNumber][0];
+    Double_t rIn = layersConfig[layerNumber][1];
+    Double_t rOut = layersConfig[layerNumber][2];
+    Double_t x2X0 = layersConfig[layerNumber][3];
+    Double_t radialSegLength = (rOut - rIn) / ((Double_t)(param.nRadSeg));
+	  Double_t trapezoidVertLength = radialSegLength*TMath::Cos(segAngle/2.);
+    for (int radialNumber = 0; radialNumber < param.nRadSeg; radialNumber++) {
+      for (int azimuthalNumber = 0; azimuthalNumber < param.nAziSeg; azimuthalNumber++) {
+        Double_t innerTrapLength = TMath::Sqrt(2. * (rIn + radialNumber * radialSegLength)*(rIn + radialNumber * radialSegLength) * (1. - TMath::Cos(segAngle)));
+        Double_t outerTrapLength = TMath::Sqrt(2. * (rIn + (radialNumber + 1) * radialSegLength)*(rIn + (radialNumber + 1) * radialSegLength) * (1. - TMath::Cos(segAngle)));
+        Double_t innerTrapCenterR = (rIn + radialNumber * radialSegLength)*TMath::Cos(segAngle/2.);
+        Double_t outerTrapCenterR = (rIn + (radialNumber + 1) * radialSegLength)*TMath::Cos(segAngle/2.);
+        Double_t rTrapCenter = outerTrapCenterR - 0.5*(outerTrapCenterR - innerTrapCenterR);
+        Double_t xPosTrap = rTrapCenter * TMath::Cos(azimuthalNumber * segAngle);
+        Double_t yPosTrap = rTrapCenter * TMath::Sin(azimuthalNumber * segAngle);
+        Double_t xRot = -90 + azimuthalNumber*segAngle*kRadDeg;
+        std::string segmentName = GeometryTGeo::getFCTLayerPattern() + std::to_string(segmentNumber);
+        mSegments.emplace_back(segmentNumber, segmentName, xPosTrap, yPosTrap, zPosTrap, trapezoidVertLength, innerTrapLength, outerTrapLength, xRot, 0., 0., x2X0);
+        segmentNumber++;
+      }
+    }
+  }
+  mNumberOfLayers = segmentNumber;
+}
+
 //_________________________________________________________________________________________________
 void Detector::buildFCTV1()
 {
@@ -479,6 +532,9 @@ void Detector::ConstructGeometry()
       case Telescope:
         buildBasicFCT(fctBaseParam); // BasicFCT = Parametrized telescopic detector (equidistant layers)
         break;
+      case Segmented: 
+        buildSegmentedFCT(fctBaseParam); // Layers of the FCT are segmented in trapezoids. 
+        break;
       default:
         LOG(fatal) << "Invalid Geometry.\n";
         break;
@@ -536,15 +592,25 @@ void Detector::createGeometry()
     for (Int_t iLayer = 0; iLayer < mConverterLayers.size(); iLayer++) {
       mConverterLayers[iLayer].createLayer(volFCT);
     }
+    for (Int_t iSegment = 0; iSegment < mSegments.size(); iSegment++){
+      mSegments[iSegment].createSegment(volFCT);
+    }
     vALIC->AddNode(volFCT, 2, new TGeoTranslation(0., 30., 0.));
   }
 
-  LOG(info) << "Registering FCT SensitiveLayerIDs:";
+  if(!mLayers.size()){LOG(info) << "Registering FCT SensitiveLayerIDs:";}
   for (int iLayer = 0; iLayer < mLayers.size(); iLayer++) {
     auto layerID = gMC ? TVirtualMC::GetMC()->VolId(Form("%s_%d", GeometryTGeo::getFCTSensorPattern(), mLayers[iLayer].getLayerNumber())) : 0;
     mLayerID.push_back(layerID);
     LOG(info) << "  mLayerID[" << mLayers[iLayer].getLayerNumber() << "] = " << layerID;
   }
+
+  if(!mSegments.size()){LOG(info) << "Registering FCT SensitiveSegmentIDs:";}
+  for (int iSegment = 0; iSegment < mSegments.size(); iSegment++) {
+    auto segmentID = gMC ? TVirtualMC::GetMC()->VolId(Form("%s_%d", GeometryTGeo::getFCTSensorPattern(), mSegments[iSegment].getSegmentNumber())) : 0;
+    mLayerID.push_back(segmentID);
+    LOG(info) << "  mSegmentID[" << mSegments[iSegment].getSegmentNumber() << "] = " << segmentID;
+  }
 }
 
 //_________________________________________________________________________________________________
@@ -563,6 +629,13 @@ void Detector::defineSensitiveVolumes()
     LOG(info) << "Adding FCT Sensitive Volume => " << v->GetName();
     AddSensitiveVolume(v);
   }
+
+  for (Int_t iSegment = 0; iSegment < mSegments.size(); iSegment++) {
+    volumeName = o2::fct::GeometryTGeo::getFCTSensorPattern() + std::to_string(mSegments[iSegment].getSegmentNumber());
+    v = geoManager->GetVolume(Form("%s_%d", GeometryTGeo::getFCTSensorPattern(), mSegments[iSegment].getSegmentNumber()));
+    LOG(info) << "Adding FCT Sensitive Volume => " << v->GetName();
+    AddSensitiveVolume(v);   
+  }
 }
 
 //_________________________________________________________________________________________________

Detectors/Upgrades/ALICE3/FCT/simulation/src/FCTSegment.cxx

@@ -0,0 +1,97 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file FCTSegment.cxx
+/// \brief Implementation of the FCTSegment class
+/// \author Mario Sitta <sitta@to.infn.it>
+/// \author Chinorat Kobdaj (kobdaj@g.sut.ac.th)
+
+#include "FCTSimulation/FCTSegment.h"
+#include "FCTBase/GeometryTGeo.h"
+#include "FCTSimulation/Detector.h"
+
+#include <fairlogger/Logger.h> // for LOG
+
+#include <TGeoManager.h> // for TGeoManager, gGeoManager
+#include <TGeoMatrix.h>  // for TGeoCombiTrans, TGeoRotation, etc
+#include <TGeoMedium.h>
+#include <TGeoArb8.h>           // for TGeoTrap
+#include <TGeoVolume.h>         // for TGeoVolume, TGeoVolumeAssembly
+#include <TGeoCompositeShape.h> // for TGeoCompositeShape
+#include <TGeoMatrix.h>			// for TGeoCombiTrans
+#include "TMathBase.h"          // for Abs
+#include <TMath.h>              // for Sin, RadToDeg, DegToRad, Cos, Tan, etc
+
+#include <cstdio> // for snprintf
+
+using namespace TMath;
+using namespace o2::fct;
+using namespace o2::itsmft;
+
+ClassImp(FCTSegment);
+
+FCTSegment::~FCTSegment() = default;
+
+FCTSegment::FCTSegment(Int_t segmentNumber, std::string segmentName, Double_t x, Double_t y, Double_t z, Double_t vertL, Double_t innerL, Double_t outerL, Double_t rotX, Double_t rotY, Double_t rotZ, Float_t segmentx2X0) : 
+            mSegmentNumber(segmentNumber), mSegmentName(segmentName), mx2X0(segmentx2X0),
+            mX(x), mY(y), mZ(z), mRotX(rotX), mRotY(rotY), mRotZ(rotZ),
+            mVertL(vertL), mInnerL(innerL), mOuterL(outerL)
+{
+  
+  Float_t Si_X0 = 9.37;   // In cm
+  mChipThickness = mx2X0 * Si_X0;
+  LOG(info) << "Creating FCT segment: segment " << mSegmentNumber;
+  LOG(info) << "   Using silicon X0 = " << Si_X0 << " to emulate segment radiation length.";
+  LOG(info) << "   Segment z = " << mZ << " ; vertL = " << mVertL << " ; innerL = " << mInnerL << " ; outerL = " << mOuterL <<  " ; x2X0 = " << mx2X0 << " ; ChipThickness = " << mChipThickness;
+}
+
+void FCTSegment::createSegment(TGeoVolume* motherVolume)
+{
+  if (mSegmentNumber < 0) {
+    return;
+  }
+  // Create tube, set sensitive volume, add to mother volume
+
+  std::string chipName = o2::fct::GeometryTGeo::getFCTChipPattern() + std::to_string(mSegmentNumber),
+              sensName = Form("%s_%d", GeometryTGeo::getFCTSensorPattern(), mSegmentNumber);
+  TGeoTrap *sensor = new TGeoTrap(mChipThickness/2., 0., 0., 
+                                  mVertL/2., mInnerL/2., mOuterL/2., 0.,
+                                  mVertL/2., mInnerL/2., mOuterL/2., 0.);
+  TGeoTrap *chip = new TGeoTrap(mChipThickness/2., 0., 0., 
+                                  mVertL/2., mInnerL/2., mOuterL/2., 0.,
+                                  mVertL/2., mInnerL/2., mOuterL/2., 0.);
+  TGeoTrap *segment = new TGeoTrap(mChipThickness/2., 0., 0., 
+                                  mVertL/2., mInnerL/2., mOuterL/2., 0.,
+                                  mVertL/2., mInnerL/2., mOuterL/2., 0.);
+
+  TGeoMedium* medSi = gGeoManager->GetMedium("FCT_SILICON$");
+  TGeoMedium* medAir = gGeoManager->GetMedium("FCT_AIR$");
+
+  TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
+  sensVol->SetLineColor(kSpring + 5);
+  TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+  chipVol->SetLineColor(kSpring + 5);
+  TGeoVolume* segmentVol = new TGeoVolume(mSegmentName.c_str(), segment, medAir);
+  segmentVol->SetLineColor(kSpring + 5);
+
+  LOG(info) << "Inserting " << sensVol->GetName() << " inside " << chipVol->GetName();
+  chipVol->AddNode(sensVol, 1, nullptr);
+
+  LOG(info) << "Inserting " << chipVol->GetName() << " inside " << segmentVol->GetName();
+  segmentVol->AddNode(chipVol, 1, nullptr);
+
+  // Finally put everything in the mother volume
+  auto FwdSegmentRotation = new TGeoRotation("FwdSegmentRotation", mRotX, mRotY, mRotZ);
+  auto FwdSegmentCombiTrans = new TGeoCombiTrans(mX, mY, mZ, FwdSegmentRotation);
+
+  LOG(info) << "Inserting " << segmentVol->GetName() << " inside " << motherVolume->GetName();
+  motherVolume->AddNode(segmentVol, 1, FwdSegmentCombiTrans);
+}

Detectors/Upgrades/ALICE3/FCT/simulation/src/FCTSimulationLinkDef.h

@@ -16,6 +16,7 @@
 #pragma link off all functions;
 
 #pragma link C++ class o2::fct::FCTLayer + ;
+#pragma link C++ class o2::fct::FCTSegment + ;
 #pragma link C++ class o2::fct::Detector + ;
 #pragma link C++ class o2::base::DetImpl < o2::fct::Detector> + ;