Preserve DPL orbit in CMV TFs when FLP orbit is missing

Author: tubagundem

Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h

@@ -58,9 +58,9 @@ struct CMVEncoding {
 ///       kZigzag + kVarint  → varint(zigzag(signed(raw)))
 ///       kZigzag + kHuffman → [Huffman table] + [bitstream] of zigzag(signed(raw))
 struct CMVPerTFCompressed {
-  uint32_t firstOrbit{0}; ///< First orbit of this TF
-  uint16_t firstBC{0};    ///< First bunch crossing of this TF
-  uint8_t mFlags{0};      ///< Bitmask of CMVEncoding values
+  uint32_t firstOrbit{0};    ///< First orbit of this TF
+  uint32_t firstOrbitDPL{0}; ///< First orbit of this TF
+  uint8_t mFlags{0};         ///< Bitmask of CMVEncoding values
 
   std::vector<uint8_t> mData; ///< Encoded payload
 
@@ -88,14 +88,14 @@ struct CMVPerTFCompressed {
   static void decodeDenseValues(const std::vector<uint32_t>& symbols, uint8_t flags, CMVPerTF* cmv);
 
  public:
-  ClassDefNV(CMVPerTFCompressed, 1)
+  ClassDefNV(CMVPerTFCompressed, 2)
 };
 
 /// CMV data for one TF across all CRUs
 /// Raw 16-bit CMV values are stored in a flat C array indexed as [cru * NTimeBinsPerTF + timeBin]
 struct CMVPerTF {
-  uint32_t firstOrbit{0}; ///< First orbit of this TF, from heartbeatOrbit of the first CMV packet
-  uint16_t firstBC{0};    ///< First bunch crossing of this TF, from heartbeatBC of the first CMV packet
+  uint32_t firstOrbit{0};    ///< First orbit of this TF, from heartbeatOrbit of the first CMV packet
+  uint32_t firstOrbitDPL{0}; ///< First orbit of this TF, from DPL
 
   // Raw 16-bit CMV values, flat array indexed as [cru * NTimeBinsPerTF + timeBin]
   uint16_t mDataPerTF[CRU::MaxCRU * cmv::NTimeBinsPerTF]{};
@@ -133,7 +133,7 @@ struct CMVPerTF {
   static void encodeVarintInto(uint32_t value, std::vector<uint8_t>& out);                               ///< Varint encode
 
  public:
-  ClassDefNV(CMVPerTF, 1)
+  ClassDefNV(CMVPerTF, 2)
 };
 
 } // namespace o2::tpc

Detectors/TPC/calibration/macro/drawCMV.C

@@ -32,7 +32,7 @@ using namespace o2::tpc;
 /// \param filename  input ROOT file containing the ccdb_object TTree
 /// \param outDir    output directory for saved plots; nothing is saved if empty
 /// \return          array of canvases
-TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
+TObjArray* drawCMV(std::string_view filename, std::string_view outDir, std::string_view rootFileName = "CMVCanvases.root")
 {
   TObjArray* arrCanvases = new TObjArray;
   arrCanvases->SetName("CMV");
@@ -82,7 +82,7 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
                        110, -100.5, 9.5);
   h2d->SetStats(1);
   TH1F* h1d = new TH1F("hCMV", ";Common Mode Values (ADC);Counts",
-                       1100, -100.5, 9.5);
+                       110, -100.5, 9.5);
   h1d->SetStats(1);
 
   // auto-detect branch format: compressed or raw
@@ -105,6 +105,7 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
   }
 
   long firstOrbit = -1;
+  long firstOrbitDPL = -1;
 
   for (int i = 0; i < nEntries; ++i) {
     tree->GetEntry(i);
@@ -118,16 +119,15 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
       tf = tfRaw;
     }
 
-    if (i == 0) {
-      firstOrbit = tf->firstOrbit;
-    }
+    firstOrbit = tf->firstOrbit;
+    firstOrbitDPL = tf->firstOrbitDPL;
+    fmt::print("firstOrbit: {}, firstOrbitDPL: {}\n", firstOrbit, firstOrbitDPL);
 
     for (int cru = 0; cru < nCRUs; ++cru) {
       for (int tb = 0; tb < nTimeBins; ++tb) {
         const float cmvValue = tf->getCMVFloat(cru, tb);
         h2d->Fill(tb, cmvValue);
         h1d->Fill(cmvValue);
-        // fmt::print("cru: {}, tb: {}, cmv: {}\n", cru, tb, cmvValue);
       }
     }
   }
@@ -136,8 +136,6 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
   tree->ResetBranchAddresses();
   delete tfCompressed;
 
-  fmt::print("firstOrbit: {}\n", firstOrbit);
-
   // draw
   auto* c = new TCanvas("cCMVvsTimeBin", "");
   c->SetLogz();
@@ -152,7 +150,7 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
   arrCanvases->Add(c1);
 
   if (outDir.size()) {
-    utils::saveCanvases(*arrCanvases, outDir, "png,pdf", "CMVCanvases.root");
+    utils::saveCanvases(*arrCanvases, outDir, "", rootFileName);
   }
 
   f.Close();

Detectors/TPC/calibration/src/CMVContainer.cxx

@@ -447,7 +447,7 @@ CMVPerTFCompressed CMVPerTF::compress(uint8_t flags) const
 {
   CMVPerTFCompressed out;
   out.firstOrbit = firstOrbit;
-  out.firstBC = firstBC;
+  out.firstOrbitDPL = firstOrbitDPL;
   out.mFlags = flags;
 
   if (flags & CMVEncoding::kSparse) {
@@ -670,7 +670,7 @@ void CMVPerTFCompressed::decompress(CMVPerTF* cmv) const
     throw std::invalid_argument("CMVPerTFCompressed::decompress: cmv pointer is null");
   }
   cmv->firstOrbit = firstOrbit;
-  cmv->firstBC = firstBC;
+  cmv->firstOrbitDPL = firstOrbitDPL;
   std::fill(std::begin(cmv->mDataPerTF), std::end(cmv->mDataPerTF), uint16_t(0));
 
   const uint8_t* ptr = mData.data();

Detectors/TPC/workflow/include/TPCWorkflow/TPCAggregateCMVSpec.h

@@ -211,7 +211,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
         // independent of the GRPECS/config nHBFPerTF value.
         const auto batchLastOrbit = static_cast<uint32_t>(pc.services().get<o2::framework::TimingInfo>().firstTForbit);
         const auto defaultOrbitStep = static_cast<uint32_t>(o2::base::GRPGeomHelper::instance().getNHBFPerTF());
-        mOrbitStep[relTF] = (mNTFsBuffer > 1 && batchLastOrbit > batchFirstOrbit) ? (batchLastOrbit - batchFirstOrbit) / static_cast<uint32_t>(mNTFsBuffer - 1) : defaultOrbitStep;
+        mOrbitStep[relTF] = ((batchFirstOrbit > 0) && (mNTFsBuffer > 1) && (batchLastOrbit > batchFirstOrbit)) ? (batchLastOrbit - batchFirstOrbit) / static_cast<uint32_t>(mNTFsBuffer - 1) : defaultOrbitStep;
         mLastOrbitStep = mOrbitStep[relTF];
         mOrbitInfoSeen[relTF] = true;
         break;
@@ -307,6 +307,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
   uint64_t mRun{0};                                                            ///< run number, captured once per run
   uint32_t mIntervalFirstOrbit{0};                                             ///< first orbit of the first TF in the current interval
   uint32_t mIntervalLastOrbit{0};                                              ///< first orbit of the last TF in the current interval
+  uint32_t mFirstOrbitDPL{0};                                                  ///< first orbit of the first TF in the current interval
   bool mIntervalOrbitSet{false};                                               ///< true once first orbit has been captured for the current interval
   dataformats::Pair<long, int> mTFInfo{};                                      ///< orbit-reset time (ms) and NHBFPerTF forwarded by distribute lane 0 for precise timestamps
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;                      ///< GRPECS request so GRPGeomHelper::getNHBFPerTF() is valid in this process
@@ -396,8 +397,9 @@ class TPCAggregateCMVDevice : public o2::framework::Task
     // prefer the measured stride; fall back to NHBFPerTF from GRPECS
     const int nHBFPerTF = (orbitStep > 0) ? static_cast<int>(orbitStep) : o2::base::GRPGeomHelper::instance().getNHBFPerTF();
     const auto nOrbitsOffset = (relTF * mNTFsBuffer + (mNTFsBuffer - 1)) * nHBFPerTF;
+    mFirstOrbitDPL = tinfo.firstTForbit - nOrbitsOffset;
     mTimestampStart = mUsePreciseTimestamp ? (mTFInfo.first + (tinfo.firstTForbit - nOrbitsOffset) * o2::constants::lhc::LHCOrbitMUS * 0.001) : tinfo.creation;
-    LOGP(detail, "Setting time stamp reset reference to: {}, at tfCounter: {}, firstTForbit: {}, NHBFPerTF: {}, relTF: {}, nOrbitsOffset: {}",
+    LOGP(info, "Setting timestamp reset reference to: {}, at tfCounter: {}, firstTForbit: {}, NHBFPerTF: {}, relTF: {}, nOrbitsOffset: {}",
          mTFInfo.first, tinfo.tfCounter, tinfo.firstTForbit, nHBFPerTF, relTF, nOrbitsOffset);
   }
 
@@ -480,11 +482,13 @@ class TPCAggregateCMVDevice : public o2::framework::Task
 
     const auto firstOrbit = static_cast<uint32_t>(orbitInfo >> 32);
     const auto firstBC = static_cast<uint16_t>(orbitInfo & 0xFFFFu);
+    // Use the DPL-derived orbit as fallback when the FLP orbit info is missing (firstOrbit == 0)
+    const auto batchFirstOrbitDPL = (firstOrbit > 0) ? firstOrbit : mFirstOrbitDPL;
     if (!mIntervalOrbitSet) {
-      mIntervalFirstOrbit = firstOrbit;
+      mIntervalFirstOrbit = batchFirstOrbitDPL;
       mIntervalOrbitSet = true;
     }
-    mIntervalLastOrbit = firstOrbit + static_cast<uint32_t>(nTFsInBatch - 1) * orbitStep;
+    mIntervalLastOrbit = batchFirstOrbitDPL + static_cast<uint32_t>(nTFsInBatch - 1) * orbitStep;
     const uint8_t flags = buildCompressionFlags();
     std::vector<PreparedTF> prepared(nTFsInBatch);
     const int nThreads = std::max(1, std::min(mThreads, nTFsInBatch));
@@ -497,7 +501,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
 
         auto& preparedTF = prepared[tfIndex];
         preparedTF.tf.firstOrbit = firstOrbit + static_cast<uint32_t>(tfIndex) * orbitStep;
-        preparedTF.tf.firstBC = (tfIndex == 0) ? firstBC : 0;
+        preparedTF.tf.firstOrbitDPL = batchFirstOrbitDPL + static_cast<uint32_t>(tfIndex) * orbitStep;
 
         for (const auto& [cru, values] : rawCMVs) {
           const uint32_t offset = static_cast<uint32_t>(tfIndex) * cmv::NTimeBinsPerTF;
@@ -558,7 +562,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
     mIntervalTree->GetUserInfo()->Add(new TParameter<long>("firstTF", mIntervalFirstTF));
     mIntervalTree->GetUserInfo()->Add(new TParameter<long>("lastTF", lastTF));
 
-    LOGP(detail, "CMVPerTF TTree lane {}: {} entries, firstTF={}, lastTF={}", mLaneId, mIntervalTFCount, mIntervalFirstTF, lastTF);
+    LOGP(info, "CMVPerTF TTree lane {}: {} entries, firstTF={}, lastTF={}", mLaneId, mIntervalTFCount, mIntervalFirstTF, lastTF);
     auto start = timer::now();
 
     const int nHBFPerTF = o2::base::GRPGeomHelper::instance().getNHBFPerTF();
@@ -569,7 +573,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
                                                  mRun, mIntervalFirstOrbit, mIntervalLastOrbit, mTimestampStart, timeStampEnd);
       try {
         CMVPerTF::writeToFile(mOutputDir + calibFName, mIntervalTree);
-        LOGP(detail, "CMV file written to {}", mOutputDir + calibFName);
+        LOGP(info, "CMV file written to {}", mOutputDir + calibFName);
       } catch (const std::exception& e) {
         LOGP(error, "Failed to write CMV file {}: {}", mOutputDir + calibFName, e.what());
       }
@@ -614,13 +618,13 @@ class TPCAggregateCMVDevice : public o2::framework::Task
       mf.Close();
     }
 
-    LOGP(detail, "Sending object {} / {} of size {} bytes, valid for {} : {}", ccdbInfoCMV.getPath(), ccdbInfoCMV.getFileName(), image->size(), ccdbInfoCMV.getStartValidityTimestamp(), ccdbInfoCMV.getEndValidityTimestamp());
+    LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {}", ccdbInfoCMV.getPath(), ccdbInfoCMV.getFileName(), image->size(), ccdbInfoCMV.getStartValidityTimestamp(), ccdbInfoCMV.getEndValidityTimestamp());
     output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBCMV(), 0}, *image);
     output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBCMV(), 0}, ccdbInfoCMV);
 
     auto stop = timer::now();
     std::chrono::duration<float> elapsed = stop - start;
-    LOGP(detail, "CMV CCDB serialisation time: {:.3f} s", elapsed.count());
+    LOGP(info, "CMV CCDB serialisation time: {:.3f} s", elapsed.count());
   }
 
   /// Reset all per-interval state after a successful sendOutput(); prepares for the next interval
@@ -652,6 +656,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
     mIntervalTFCount = 0;
     mIntervalFirstOrbit = 0;
     mIntervalLastOrbit = 0;
+    mFirstOrbitDPL = 0;
     mIntervalOrbitSet = false;
     mCurrentTF = CMVPerTF{};
     mCurrentCompressedTF = CMVPerTFCompressed{};