ITS: staggered STF decoder

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

Author: f3sch

Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingITS.h

@@ -310,6 +310,9 @@ class ChipMappingITS
 
   std::vector<Overlaps> getOverlapsInfo() const;
 
+  ///< Collect all FEEIDs for one layer (lr>=0) or all (lr==-1)
+  std::vector<uint16_t> getLayer2FEEIDs(int lr);
+
   // sub-barrel types, their number, N layers, Max N GBT Links per RU
   static constexpr int IB = 0, MB = 1, OB = 2, NSubB = 3, NLayers = 7, NLinks = 3;
 
@@ -395,7 +398,7 @@ class ChipMappingITS
   std::vector<uint8_t> mCablePos[NSubB];         ///< table of cables positions in the ActiveLanes mask for each RU type (sequential numbering)
   std::vector<uint8_t> mCableHWFirstChip[NSubB]; ///< 1st chip of module (relative to the 1st chip of the stave) served by each cable
 
-  std::array<int, NSubB> mCablesOnStaveSB = {0}; ///< pattern of cables per stave of sub-barrel
+  std::array<int, NSubB> mCablesOnStaveSB = {0};                                       ///< pattern of cables per stave of sub-barrel
   std::array<std::array<uint8_t, 15>, MaxHWCableID[MB] + 1> HWCableHWChip2ChipOnRU_MB; // mapping from HW cable ID / HW chip ID to Chip on RU, 255 means NA
   std::array<std::array<uint8_t, 15>, MaxHWCableID[OB] + 1> HWCableHWChip2ChipOnRU_OB; // mapping from HW cable ID / HW chip ID to Chip on RU, 255 means NA
 

Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingMFT.h

@@ -266,6 +266,9 @@ class ChipMappingMFT
 
   const auto& getModuleMappingData() const { return ModuleMappingData; }
 
+  ///< Collect all FEEIDs for one layer (lr>=0) or all (lr==-1)
+  std::vector<uint16_t> getLayer2FEEIDs(int lr);
+
   void print() const;
 
   ///< LayerID of each MFT chip

Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/PixelReader.h

@@ -50,11 +50,6 @@ class PixelReader
   {
     return nullptr;
   }
-  const o2::InteractionRecord& getInteractionRecordHB() const
-  {
-    return mInteractionRecordHB;
-  }
-
   const o2::InteractionRecord& getInteractionRecord() const
   {
     return mInteractionRecord;
@@ -70,8 +65,7 @@ class PixelReader
   //
  protected:
   //
-  o2::InteractionRecord mInteractionRecord = {};   // interation record for the trigger
-  o2::InteractionRecord mInteractionRecordHB = {}; // interation record for the HB
+  o2::InteractionRecord mInteractionRecord = {}; // interation record for the trigger
   uint32_t mTrigger = 0;
   bool mDecodeNextAuto = true; // try to fetch/decode next trigger when getNextChipData does not see any decoded data
 

Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelDecoder.h

@@ -17,6 +17,7 @@
 #include <array>
 #include <TStopwatch.h>
 #include "Framework/Logger.h"
+#include "Framework/InputSpec.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
 #include "ITSMFTReconstruction/ChipMappingMFT.h"
 #include "DetectorsRaw/HBFUtils.h"
@@ -56,7 +57,7 @@ class RawPixelDecoder final : public PixelReader
   bool getNextChipData(ChipPixelData& chipData) final;
   ChipPixelData* getNextChipData(std::vector<ChipPixelData>& chipDataVec) final;
   void ensureChipOrdering() {}
-  void startNewTF(o2::framework::InputRecord& inputs);
+  void startNewTF(o2::framework::InputRecord& inputs, const std::vector<o2::framework::InputSpec>& filter);
   void collectROFCableData(int iru);
   int decodeNextTrigger() final;
 
@@ -138,7 +139,7 @@ class RawPixelDecoder final : public PixelReader
   void reset();
 
  private:
-  void setupLinks(o2::framework::InputRecord& inputs);
+  void setupLinks(o2::framework::InputRecord& inputsm, const std::vector<o2::framework::InputSpec>& filter);
   int getRUEntrySW(int ruSW) const { return mRUEntry[ruSW]; }
   RUDecodeData* getRUDecode(int ruSW) { return &mRUDecodeVec[mRUEntry[ruSW]]; }
   GBTLink* getGBTLink(int i) { return i < 0 ? nullptr : &mGBTLinks[i]; }

Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelReader.h

@@ -53,8 +53,8 @@ namespace o2
 namespace itsmft
 {
 
-constexpr int MaxGBTPacketBytes = 8 * 1024;                                   // Max size of GBT packet in bytes (8KB)
-constexpr int NCRUPagesPerSuperpage = 256;                                    // Expected max number of CRU pages per superpage
+constexpr int MaxGBTPacketBytes = 8 * 1024; // Max size of GBT packet in bytes (8KB)
+constexpr int NCRUPagesPerSuperpage = 256;  // Expected max number of CRU pages per superpage
 using RDHUtils = o2::raw::RDHUtils;
 
 struct RawDecodingStat {
@@ -633,7 +633,6 @@ class RawPixelReader : public PixelReader
             const auto rdh = reinterpret_cast<const o2::header::RAWDataHeader*>(link->data.getPtr());
             mInteractionRecord = RDHUtils::getTriggerIR(rdh);
             mTrigger = RDHUtils::getTriggerType(rdh);
-            mInteractionRecordHB = RDHUtils::getHeartBeatIR(rdh);
             break;
           }
         }
@@ -674,7 +673,7 @@ class RawPixelReader : public PixelReader
       }
     }
     if (ruDecData.ruInfo->nCables) { // there are cables with data to decode
-      decodeAlpideData(ruDecData); // decode Alpide data from the compressed RU Data
+      decodeAlpideData(ruDecData);   // decode Alpide data from the compressed RU Data
     }
     return res;
   }

Detectors/ITSMFT/common/reconstruction/src/ChipMappingITS.cxx

@@ -78,14 +78,14 @@ ChipMappingITS::ChipMappingITS()
     cInfo.moduleSW = 0;
     cInfo.chipOnModuleSW = i;
     cInfo.chipOnModuleHW = i;
-    cInfo.cableHW = i;                              //1-to-1 mapping
-    cInfo.cableHWPos = i;                           //1-to-1 mapping
-    cInfo.cableSW = i;                              //1-to-1 mapping
-    cInfo.chipOnCable = 0;                          // every chip is master
+    cInfo.cableHW = i;     // 1-to-1 mapping
+    cInfo.cableHWPos = i;  // 1-to-1 mapping
+    cInfo.cableSW = i;     // 1-to-1 mapping
+    cInfo.chipOnCable = 0; // every chip is master
     mCableHW2SW[IB][cInfo.cableHW] = cInfo.cableSW;
     mCableHW2Pos[IB][cInfo.cableHW] = cInfo.cableHWPos;
     mCablesOnStaveSB[IB] |= 0x1 << cInfo.cableHWPos; // account in lanes pattern
-    mCableHWFirstChip[IB][i] = 0;                   // stave and module are the same
+    mCableHWFirstChip[IB][i] = 0;                    // stave and module are the same
   }
 
   // [i][j] gives lane id for  lowest(i=0) and highest(i=1) 7 chips of HW module (j+1) (1-4 for ML, 1-7 for OL)
@@ -289,3 +289,17 @@ std::vector<ChipMappingITS::Overlaps> ChipMappingITS::getOverlapsInfo() const
   }
   return v;
 }
+
+//_____________________________________________________________________________
+std::vector<uint16_t> ChipMappingITS::getLayer2FEEIDs(int lr)
+{
+  std::vector<uint16_t> feeIDs;
+  for (int ilr = (lr >= 0 ? lr : 0); ilr < (lr >= 0 ? lr + 1 : NLayers); ++ilr) {
+    for (int ist = 0; ist < NStavesOnLr[ilr]; ++ist) {
+      for (int lnk = 0; lnk < NLinks; ++lnk) {
+        feeIDs.push_back(composeFEEId(ilr, ist, lnk));
+      }
+    }
+  }
+  return feeIDs;
+}

Detectors/ITSMFT/common/reconstruction/src/ChipMappingMFT.cxx

@@ -1753,3 +1753,17 @@ void ChipMappingMFT::print() const
            ChipMappingData[iChip].chipOnRU);
   }
 }
+
+//_____________________________________________________________________________
+std::vector<uint16_t> ChipMappingMFT::getLayer2FEEIDs(int lr)
+{
+  std::vector<uint16_t> feeIDs;
+  for (int ilr = (lr >= 0 ? lr : 0); ilr < (lr >= 0 ? lr + 1 : NLayers); ++ilr) {
+    for (int iz = 0; iz < NZonesPerLayer; ++iz) {
+      for (int lnk = 0; lnk < NLinks; ++lnk) {
+        feeIDs.push_back(composeFEEId(ilr, iz, lnk));
+      }
+    }
+  }
+  return feeIDs;
+}

Detectors/ITSMFT/common/reconstruction/src/GBTLink.cxx

@@ -41,7 +41,7 @@ GBTLink::GBTLink(uint16_t _cru, uint16_t _fee, uint8_t _ep, uint8_t _idInCru, ui
 /// create string describing the link
 std::string GBTLink::describe() const
 {
-  std::string ss = fmt::format("link cruID:{:#06x}/lID{} feeID:{:#06x}", cruID, int(idInCRU), feeID);
+  std::string ss = fmt::format("link cruID:{:#06x}/lID{:02} feeID:{:#06x}", cruID, int(idInCRU), feeID);
   if (lanes) {
     ss += fmt::format(" lanes {}", std::bitset<28>(lanes).to_string());
   }

Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx

@@ -136,7 +136,7 @@ int RawPixelDecoder<Mapping>::decodeNextTrigger()
 ///______________________________________________________________
 /// prepare for new TF
 template <class Mapping>
-void RawPixelDecoder<Mapping>::startNewTF(InputRecord& inputs)
+void RawPixelDecoder<Mapping>::startNewTF(InputRecord& inputs, const std::vector<InputSpec>& filter)
 {
   mTimerTFStart.Start(false);
   for (auto& link : mGBTLinks) {
@@ -149,7 +149,7 @@ void RawPixelDecoder<Mapping>::startNewTF(InputRecord& inputs)
     ru.linkHBFToDump.clear();
     ru.nLinksDone = 0;
   }
-  setupLinks(inputs);
+  setupLinks(inputs, filter);
   mNLinksDone = 0;
   mExtTriggers.clear();
   mTimerTFStart.Stop();
@@ -186,6 +186,9 @@ bool RawPixelDecoder<Mapping>::doIRMajorityPoll()
     if (link.statusInTF == GBTLink::DataSeen) {
       if (link.status == GBTLink::DataSeen || link.status == GBTLink::CachedDataExist) {
         mIRPoll[link.ir]++;
+        if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
+          LOGP(info, "doIRMajorityPoll: {} contributes to poll {}", link.describe(), link.ir.asString());
+        }
       } else if (link.status == GBTLink::StoppedOnEndOfData || link.status == GBTLink::AbortedOnError) {
         link.statusInTF = GBTLink::StoppedOnEndOfData;
         if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
@@ -195,31 +198,35 @@ bool RawPixelDecoder<Mapping>::doIRMajorityPoll()
       }
     }
   }
+  if (mNLinksDone == mNLinksInTF) {
+    if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
+      LOGP(info, "doIRMajorityPoll: All {} links registered in TF are done", mNLinksInTF);
+    }
+    return false;
+  }
   int majIR = -1;
   for (const auto& entIR : mIRPoll) {
     if (entIR.second > majIR) {
       majIR = entIR.second;
       mInteractionRecord = entIR.first;
     }
   }
-  mInteractionRecordHB = mInteractionRecord;
   if (mInteractionRecord.isDummy()) {
     if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
       LOG(info) << "doIRMajorityPoll: did not find any valid IR";
     }
     return false;
   }
-  mInteractionRecordHB.bc = 0;
   if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
-    LOG(info) << "doIRMajorityPoll: " << mInteractionRecordHB.asString() << " majority = " << majIR << " for " << mNLinksInTF << " links seen, LinksDone = " << mNLinksDone;
+    LOG(info) << "doIRMajorityPoll: " << mInteractionRecord.asString() << " majority = " << majIR << " for " << mNLinksInTF << " links seen, LinksDone = " << mNLinksDone;
   }
   return true;
 }
 
 ///______________________________________________________________
 /// Setup links checking the very RDH of every input
 template <class Mapping>
-void RawPixelDecoder<Mapping>::setupLinks(InputRecord& inputs)
+void RawPixelDecoder<Mapping>::setupLinks(InputRecord& inputs, const std::vector<InputSpec>& filter)
 {
   constexpr uint32_t ROF_RAMP_FLAG = 0x1 << 4;
   constexpr uint32_t LINK_RECOVERY_FLAG = 0x1 << 5;
@@ -228,7 +235,6 @@ void RawPixelDecoder<Mapping>::setupLinks(InputRecord& inputs)
   auto nLinks = mGBTLinks.size();
   auto origin = (mUserDataOrigin == o2::header::gDataOriginInvalid) ? mMAP.getOrigin() : mUserDataOrigin;
   auto datadesc = (mUserDataDescription == o2::header::gDataDescriptionInvalid) ? o2::header::gDataDescriptionRawData : mUserDataDescription;
-  std::vector<InputSpec> filter{InputSpec{"filter", ConcreteDataTypeMatcher{origin, datadesc}}};
 
   // if we see requested data type input with 0xDEADBEEF subspec and 0 payload this means that the "delayed message"
   // mechanism created it in absence of real data from upstream. Processor should send empty output to not block the workflow
@@ -258,21 +264,24 @@ void RawPixelDecoder<Mapping>::setupLinks(InputRecord& inputs)
 
   uint32_t currSSpec = 0xffffffff; // dummy starting subspec
   int linksAdded = 0;
+  uint16_t lr, dummy; // extraxted info from FEEId
   for (auto it = parser.begin(); it != parser.end(); ++it) {
     auto const* dh = it.o2DataHeader();
     auto& lnkref = mSubsSpec2LinkID[dh->subSpecification];
     const auto& rdh = *reinterpret_cast<const header::RDHAny*>(it.raw()); // RSTODO this is a hack in absence of generic header getter
+    const auto feeID = RDHUtils::getFEEID(rdh);
+    mMAP.expandFEEId(feeID, lr, dummy, dummy);
 
     if (lnkref.entry == -1) { // new link needs to be added
       lnkref.entry = int(mGBTLinks.size());
-      auto& lnk = mGBTLinks.emplace_back(RDHUtils::getCRUID(rdh), RDHUtils::getFEEID(rdh), RDHUtils::getEndPointID(rdh), RDHUtils::getLinkID(rdh), lnkref.entry);
+      auto& lnk = mGBTLinks.emplace_back(RDHUtils::getCRUID(rdh), feeID, RDHUtils::getEndPointID(rdh), RDHUtils::getLinkID(rdh), lnkref.entry);
       lnk.subSpec = dh->subSpecification;
       lnk.wordLength = (lnk.expectPadding = (RDHUtils::getDataFormat(rdh) == 0)) ? o2::itsmft::GBTPaddedWordLength : o2::itsmft::GBTWordLength;
-      getCreateRUDecode(mMAP.FEEId2RUSW(RDHUtils::getFEEID(rdh))); // make sure there is a RU for this link
+      getCreateRUDecode(mMAP.FEEId2RUSW(feeID)); // make sure there is a RU for this link
       lnk.verbosity = GBTLink::Verbosity(mVerbosity);
       lnk.alwaysParseTrigger = mAlwaysParseTrigger;
       if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
-        LOG(info) << mSelfName << " registered new link " << lnk.describe() << " RUSW=" << int(mMAP.FEEId2RUSW(lnk.feeID));
+        LOG(info) << mSelfName << " registered new " << lnk.describe() << " RUSW=" << int(mMAP.FEEId2RUSW(lnk.feeID));
       }
       linksAdded++;
     }
@@ -330,7 +339,7 @@ void RawPixelDecoder<Mapping>::setupLinks(InputRecord& inputs)
       mMAP.expandFEEId(link.feeID, lr, ruOnLr, linkInRU);
       if (newLinkAdded) {
         if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
-          LOG(info) << mSelfName << " Attaching " << link.describe() << " to RU#" << int(mMAP.FEEId2RUSW(link.feeID)) << " (stave " << ruOnLr << " of layer " << lr << ')';
+          LOGP(info, "{} Attaching {} to RU#{:02} (stave {:02} of layer {})", mSelfName, link.describe(), int(mMAP.FEEId2RUSW(link.feeID)), ruOnLr, lr);
         }
       }
       link.idInRU = linkInRU;

Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h

@@ -16,12 +16,14 @@
 #ifndef O2_ITSMFT_STFDECODER_
 #define O2_ITSMFT_STFDECODER_
 
+#include <memory>
+#include <string>
+#include <array>
 #include <TStopwatch.h>
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
-#include <memory>
-#include <string>
-#include <string_view>
+#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
 #include "ITSMFTReconstruction/ChipMappingMFT.h"
 #include "ITSMFTReconstruction/RawPixelDecoder.h"
@@ -55,6 +57,9 @@ struct STFDecoderInp {
 template <class Mapping>
 class STFDecoder : public Task
 {
+  using AlpideParam = DPLAlpideParam<Mapping::getDetID()>;
+  static constexpr int NLayers{AlpideParam::supportsStaggering() ? AlpideParam::getNLayers() : 1};
+
  public:
   STFDecoder(const STFDecoderInp& inp, std::shared_ptr<o2::base::GRPGeomRequest> gr);
   STFDecoder() = default;
@@ -70,6 +75,8 @@ class STFDecoder : public Task
   void finalize();
   void reset();
   std::unique_ptr<o2::itsmft::Clusterer> setupClusterer(const std::string& dictName);
+  void ensureContinuousROF(const std::vector<ROFRecord>& in, std::vector<ROFRecord>& out, int lr, int nROFsTF, const char* name);
+
   TStopwatch mTimer;
   bool mDoClusters = false;
   bool mDoPatterns = false;
@@ -87,18 +94,20 @@ class STFDecoder : public Task
   int mVerbosity = 0;
   long mROFErrRepIntervalMS = 0;
   size_t mTFCounter = 0;
-  size_t mEstNDig = 0;
-  size_t mEstNClus = 0;
-  size_t mEstNClusPatt = 0;
-  size_t mEstNCalib = 0;
-  size_t mEstNROF = 0;
+  uint32_t mFirstTFOrbit = 0;
+  o2::InteractionRecord mFirstIR;
+  std::array<size_t, NLayers> mEstNDig{0};
+  std::array<size_t, NLayers> mEstNClus{0};
+  std::array<size_t, NLayers> mEstNClusPatt{0};
+  std::array<size_t, NLayers> mEstNCalib{0};
   size_t mMaxRawDumpsSize = 0;
   size_t mRawDumpedSize = 0;
   std::string mInputSpec;
   std::string mSelfName;
-  std::unique_ptr<RawPixelDecoder<Mapping>> mDecoder;
+  std::array<std::unique_ptr<RawPixelDecoder<Mapping>>, NLayers> mDecoder;
   std::unique_ptr<Clusterer> mClusterer;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
+  std::array<std::vector<InputSpec>, NLayers> mRawFilter;
 };
 
 using STFDecoderITS = STFDecoder<ChipMappingITS>;