Adapt ITS3 tracker to work with 4th layer

Author: fgrosa

Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h

@@ -48,8 +48,8 @@ class IndexTableUtils
   int mNzBins = 0;
   int mNphiBins = 0;
   float mInversePhiBinSize = 0.f;
-  float mLayerZ[7] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
-  float mInverseZBinSize[7] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+  std::vector<float> mLayerZ = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+  std::vector<float> mInverseZBinSize = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
 };
 
 template <class T>
@@ -58,6 +58,10 @@ inline void IndexTableUtils::setTrackingParameters(const T& params)
   mInversePhiBinSize = params.PhiBins / constants::math::TwoPi;
   mNzBins = params.ZBins;
   mNphiBins = params.PhiBins;
+  if (params.LayerZ.size() > 7) {
+    mLayerZ.resize(params.LayerZ.size());
+    mInverseZBinSize.resize(params.LayerZ.size());
+  }
   for (int iLayer{0}; iLayer < params.LayerZ.size(); ++iLayer) {
     mLayerZ[iLayer] = params.LayerZ[iLayer];
   }

Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h

@@ -202,6 +202,8 @@ class TimeFrame
   void addTrackingFrameInfoToLayer(int layer, T&&... args);
   void addClusterExternalIndexToLayer(int layer, const int idx);
 
+  void resizeVectors(int nLayers);
+
   /// Debug and printing
   void checkTrackletLUTs();
   void printROFoffsets();

Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h

@@ -136,7 +136,7 @@ inline const int4 TrackerTraits::getBinsRect(const Cluster& currentCluster, int
 
 inline void TrackerTraits::initialiseTimeFrame(const int iteration)
 {
-  mTimeFrame->initialise(iteration, mTrkParams[iteration], 7);
+  mTimeFrame->initialise(iteration, mTrkParams[iteration], mTrkParams[iteration].NLayers);
   setIsGPU(false);
 }
 

Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx

@@ -455,6 +455,20 @@ void TimeFrame::checkTrackletLUTs()
   }
 }
 
+void TimeFrame::resizeVectors(int nLayers)
+{
+  mMinR.resize(nLayers, 10000.);
+  mMaxR.resize(nLayers, -1.);
+  mClusters.resize(nLayers);
+  mUnsortedClusters.resize(nLayers);
+  mTrackingFrameInfo.resize(nLayers);
+  mClusterExternalIndices.resize(nLayers);
+  mUsedClusters.resize(nLayers);
+  mROframesClusters.resize(nLayers, {0});
+  mNClustersPerROF.resize(nLayers);
+  mTrackletsIndexROf.resize(2, {0});
+}
+
 void TimeFrame::printTrackletLUTonLayer(int i)
 {
   std::cout << "--------" << std::endl

Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C

@@ -181,10 +181,10 @@ void CheckClustersITS3(std::string clusfile = "o2clus_it3.root", std::string hit
       auto chipID = cluster.getSensorID();
       if (pattID == o2::its3::CompCluster::InvalidPatternID || dict.isGroup(pattID)) {
         o2::itsmft::ClusterPattern patt(pattIt);
-        locC = dict.getClusterCoordinates(cluster, patt, false, gman->getNumberOfLayers());
+        locC = dict.getClusterCoordinates(cluster, patt, false, segs.size());
         LOGP(info, "I am invalid and I am on chip {}", chipID);
       } else {
-        locC = dict.getClusterCoordinates(cluster, gman->getNumberOfLayers());
+        locC = dict.getClusterCoordinates(cluster, segs.size());
         errX = dict.getErrX(pattID);
         errZ = dict.getErrZ(pattID);
         if (chipID >= segs.size()) {

Detectors/Upgrades/ITS3/macros/test/CheckTracksITS3.C

@@ -73,6 +73,7 @@ void CheckTracksITS3(std::string tracfile = "o2trac_its3.root",
                      std::string clusfile = "o2clus_it3.root",
                      std::string kinefile = "o2sim_Kine.root",
                      std::string magfile = "o2sim_grp.root",
+                     std::string inputGeom = "o2sim_geometry.root",
                      bool batch = true)
 {
 
@@ -94,7 +95,7 @@ void CheckTracksITS3(std::string tracfile = "o2trac_its3.root",
   double orig[3] = {0., 0., 0.};
   float bz = field->getBz(orig);
   // Geometry
-  o2::base::GeometryManager::loadGeometry();
+  o2::base::GeometryManager::loadGeometry(inputGeom);
   auto gman = o2::its::GeometryTGeo::Instance();
 
   // MC tracks

Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx

@@ -38,38 +38,40 @@ int loadROFrameDataITS3(its::TimeFrame* tf,
 
   std::vector<o2::its3::SegmentationSuperAlpide> segITS3;
   for (int iLayer{0}; iLayer < geom->getNumberOfLayers() - 4; ++iLayer) {
-    segITS3.push_back(SegmentationSuperAlpide(iLayer));
+    for (int iChip{0}; iChip < geom->getNumberOfChipsPerLayer(iLayer); ++iChip) {
+      segITS3.push_back(SegmentationSuperAlpide(iLayer));
+    }
   }
+  int nChipsITS3 = segITS3.size();
 
   tf->mNrof = 0;
   for (auto& rof : rofs) {
     for (int clusterId{rof.getFirstEntry()}; clusterId < rof.getFirstEntry() + rof.getNEntries(); ++clusterId) {
       auto& c = clusters[clusterId];
-
       auto sensorID = c.getSensorID();
       int layer = layer = geom->getLayer(sensorID);
 
       auto pattID = c.getPatternID();
       o2::math_utils::Point3D<float> locXYZ;
       float sigmaY2 = o2::its::ioutils::DefClusError2Row, sigmaZ2 = o2::its::ioutils::DefClusError2Col, sigmaYZ = 0; // Dummy COG errors (about half pixel size)
-      float pitchRow = ((layer < geom->getNumberOfLayers() - 4) ? segITS3[layer].mPitchRow : o2::itsmft::SegmentationAlpide::PitchRow);
-      float pitchCol = ((layer < geom->getNumberOfLayers() - 4) ? segITS3[layer].mPitchCol : o2::itsmft::SegmentationAlpide::PitchCol);
+      float pitchRow = ((sensorID < nChipsITS3) ? segITS3[sensorID].mPitchRow : o2::itsmft::SegmentationAlpide::PitchRow);
+      float pitchCol = ((sensorID < nChipsITS3) ? segITS3[sensorID].mPitchCol : o2::itsmft::SegmentationAlpide::PitchCol);
       if (pattID != its3::CompCluster::InvalidPatternID) {
         sigmaY2 = dict->getErr2X(pattID) * pitchRow * pitchRow;
         sigmaZ2 = dict->getErr2Z(pattID) * pitchCol * pitchCol;
         if (!dict->isGroup(pattID)) {
-          locXYZ = dict->getClusterCoordinates(c, segITS3.size());
+          locXYZ = dict->getClusterCoordinates(c, nChipsITS3);
         } else {
           o2::itsmft::ClusterPattern patt(pattIt);
-          locXYZ = dict->getClusterCoordinates(c, patt, segITS3.size());
+          locXYZ = dict->getClusterCoordinates(c, patt, nChipsITS3);
           sigmaY2 = patt.getRowSpan() * patt.getRowSpan() * pitchRow * pitchRow / 12.;
           sigmaZ2 = patt.getColumnSpan() * patt.getColumnSpan() * pitchCol * pitchCol / 12.;
         }
       } else {
         o2::itsmft::ClusterPattern patt(pattIt);
         sigmaY2 = patt.getRowSpan() * patt.getRowSpan() * pitchRow * pitchRow / 12.;
         sigmaZ2 = patt.getColumnSpan() * patt.getColumnSpan() * pitchCol * pitchCol / 12.;
-        locXYZ = dict->getClusterCoordinates(c, patt, false, segITS3.size());
+        locXYZ = dict->getClusterCoordinates(c, patt, false, nChipsITS3);
       }
 
       // Transformation to the local --> global

Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackerSpec.h

@@ -56,6 +56,7 @@ class TrackerDPL : public framework::Task
   bool mRunVertexer = true;
   bool mCosmicsProcessing = false;
   int mUseTriggers = 0;
+  int mNLayers = 7;
   std::string mMode = "sync";
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   const o2::its3::TopologyDictionary* mDict = nullptr;

Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx

@@ -30,6 +30,7 @@
 #include "DataFormatsTRD/TriggerRecord.h"
 #include <ITS3Reconstruction/IOUtils.h>
 #include "ITSReconstruction/FastMultEstConfig.h"
+#include "ITS3Base/DescriptorInnerBarrelITS3Param.h"
 // #include "ITS3Reconstruction/FastMultEst.h"
 
 namespace o2
@@ -57,6 +58,11 @@ void TrackerDPL::init(InitContext& ic)
   mTimer.Stop();
   mTimer.Reset();
   o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
+  auto& paramGeom = DescriptorInnerBarrelITS3Param::Instance();
+  if (paramGeom.getITS3LayerConfigString() == "FourLayers") {
+    mNLayers = 8;
+  }
+
   mChainITS.reset(mRecChain->AddChain<o2::gpu::GPUChainITS>());
   mVertexer = std::make_unique<Vertexer>(mChainITS->GetITSVertexerTraits());
   mTracker = std::make_unique<Tracker>(mChainITS->GetITSTrackerTraits());
@@ -120,7 +126,21 @@ void TrackerDPL::init(InitContext& ic)
 
   for (auto& params : trackParams) {
     params.CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT;
+    params.NLayers = mNLayers;
+    if (params.NLayers > 7) { // shift by one position OB radii and lengths
+      params.LayerZ.resize(params.NLayers);
+      params.LayerRadii.resize(params.NLayers);
+      for (int iLayer{params.NLayers - 1}; iLayer >= params.NLayers - 4; iLayer--) {
+        params.LayerZ[iLayer] = params.LayerZ[iLayer - 1];
+        params.LayerRadii[iLayer] = params.LayerRadii[iLayer - 1];
+      }
+    }
+    for (int iLayer{0}; iLayer < params.NLayers - 4; ++iLayer) { // initialise ITS3 radii and lengths
+      params.LayerZ[iLayer] = paramGeom.mLength;
+      params.LayerRadii[iLayer] = paramGeom.mRadii[iLayer];
+    }
   }
+
   mTracker->setParameters(trackParams);
 }
 
@@ -181,6 +201,7 @@ void TrackerDPL::run(ProcessingContext& pc)
   auto& vertices = pc.outputs().make<std::vector<Vertex>>(Output{"IT3", "VERTICES", 0, Lifetime::Timeframe});
 
   TimeFrame* timeFrame = mChainITS->GetITSTimeframe();
+  timeFrame->resizeVectors(mNLayers);
   mTracker->adoptTimeFrame(*timeFrame);
 
   mTracker->setBz(o2::base::Propagator::Instance()->getNominalBz());