ITS3: adapt staggering

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

Author: f3sch

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

@@ -34,14 +34,14 @@ namespace o2::its
 {
 class ITSTrackingInterface
 {
+ public:
   static constexpr int NLayers{7};
   using VertexerN = Vertexer<NLayers>;
   using VertexerTraitsN = VertexerTraits<NLayers>;
   using TrackerN = Tracker<NLayers>;
   using TrackerTraitsN = TrackerTraits<NLayers>;
   using TimeFrameN = TimeFrame<NLayers>;
 
- public:
   ITSTrackingInterface(bool isMC,
                        bool doStag,
                        int trgType,
@@ -80,6 +80,7 @@ class ITSTrackingInterface
   TimeFrameN* mTimeFrame = nullptr;
 
  protected:
+  virtual void requestTopologyDictionary(framework::ProcessingContext& pc);
   virtual void loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                        gsl::span<const itsmft::CompClusterExt> clusters,
                        gsl::span<const unsigned char>::iterator& pattIt,
@@ -98,7 +99,7 @@ class ITSTrackingInterface
   const o2::itsmft::TopologyDictionary* mDict = nullptr;
   std::unique_ptr<TrackerN> mTracker = nullptr;
   std::unique_ptr<VertexerN> mVertexer = nullptr;
-  const o2::dataformats::MeanVertexObject* mMeanVertex;
+  const o2::dataformats::MeanVertexObject* mMeanVertex{};
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<tbb::task_arena> mTaskArena;
 };

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

@@ -362,7 +362,7 @@ void ITSTrackingInterface::updateTimeDependentParams(framework::ProcessingContex
   }
   if (!initOnceDone) { // this params need to be queried only once
     initOnceDone = true;
-    pc.inputs().get<o2::itsmft::TopologyDictionary*>("itscldict"); // just to trigger the finaliseCCDB
+    requestTopologyDictionary(pc);
     pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>*>("itsalppar");
     if (pc.inputs().getPos("itsTGeo") >= 0) {
       pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
@@ -474,6 +474,11 @@ void ITSTrackingInterface::setTraitsFromProvider(VertexerTraitsN* vertexerTraits
   mVertexer->setMemoryPool(mMemoryPool);
 }
 
+void ITSTrackingInterface::requestTopologyDictionary(framework::ProcessingContext& pc)
+{
+  pc.inputs().get<o2::itsmft::TopologyDictionary*>("itscldict"); // just to trigger the finaliseCCDB
+}
+
 void ITSTrackingInterface::loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                                    gsl::span<const itsmft::CompClusterExt> clusters,
                                    gsl::span<const unsigned char>::iterator& pattIt,

Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h

@@ -83,6 +83,7 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
                         gsl::span<const itsmft::CompClusterExt> clusters,
                         gsl::span<const unsigned char>::iterator& pattIt,
                         const o2::its3::TopologyDictionary* dict,
+                        int layer,
                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
 } // namespace its3::ioutils
 } // namespace o2

Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TrackingInterface.h

@@ -24,10 +24,10 @@ class ITS3TrackingInterface final : public its::ITSTrackingInterface
   using its::ITSTrackingInterface::ITSTrackingInterface;
 
   void setClusterDictionary(const o2::its3::TopologyDictionary* d) { mDict = d; }
-  void updateTimeDependentParams(framework::ProcessingContext& pc) final;
   void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj) final;
 
  protected:
+  void requestTopologyDictionary(framework::ProcessingContext& pc) final;
   void loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                gsl::span<const itsmft::CompClusterExt> clusters,
                gsl::span<const unsigned char>::iterator& pattIt,

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

@@ -61,13 +61,21 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
                         gsl::span<const itsmft::CompClusterExt> clusters,
                         gsl::span<const unsigned char>::iterator& pattIt,
                         const its3::TopologyDictionary* dict,
+                        int layer,
                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
   auto geom = its::GeometryTGeo::Instance();
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
 
-  // tf->resetROFrameData(rofs.size()); // FIXME
-  // tf->prepareROFrameData(rofs, clusters); FIXME
+  tf->resetROFrameData(layer);
+  tf->prepareROFrameData(clusters, layer);
+
+  // check for missing/empty/unset rofs
+  // the code requires consistent monotonically increasing input without gaps
+  const auto& timing = tf->getROFOverlapTableView().getLayer(layer);
+  if (timing.mNROFsTF != rofs.size()) {
+    LOGP(fatal, "Received inconsistent number of rofs on layer:{} expected:{} received:{}", layer, timing.mNROFsTF, rofs.size());
+  }
 
   its::bounded_vector<uint8_t> clusterSizeVec(clusters.size(), tf->getMemoryPool().get());
 
@@ -110,22 +118,22 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
       tf->addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), tf->getUnsortedClusters()[layer].size());
       tf->addClusterExternalIndexToLayer(layer, clusterId);
     }
-    for (unsigned int iL{0}; iL < tf->getUnsortedClusters().size(); ++iL) {
-      tf->mROFramesClusters[iL][iRof + 1] = (int)tf->getUnsortedClusters()[iL].size();
-    }
+    tf->mROFramesClusters[layer][iRof + 1] = (int)tf->getUnsortedClusters()[layer].size();
   }
 
-  // tf->setClusterSize(clusterSizeVec); FIXME
+  tf->setClusterSize(layer, clusterSizeVec);
 
-  for (auto& v : tf->mNTrackletsPerCluster) {
-    v.resize(tf->getUnsortedClusters()[1].size());
-  }
-  for (auto& v : tf->mNTrackletsPerClusterSum) {
-    v.resize(tf->getUnsortedClusters()[1].size() + 1);
+  if (layer == 1) {
+    for (auto& v : tf->mNTrackletsPerCluster) {
+      v.resize(tf->getUnsortedClusters()[1].size());
+    }
+    for (auto& v : tf->mNTrackletsPerClusterSum) {
+      v.resize(tf->getUnsortedClusters()[1].size() + 1);
+    }
   }
 
   if (mcLabels != nullptr) {
-    // tf->mClusterLabels = mcLabels; // FIXME
+    tf->mClusterLabels[layer] = mcLabels;
   }
   return 0;
 }

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

@@ -12,6 +12,7 @@
 #include "ITS3Reconstruction/TrackingInterface.h"
 #include "ITS3Reconstruction/IOUtils.h"
 #include "ITSBase/GeometryTGeo.h"
+#include "ITStracking/FastMultEstConfig.h"
 #include "ITStracking/TrackingConfigParam.h"
 #include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsBase/GRPGeomHelper.h"
@@ -20,30 +21,9 @@
 namespace o2::its3
 {
 
-void ITS3TrackingInterface::updateTimeDependentParams(framework::ProcessingContext& pc)
+void ITS3TrackingInterface::requestTopologyDictionary(framework::ProcessingContext& pc)
 {
-  o2::base::GRPGeomHelper::instance().checkUpdates(pc);
-  static bool initOnceDone = false;
-  if (!initOnceDone) { // this params need to be queried only once
-    initOnceDone = true;
-    pc.inputs().get<o2::its3::TopologyDictionary*>("cldict"); // just to trigger the finaliseCCDB
-    pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>*>("alppar");
-    if (pc.inputs().getPos("itsTGeo") >= 0) {
-      pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
-    }
-    auto geom = its::GeometryTGeo::Instance();
-    geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G));
-    initialise();
-    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // print settings only for the 1st pipeling
-      o2::its::VertexerParamConfig::Instance().printKeyValues();
-      o2::its::TrackerParamConfig::Instance().printKeyValues();
-      const auto& trParams = getTracker()->getParameters();
-      for (size_t it = 0; it < trParams.size(); it++) {
-        const auto& par = trParams[it];
-        LOGP(info, "recoIter#{} : {}", it, par.asString());
-      }
-    }
-  }
+  pc.inputs().get<o2::its3::TopologyDictionary*>("itscldict"); // just to trigger the finaliseCCDB
 }
 
 void ITS3TrackingInterface::finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj)
@@ -80,7 +60,7 @@ void ITS3TrackingInterface::loadROF(gsl::span<const itsmft::ROFRecord>& trackROF
                                     int layer,
                                     const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
-  // ioutils::loadROFrameDataITS3(mTimeFrame, trackROFspan, clusters, pattIt, mDict, mcLabels);
+  ioutils::loadROFrameDataITS3(mTimeFrame, trackROFspan, clusters, pattIt, mDict, layer, mcLabels);
 }
 
 } // namespace o2::its3

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

@@ -54,8 +54,8 @@ class Digitizer : public TObject
   void init();
 
   /// Steer conversion of hits to digits
-  void process(const std::vector<itsmft::Hit>* hits, int evID, int srcID);
-  void setEventTime(const o2::InteractionTimeRecord& irt);
+  void process(const std::vector<itsmft::Hit>* hits, int evID, int srcID, int layer);
+  void setEventTime(const o2::InteractionTimeRecord& irt, int layer);
   double getEndTimeOfROFMax() const
   {
     ///< return the time corresponding to end of the last reserved ROFrame : mROFrameMax
@@ -64,7 +64,7 @@ class Digitizer : public TObject
 
   void setContinuous(bool v) { mParams.setContinuous(v); }
   bool isContinuous() const { return mParams.isContinuous(); }
-  void fillOutputContainer(uint32_t maxFrame = 0xffffffff);
+  void fillOutputContainer(uint32_t maxFrame = 0xffffffff, int layer = -1);
 
   // provide the common itsmft::GeometryTGeo to access matrices and segmentation
   void setGeometry(const o2::its::GeometryTGeo* gm) { mGeometry = gm; }
@@ -76,13 +76,19 @@ class Digitizer : public TObject
     mEventROFrameMin = 0xffffffff;
     mEventROFrameMax = 0;
   }
+  void resetROFrameBounds()
+  {
+    mROFrameMin = 0;
+    mROFrameMax = 0;
+    mNewROFrame = 0;
+  }
 
   void setDeadChannelsMap(const o2::itsmft::NoiseMap* mp) { mDeadChanMap = mp; }
 
  private:
-  void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID);
+  void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID, int layer);
   void registerDigits(o2::its3::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
-                      uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
+                      uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl, int layer);
 
   ExtraDig* getExtraDigBuffer(uint32_t roFrame)
   {
@@ -105,6 +111,7 @@ class Digitizer : public TObject
   uint32_t mROFrameMin = 0; ///< lowest RO frame of current digits
   uint32_t mROFrameMax = 0; ///< highest RO frame of current digits
   uint32_t mNewROFrame = 0; ///< ROFrame corresponding to provided time
+  bool mIsBeforeFirstRO = false;
 
   uint32_t mEventROFrameMin = 0xffffffff; ///< lowest RO frame for processed events (w/o automatic noise ROFs)
   uint32_t mEventROFrameMax = 0;          ///< highest RO frame forfor processed events (w/o automatic noise ROFs)