ITS3: double precision for geometry + z-shift

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

Author: f3sch

Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationSuperAlpide.h

@@ -70,7 +70,7 @@ class SegmentationSuperAlpide
   static constexpr float mSensorLayerThickness{constants::thickness};
   static constexpr float mSensorLayerThicknessEff{constants::effThickness};
   static constexpr float mSensorLayerThicknessCorr{constants::corrThickness};
-  static constexpr std::array<float, constants::nLayers> mRadii{constants::radii};
+  static constexpr std::array<float, constants::nLayers> mRadii{constants::radiiF};
 
   /// Transformation from the curved surface to a flat surface
   /// \param xCurved Detector local curved coordinate x in cm with respect to

Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h

@@ -23,109 +23,110 @@
 
 namespace o2::its3::constants
 {
-constexpr float cm{1e+2}; // This is the default unit of TGeo so we use this as scale
-constexpr float mu{1e-6 * cm};
-constexpr float mm{1e-3 * cm};
+constexpr double cm{1e+2}; // This is the default unit of TGeo so we use this as scale
+constexpr double mu{1e-6 * cm};
+constexpr double mm{1e-3 * cm};
 namespace pixelarray
 {
-constexpr float width{9.197 * mm};
-constexpr float length{3.571 * mm};
+constexpr double width{9.197 * mm};
+constexpr double length{3.571 * mm};
 constexpr int nCols{156};
 constexpr int nRows{442};
 constexpr int nPixels{nRows * nCols};
 constexpr EColor color{kGreen};
-constexpr float area{width * length};
+constexpr double area{width * length};
 } // namespace pixelarray
 namespace tile
 {
 namespace biasing
 {
-constexpr float width{0.06 * mm};
-constexpr float length{3.571 * mm};
+constexpr double width{0.06 * mm};
+constexpr double length{3.571 * mm};
 constexpr EColor color{kYellow};
 static_assert(length == pixelarray::length);
 } // namespace biasing
 namespace powerswitches
 {
-constexpr float width{9.257 * mm};
-constexpr float length{0.02 * mm};
-constexpr float z{pixelarray::width};
+constexpr double width{9.257 * mm};
+constexpr double length{0.02 * mm};
+constexpr double z{pixelarray::width};
 constexpr EColor color{kBlue};
 } // namespace powerswitches
 namespace readout
 {
-constexpr float width{0.525 * mm};
-constexpr float length{3.591 * mm};
+constexpr double width{0.525 * mm};
+constexpr double length{3.591 * mm};
 constexpr EColor color{kMagenta};
 static_assert(length == (biasing::length + powerswitches::length));
 } // namespace readout
-constexpr float length{readout::length};
-constexpr float width{powerswitches::width + readout::width};
+constexpr double length{readout::length};
+constexpr double width{powerswitches::width + readout::width};
 } // namespace tile
 namespace rsu
 {
 namespace databackbone
 {
-constexpr float width{9.782 * mm};
-constexpr float length{0.06 * mm};
+constexpr double width{9.782 * mm};
+constexpr double length{0.06 * mm};
 constexpr EColor color{kRed};
 } // namespace databackbone
-constexpr float width{19.564 * mm};
-constexpr float length{21.666 * mm};
+constexpr double width{19.564 * mm};
+constexpr double length{21.666 * mm};
 constexpr unsigned int nTiles{12};
 } // namespace rsu
 namespace segment
 {
-constexpr float width{rsu::width};
+constexpr double width{rsu::width};
 namespace lec
 {
-constexpr float width{segment::width};
-constexpr float length{4.5 * mm};
+constexpr double width{segment::width};
+constexpr double length{4.5 * mm};
 constexpr EColor color{kCyan};
 } // namespace lec
 namespace rec
 {
-constexpr float width{segment::width};
-constexpr float length{1.5 * mm};
+constexpr double width{segment::width};
+constexpr double length{1.5 * mm};
 constexpr EColor color{kCyan};
 } // namespace rec
 constexpr unsigned int nRSUs{12};
 constexpr unsigned int nTilesPerSegment{nRSUs * rsu::nTiles};
-constexpr float length{nRSUs * rsu::length + lec::length + rec::length};
-constexpr float lengthSensitive{nRSUs * rsu::length};
+constexpr double length{nRSUs * rsu::length + lec::length + rec::length};
+constexpr double lengthSensitive{nRSUs * rsu::length};
 } // namespace segment
 namespace carbonfoam
 {
 // TODO: Waiting for the further information from WP5(Corrado)
-constexpr float longeronsWidth{2.0 * mm};                                 // what is the height of the longerons?
-constexpr float longeronsLength{263 * mm};                                // from blueprint
-constexpr float HringLength{6.0 * mm};                                    // from blueprint
-constexpr float edgeBetwChipAndFoam{1.0 * mm};                            // from blueprint but not used cause forms are already overlapping
-constexpr float gapBetwHringsLongerons{0.05 * mm};                        // from blueprint
-constexpr std::array<int, 3> nHoles{11, 11, 11};                          // how many holes for each layer?
-constexpr std::array<float, 3> radiusHoles{1.0 * mm, 1.0 * mm, 2.0 * mm}; // what is the radius of the holes for each layer?
+constexpr double longeronsWidth{2.0 * mm};                                 // what is the height of the longerons?
+constexpr double longeronsLength{263 * mm};                                // from blueprint
+constexpr double HringLength{6.0 * mm};                                    // from blueprint
+constexpr double edgeBetwChipAndFoam{1.0 * mm};                            // from blueprint but not used cause forms are already overlapping
+constexpr double gapBetwHringsLongerons{0.05 * mm};                        // from blueprint
+constexpr std::array<int, 3> nHoles{11, 11, 11};                           // how many holes for each layer?
+constexpr std::array<double, 3> radiusHoles{1.0 * mm, 1.0 * mm, 2.0 * mm}; // what is the radius of the holes for each layer?
 constexpr EColor color{kGray};
 } // namespace carbonfoam
 namespace metalstack
 {
-constexpr float thickness{5 * mu}; // physical thickness of the copper metal stack
-constexpr float length{segment::length};
-constexpr float width{segment::width};
+constexpr double thickness{5 * mu}; // physical thickness of the copper metal stack
+constexpr double length{segment::length};
+constexpr double width{segment::width};
 constexpr EColor color{kBlack};
 } // namespace metalstack
 constexpr unsigned int nLayers{3};
 constexpr unsigned int nTotLayers{7};
 constexpr unsigned int nSensorsIB{2 * nLayers};
-constexpr float equatorialGap{1 * mm};
+constexpr double equatorialGap{1 * mm};
 constexpr std::array<unsigned int, nLayers> nSegments{3, 4, 5};
-constexpr float epitaxialThickness{10 * mu};                                                                                         // eptixial layer (charge collection)
-constexpr float psubThickness{40 * mu};                                                                                              // silicon substrate
-constexpr float thickness{epitaxialThickness + psubThickness};                                                                       // physical thickness of chip
-constexpr float effThickness{epitaxialThickness / 2.0 + psubThickness};                                                              // effective physical thickness
-constexpr float corrThickness{effThickness - thickness / 2.0};                                                                       // correction to get into the epitxial layer
-constexpr std::array<float, nLayers> radii{19.0006 * mm, 25.228 * mm, 31.4554 * mm};                                                 // middle radius e.g. inner radius+thickness/2.
-constexpr std::array<float, nLayers> radiiInner{radii[0] - thickness / 2.0, radii[1] - thickness / 2.0, radii[2] - thickness / 2.0}; // inner radius
-constexpr std::array<float, nLayers> radiiOuter{radii[0] + thickness / 2.0, radii[1] + thickness / 2.0, radii[2] + thickness / 2.0}; // inner radius
+constexpr double epitaxialThickness{10 * mu};                                                                                         // eptixial layer (charge collection)
+constexpr double psubThickness{40 * mu};                                                                                              // silicon substrate
+constexpr double thickness{epitaxialThickness + psubThickness};                                                                       // physical thickness of chip
+constexpr double effThickness{epitaxialThickness / 2.0 + psubThickness};                                                              // effective physical thickness
+constexpr double corrThickness{effThickness - thickness / 2.0};                                                                       // correction to get into the epitxial layer
+constexpr std::array<double, nLayers> radii{19.0006 * mm, 25.228 * mm, 31.4554 * mm};                                                 // middle radius e.g. inner radius+thickness/2.
+constexpr std::array<float, nLayers> radiiF{19.0006 * mm, 25.228 * mm, 31.4554 * mm};                                                 // middle radius e.g. inner radius+thickness/2.
+constexpr std::array<double, nLayers> radiiInner{radii[0] - thickness / 2.0, radii[1] - thickness / 2.0, radii[2] - thickness / 2.0}; // inner radius
+constexpr std::array<double, nLayers> radiiOuter{radii[0] + thickness / 2.0, radii[1] + thickness / 2.0, radii[2] + thickness / 2.0}; // inner radius
 namespace detID
 {
 constexpr unsigned int mDetIDs{2 * 12 * 12 * 12};                //< 2 Hemispheres * (3,4,5=12 segments in a layer) * 12 RSUs in a segment * 12 Tiles in a RSU

Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3Layer.h

@@ -96,7 +96,7 @@ class ITS3Layer
 
   uint8_t mNLayer{0}; // Layer number
   double mR{0};       // Middle Radius
-  double mRmin{};     // Minimum Radius
+  double mRmin{0};    // Minimum Radius
   double mRmax{0};    // Maximum Radius
 
   // Individual pieces

Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx

@@ -73,7 +73,7 @@ void ITS3Layer::createLayer(TGeoVolume* motherVolume)
     return;
   }
   // Add it to motherVolume
-  auto* trans = new TGeoTranslation(0, 0, -constants::segment::lengthSensitive / 2.);
+  auto* trans = new TGeoTranslation(0, 0, -constants::segment::lengthSensitive / 2. - constants::rsu::databackbone::length / 2. + constants::tile::powerswitches::length / 2.);
   motherVolume->AddNode(mLayer, 0, trans);
 }
 
@@ -293,7 +293,7 @@ void ITS3Layer::createCarbonForm()
   mCarbonForm->VisibleDaughters();
   double dRadius = -1;
   if (mNLayer < 2) {
-    dRadius = constants::radii[mNLayer + 1] - constants::radii[mNLayer] - constants::thickness;
+    dRadius = constants::radii[mNLayer + 1] - constants::radii[mNLayer] - constants::thickness - constants::metalstack::thickness;
   } else {
     dRadius = 0.7; // TODO: lack of carbon foam radius for layer 2, use 0.7mm as a temporary value
   }
@@ -409,8 +409,7 @@ void ITS3Layer::buildPartial(TGeoVolume* motherVolume, TGeoMatrix* mat, BuildLev
     case BuildLevel::kLayer:
       [[fallthrough]];
     default:
-      createLayerImpl();
-      motherVolume->AddNode(mLayer, 0, mat);
+      createLayer(motherVolume);
   }
   LOGP(info, "Partially built ITS3-{}-{}", mNLayer, getName(level));
 }