Merge b3870af into sapling-pr-archive-ktf

Author: ktf

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

@@ -155,7 +155,7 @@ struct GBTLink {
       long offs = sizeof(RDH);
       char* ptrR = ((char*)ptr) + sizeof(RDH);
       while (offs < szd) {
-        const o2::itsmft::GBTWord* w = reinterpret_cast<const o2::itsmft::GBTWord*>(ptrR);
+        const GBTWord* w = reinterpret_cast<const o2::itsmft::GBTWord*>(ptrR);
         std::string com = fmt::format(" | FeeID:{:#06x} offs: {:6} ", feeID, offs);
         if (w->isData()) {
           com += "data word";
@@ -164,12 +164,12 @@ struct GBTLink {
         } else if (w->isDataTrailer()) {
           com += "data trailer";
         } else if (w->isTriggerWord()) {
-          com += "trigger word";
+          const GBTTrigger* trw = (const GBTTrigger*)w;
+          com += fmt::format("trigger word bc:{} orbit:{} noData:{} int:{} cont:{}", trw->bc, trw->orbit, trw->noData, trw->internal, trw->continuation);
         } else if (w->isDiagnosticWord()) {
           com += "diag word";
         } else if (w->isCalibrationWord()) {
-          com += "calib word";
-          com += fmt::format(" #{}", ((const GBTCalibration*)w)->calibCounter);
+          com += fmt::format("calib word count:{:5} data:{:#08x}", ((const GBTCalibration*)w)->calibCounter, ((const GBTCalibration*)w)->calibUserField);
         } else if (w->isCableDiagnostic()) {
           com += "cable diag word";
         } else if (w->isStatus()) {

Detectors/Raw/src/RDHUtils.cxx

@@ -26,48 +26,39 @@ using namespace o2::header;
 void RDHUtils::printRDH(const RAWDataHeaderV4& rdh)
 {
   std::bitset<32> trb(rdh.triggerType);
-  LOGF(info, "EP:%d CRU:0x%04x Link:%-3d FEEID:0x%04x Packet:%-3d MemSize:%-4d OffsNext:%-4d prio.:%d BL:%-5d HS:%-2d HV:%d",
-       int(rdh.endPointID), int(rdh.cruID), int(rdh.linkID), int(rdh.feeId), int(rdh.packetCounter), int(rdh.memorySize),
-       int(rdh.offsetToNext), int(rdh.priority), int(rdh.blockLength), int(rdh.headerSize), int(rdh.version));
-  LOGF(info, "HBOrb:%-9u TrOrb:%-9u Trg:%32s HBBC:%-4d TrBC:%-4d Page:%-5d Stop:%d Par:%-5d DetFld:0x%04x", //
+  LOGF(info, "EP:%d CRU:0x%04x Link:%-3d FEEID:0x%04x HBOrb:%-9u TrOrb:%-9u Trg:%32s HBBC:%-4d TrBC:%-4d Packet:%-3d Page:%-5d Stop:%d Par:%-5d DetFld:0x%04x MemSize:%-4d OffsNext:%-4d prio.:%d BL:%-5d HS:%-2d HV:%d",
+       int(rdh.endPointID), int(rdh.cruID), int(rdh.linkID), int(rdh.feeId),
        rdh.heartbeatOrbit, rdh.triggerOrbit, trb.to_string().c_str(), int(rdh.heartbeatBC), int(rdh.triggerBC),
-       int(rdh.pageCnt), int(rdh.stop), int(rdh.par), int(rdh.detectorField));
+       int(rdh.packetCounter), int(rdh.pageCnt), int(rdh.stop), int(rdh.par), int(rdh.detectorField), int(rdh.memorySize),
+       int(rdh.offsetToNext), int(rdh.priority), int(rdh.blockLength), int(rdh.headerSize), int(rdh.version));
 }
 
 //_________________________________________________
 void RDHUtils::printRDH(const RAWDataHeaderV5& rdh)
 {
   std::bitset<32> trb(rdh.triggerType);
-  LOGF(info, "EP:%d CRU:0x%04x Link:%-3d FEEID:0x%04x Packet:%-3d MemSize:%-5d OffsNext:%-5d  prio.:%d HS:%-2d HV:%d",
-       int(rdh.endPointID), int(rdh.cruID), int(rdh.linkID), int(rdh.feeId), int(rdh.packetCounter), int(rdh.memorySize),
+  LOGF(info, "EP:%d CRU:0x%04x Link:%-3d FEEID:0x%04x Orbit:%-9u BC:%-4d Stop:%d Page:%-5d Packet:%-3d Trg:%32s Par:%-5d DetFld:0x%04x MemSize:%-5d OffsNext:%-5d  prio.:%d HS:%-2d HV:%d",
+       int(rdh.endPointID), int(rdh.cruID), int(rdh.linkID), int(rdh.feeId), rdh.orbit, int(rdh.bunchCrossing), int(rdh.stop), int(rdh.pageCnt),
+       int(rdh.packetCounter), trb.to_string().c_str(), int(rdh.detectorPAR), int(rdh.detectorField), int(rdh.memorySize),
        int(rdh.offsetToNext), int(rdh.priority), int(rdh.headerSize), int(rdh.version));
-  LOGF(info, "Orbit:%-9u BC:%-4d Stop:%d Page:%-5d Trg:%32s Par:%-5d DetFld:0x%04x",
-       rdh.orbit, int(rdh.bunchCrossing), int(rdh.stop), int(rdh.pageCnt), trb.to_string().c_str(),
-       int(rdh.detectorPAR), int(rdh.detectorField));
 }
 
 //_________________________________________________
 void RDHUtils::printRDH(const RAWDataHeaderV7& rdh)
 {
   std::bitset<32> trb(rdh.triggerType);
-  LOGF(info, "EP:%d CRU:0x%04x Link:%-3d FEEID:0x%04x SrcID:%s[%d] Packet:%-3d MemSize:%-5d OffsNext:%-5d  prio.:%d HS:%-2d HV:%d",
-       int(rdh.endPointID), int(rdh.cruID), int(rdh.linkID), int(rdh.feeId), DAQID::DAQtoO2(rdh.sourceID).str, int(rdh.sourceID), int(rdh.packetCounter),
-       int(rdh.memorySize), int(rdh.offsetToNext), int(rdh.priority), int(rdh.headerSize), int(rdh.version));
-  LOGF(info, "Orbit:%-9u BC:%-4d DataFormat:%-2d Stop:%d Page:%-5d Trg:%32s Par:%-5d DetFld:0x%04x",
-       rdh.orbit, int(rdh.bunchCrossing), int(rdh.dataFormat), int(rdh.stop), int(rdh.pageCnt), trb.to_string().c_str(),
-       int(rdh.detectorPAR), int(rdh.detectorField));
+  LOGF(info, "EP:%d CRU:0x%04x Link:%-3d FEEID:0x%04x SrcID:%s[%d] Orbit:%-9u BC:%-4d DataFormat:%-2d Stop:%d Page:%-5d Packet:%-3d Trg:%32s Par:%-5d DetFld:0x%04x MemSize:%-5d OffsNext:%-5d  prio.:%d HS:%-2d HV:%d",
+       int(rdh.endPointID), int(rdh.cruID), int(rdh.linkID), int(rdh.feeId), DAQID::DAQtoO2(rdh.sourceID).str, int(rdh.sourceID), rdh.orbit, int(rdh.bunchCrossing), int(rdh.dataFormat), int(rdh.stop), int(rdh.pageCnt), int(rdh.packetCounter),
+       trb.to_string().c_str(), int(rdh.detectorPAR), int(rdh.detectorField), int(rdh.memorySize), int(rdh.offsetToNext), int(rdh.priority), int(rdh.headerSize), int(rdh.version));
 }
 
 //_________________________________________________
 void RDHUtils::printRDH(const RAWDataHeaderV6& rdh)
 {
   std::bitset<32> trb(rdh.triggerType);
-  LOGF(info, "EP:%d CRU:0x%04x Link:%-3d FEEID:0x%04x SrcID:%s[%d] Packet:%-3d MemSize:%-5d OffsNext:%-5d  prio.:%d HS:%-2d HV:%d",
-       int(rdh.endPointID), int(rdh.cruID), int(rdh.linkID), int(rdh.feeId), DAQID::DAQtoO2(rdh.sourceID).str, int(rdh.sourceID), int(rdh.packetCounter),
-       int(rdh.memorySize), int(rdh.offsetToNext), int(rdh.priority), int(rdh.headerSize), int(rdh.version));
-  LOGF(info, "Orbit:%-9u BC:%-4d Stop:%d Page:%-5d Trg:%32s Par:%-5d DetFld:0x%04x",
-       rdh.orbit, int(rdh.bunchCrossing), int(rdh.stop), int(rdh.pageCnt), trb.to_string().c_str(),
-       int(rdh.detectorPAR), int(rdh.detectorField));
+  LOGF(info, "EP:%d CRU:0x%04x Link:%-3d FEEID:0x%04x SrcID:%s[%d] Orbit:%-9u BC:%-4d Stop:%d Page:%-5d Packet:%-3d Trg:%32s Par:%-5d DetFld:0x%04x MemSize:%-5d OffsNext:%-5d  prio.:%d HS:%-2d HV:%d",
+       int(rdh.endPointID), int(rdh.cruID), int(rdh.linkID), int(rdh.feeId), DAQID::DAQtoO2(rdh.sourceID).str, int(rdh.sourceID), rdh.orbit, int(rdh.bunchCrossing), int(rdh.stop), int(rdh.pageCnt),
+       int(rdh.packetCounter), trb.to_string().c_str(), int(rdh.detectorPAR), int(rdh.detectorField), int(rdh.memorySize), int(rdh.offsetToNext), int(rdh.priority), int(rdh.headerSize), int(rdh.version));
 }
 
 //_________________________________________________

Detectors/TOF/base/include/TOFBase/WindowFiller.h

@@ -104,8 +104,8 @@ class WindowFiller
 
  protected:
   // info TOF timewindow
-  uint64_t mReadoutWindowCurrent = 0;
-  InteractionRecord mFirstIR{0, 0}; // reference IR (1st IR of the timeframe)
+  uint64_t mReadoutWindowCurrent = 0; // keeps track of current readout window
+  InteractionRecord mFirstIR{0, 0};   // reference IR (1st IR of the timeframe)
   InteractionTimeRecord mEventTime;
 
   bool mContinuous = true;

Detectors/TOF/simulation/include/TOFSimulation/Digitizer.h

@@ -83,6 +83,14 @@ class Digitizer : public WindowFiller
   void setEffBoundary2(float val) { mEffBoundary2 = val; }
   void setEffBoundary3(float val) { mEffBoundary3 = val; }
 
+  // determines the readout window id, given a time in nanoseconds (relative
+  // to orbit-reset)
+  uint64_t getReadoutWindow(double timeNS) const
+  {
+    // event time shifted by 2 BC as safe margin before to change current readout window to account for decalibration
+    return uint64_t((timeNS - Geo::BC_TIME * (Geo::OVERLAP_IN_BC + 2)) * Geo::READOUTWINDOW_INV);
+  }
+
  private:
   // parameters
   Int_t mMode;

Detectors/TOF/simulation/include/TOFSimulation/TOFSimParams.h

@@ -33,6 +33,8 @@ struct TOFSimParams : public o2::conf::ConfigurableParamHelper<TOFSimParams> {
   float eff_boundary2 = 0.833; // efficiency in the pad border
   float eff_boundary3 = 0.1;   // efficiency in mBound3
 
+  float max_hit_time = 1000.; // time cutoff for hits (time of flight); default 1us
+
   O2ParamDef(TOFSimParams, "TOFSimParams");
 };
 

Detectors/TOF/simulation/src/Digitizer.cxx

@@ -69,6 +69,7 @@ void Digitizer::init()
 {
 
   // set first readout window in MC production getting
+  // orbitFirstSampled corresponds to the start of the concrete timeframe (it is set in O2DPG productions)
   mReadoutWindowCurrent = uint64_t(o2::raw::HBFUtils::Instance().orbitFirstSampled) * Geo::NWINDOW_IN_ORBIT;
 
   // method to initialize the parameters neede to digitize and the array of strip objects containing
@@ -91,12 +92,21 @@ void Digitizer::init()
 
 int Digitizer::process(const std::vector<HitType>* hits, std::vector<Digit>* digits)
 {
+  const double max_hit_time = TOFSimParams::Instance().max_hit_time;
+
   // hits array of TOF hits for a given simulated event
   // digits passed from external to be filled, in continuous readout mode we will push it on mDigitsPerTimeFrame vector of vectors of digits
 
   //  printf("process event time = %f with %ld hits\n",mEventTime.getTimeNS(),hits->size());
 
-  uint64_t readoutwindow = uint64_t((mEventTime.getTimeNS() - Geo::BC_TIME * (Geo::OVERLAP_IN_BC + 2)) * Geo::READOUTWINDOW_INV); // event time shifted by 2 BC as safe margin before to change current readout window to account for decalibration
+  uint64_t readoutwindow = getReadoutWindow(mEventTime.getTimeNS());
+
+  // determines the maximal readout window difference to a preceding RO which can still affect the current readout window
+  int max_readout_diff = int(max_hit_time * Geo::READOUTWINDOW_INV) + 1;
+  // early return based on events happening earlier than MAX_READOUT_DIFF away from current RO frame
+  if (readoutwindow < mReadoutWindowCurrent && mReadoutWindowCurrent - readoutwindow > max_readout_diff) {
+    return 0;
+  }
 
   if (mContinuous && readoutwindow > mReadoutWindowCurrent) { // if we are moving in future readout windows flush previous ones (only for continuous readout mode)
     digits->clear();
@@ -110,9 +120,18 @@ int Digitizer::process(const std::vector<HitType>* hits, std::vector<Digit>* dig
   for (auto& hit : *hits) {
     // TODO: put readout window counting/selection
     //  neglect very slow particles (low energy neutrons)
-    if (hit.GetTime() > 1000) { // 1 mus
+    if (hit.GetTime() > max_hit_time) { // 1 mus
+      continue;
+    }
+
+    // discard hits arriving before the minimum readout window
+    auto hit_ro_window = getReadoutWindow(double(hit.GetTime()) + mEventTime.getTimeNS() /*+ Geo::LATENCYWINDOW*/);
+
+    // discard hits arriving too early
+    if (hit_ro_window < mReadoutWindowCurrent) {
       continue;
     }
+
     processHit(hit, mEventTime.getTimeOffsetWrtBC() + Geo::LATENCYWINDOW);
   } // end loop over hits
 

Detectors/TPC/simulation/include/TPCSimulation/SAMPAProcessing.h

@@ -258,6 +258,10 @@ inline float SAMPAProcessing::getZfromTimeBin(float timeBin, Side s) const
 
 inline TimeBin SAMPAProcessing::getTimeBinFromTime(float time) const
 {
+  if (time < 0.f) {
+    // protection and convention for negative times (otherwise overflow)
+    return 0;
+  }
   return static_cast<TimeBin>(time / mEleParam->ZbinWidth);
 }
 

Detectors/TPC/simulation/src/Digitizer.cxx

@@ -111,6 +111,12 @@ void Digitizer::process(const std::vector<o2::tpc::HitGroup>& hits,
         }
         const float absoluteTime = eleTime + mTDriftOffset + (mEventTime - mOutputDigitTimeOffset); /// in us
 
+        /// the absolute time needs to be within the readout limits
+        /// (otherwise negative times would all be accumulated in the 0-th timebin further below)
+        if (!(absoluteTime >= 0 /* && absoluteTime <= timeframelength */)) {
+          continue;
+        }
+
         /// Attachment
         if (electronTransport.isElectronAttachment(driftTime)) {
           continue;
@@ -217,9 +223,14 @@ void Digitizer::setUseSCDistortions(std::string_view finp)
 
 void Digitizer::setStartTime(double time)
 {
+  // this is setting the first timebin index for the digit container
+  // note that negative times w.r.t start of timeframe/data-taking == mOutputDigitTimeOffset
+  // will yield the 0-th bin (due to casting logic in sampaProcessing)
   SAMPAProcessing& sampaProcessing = SAMPAProcessing::instance();
   sampaProcessing.updateParameters(mVDrift);
-  mDigitContainer.setStartTime(sampaProcessing.getTimeBinFromTime(time - mOutputDigitTimeOffset));
+  const auto timediff = time - mOutputDigitTimeOffset;
+  const auto starttimebin = sampaProcessing.getTimeBinFromTime(timediff);
+  mDigitContainer.setStartTime(starttimebin);
 }
 
 void Digitizer::setLumiScaleFactor()

Framework/Core/include/Framework/DataProcessingStats.h

@@ -16,6 +16,7 @@
 #include <atomic>
 #include <cstdint>
 #include <array>
+#include <memory>
 #include <numeric>
 #include <mutex>
 #include <utility>
@@ -69,8 +70,16 @@ enum struct ProcessingStatsId : short {
 
 /// Helper struct to hold statistics about the data processing happening.
 struct DataProcessingStats {
+  // Parameters for the default behaviour
+  struct DefaultConfig {
+    int64_t minOnlinePublishInterval = 0;
+  };
+
+  DefaultConfig config = {};
+
   DataProcessingStats(std::function<void(int64_t& base, int64_t& offset)> getRealtimeBase,
-                      std::function<int64_t(int64_t base, int64_t offset)> getTimestamp);
+                      std::function<int64_t(int64_t base, int64_t offset)> getTimestamp,
+                      DefaultConfig config);
 
   constexpr static ServiceKind service_kind = ServiceKind::Global;
   constexpr static unsigned short MAX_METRICS = 1 << 15;

Framework/Core/src/CommonServices.cxx

@@ -867,8 +867,11 @@ o2::framework::ServiceSpec CommonServices::dataProcessingStats()
       clock_gettime(CLOCK_REALTIME, &now);
       uv_update_time(state.loop);
       uint64_t offset = now.tv_sec * 1000 - uv_now(state.loop);
+      DataProcessingStats::DefaultConfig config = {
+        .minOnlinePublishInterval = std::stoi(options.GetProperty<std::string>("dpl-stats-min-online-publishing-interval").c_str())};
       auto* stats = new DataProcessingStats(TimingHelpers::defaultRealtimeBaseConfigurator(offset, state.loop),
-                                            TimingHelpers::defaultCPUTimeConfigurator(state.loop));
+                                            TimingHelpers::defaultCPUTimeConfigurator(state.loop),
+                                            config);
       auto& runningWorkflow = services.get<RunningWorkflowInfo const>();
 
       // It makes no sense to update the stats more often than every 5s