MFT: new plots for the digit task

Modules/MFT/include/MFT/QcMFTDigitTask.h

@@ -26,6 +26,7 @@
 #include <TH2.h>
 // O2
 #include <ITSMFTReconstruction/ChipMappingMFT.h>
+#include <CommonConstants/LHCConstants.h>
 // Quality Control
 #include "QualityControl/TaskInterface.h"
 
@@ -53,6 +54,11 @@ class QcMFTDigitTask final : public TaskInterface
   void endOfActivity(Activity& activity) override;
   void reset() override;
 
+  double orbitToSeconds(uint32_t orbit, uint32_t refOrbit)
+  {
+    return (orbit - refOrbit) * o2::constants::lhc::LHCOrbitNS / 1E9;
+  }
+
  private:
   //  variables
   const double maxBinXPixelOccupancyMap = 1024;
@@ -89,9 +95,16 @@ class QcMFTDigitTask final : public TaskInterface
   std::unique_ptr<TH2F> mDigitOccupancySummary = nullptr;
   std::unique_ptr<TH2F> mDigitDoubleColumnSensorIndices = nullptr;
 
+  std::unique_ptr<TH1F> mDigitsROFSize = nullptr;
+  std::unique_ptr<TH1F> mNOfDigitsTime = nullptr;
+  std::unique_ptr<TH1F> mDigitsBC = nullptr;
+
   std::vector<std::unique_ptr<TH2F>> mDigitChipOccupancyMap;
   std::vector<std::unique_ptr<TH2F>> mDigitPixelOccupancyMap;
 
+  // reference orbit used in relative time calculation
+  uint32_t mRefOrbit = 0;
+
   //  functions
   int getVectorIndexChipOccupancyMap(int chipIndex);
   int getIndexChipOccupancyMap(int vectorChipOccupancyMapIndex);

Modules/MFT/qc-mft-digit.json

@@ -37,7 +37,11 @@
         },
         "taskParameters" : {
           "FLP" : "0",
-          "NoiseScan" : "1"
+          "NoiseScan" : "1",
+          "maxDigitROFSize" : "5000",
+          "maxDuration" : "60000",
+          "timeBinSize" : "0.1",
+          "ROFLengthInBC" : "198"
         },
         "location" : "remote"
       }

Modules/MFT/src/QcMFTDigitTask.cxx

@@ -25,6 +25,7 @@
 #include <DataFormatsITSMFT/Digit.h>
 #include <DataFormatsITSMFT/ROFRecord.h>
 #include <Framework/InputRecord.h>
+#include <Framework/TimingInfo.h>
 #include <ITSMFTReconstruction/ChipMappingMFT.h>
 // Quality Control
 #include "QualityControl/QcInfoLogger.h"
@@ -52,11 +53,40 @@ void QcMFTDigitTask::initialize(o2::framework::InitContext& /*ctx*/)
     ILOG(Info, Support) << "Custom parameter - FLP: " << param->second << ENDM;
     mCurrentFLP = stoi(param->second);
   }
+
+  // loading custom parameters
   if (auto param = mCustomParameters.find("NoiseScan"); param != mCustomParameters.end()) {
     ILOG(Info, Support) << "Custom parameter - NoiseScan: " << param->second << ENDM;
     mNoiseScan = stoi(param->second);
   }
 
+  auto maxDigitROFSize = 5000;
+  if (auto param = mCustomParameters.find("maxDigitROFSize"); param != mCustomParameters.end()) {
+    ILOG(Info, Devel) << "Custom parameter - maxDigitROFSize: " << param->second << ENDM;
+    maxDigitROFSize = stoi(param->second);
+  }
+
+  auto maxDuration = 60.f;
+  if (auto param = mCustomParameters.find("maxDuration"); param != mCustomParameters.end()) {
+    ILOG(Info, Devel) << "Custom parameter - maxDuration: " << param->second << ENDM;
+    maxDuration = stof(param->second);
+  }
+
+  auto timeBinSize = 0.01f;
+  if (auto param = mCustomParameters.find("timeBinSize"); param != mCustomParameters.end()) {
+    ILOG(Info, Devel) << "Custom parameter - timeBinSize: " << param->second << ENDM;
+    timeBinSize = stof(param->second);
+  }
+
+  auto NofTimeBins = static_cast<int>(maxDuration / timeBinSize);
+
+  auto ROFLengthInBC = 198;
+  if (auto param = mCustomParameters.find("ROFLengthInBC"); param != mCustomParameters.end()) {
+    ILOG(Info, Devel) << "Custom parameter - ROFLengthInBC: " << param->second << ENDM;
+    ROFLengthInBC = stoi(param->second);
+  }
+  auto ROFsPerOrbit = o2::constants::lhc::LHCMaxBunches / ROFLengthInBC;
+
   getChipMapData();
 
   //  reset arrays of vector and chip IDs
@@ -123,6 +153,19 @@ void QcMFTDigitTask::initialize(o2::framework::InitContext& /*ctx*/)
   getObjectsManager()->startPublishing(mDigitOccupancySummary.get());
   getObjectsManager()->setDefaultDrawOptions(mDigitOccupancySummary.get(), "colz");
 
+  mDigitsROFSize = std::make_unique<TH1F>("mDigitsROFSize", "Digits ROFs size; ROF Size (#Digits); #Entries", maxDigitROFSize, 0, maxDigitROFSize);
+  mDigitsROFSize->SetStats(0);
+  getObjectsManager()->startPublishing(mDigitsROFSize.get());
+  getObjectsManager()->setDisplayHint(mDigitsROFSize.get(), "logx logy");
+
+  mNOfDigitsTime = std::make_unique<TH1F>("mNOfDigitsTime", "Number of Digits per time bin; time (s); #Entries", NofTimeBins, 0, maxDuration);
+  mNOfDigitsTime->SetMinimum(0.1);
+  getObjectsManager()->startPublishing(mNOfDigitsTime.get());
+
+  mDigitsBC = std::make_unique<TH1F>("mDigitsBC", "Digits per BC (sum over orbits); BCid; #Entries", ROFsPerOrbit, 0, o2::constants::lhc::LHCMaxBunches);
+  mDigitsBC->SetMinimum(0.1);
+  getObjectsManager()->startPublishing(mDigitsBC.get());
+
   // --Chip hit maps
   //==============================================
   QcMFTUtilTables MFTTable;
@@ -211,6 +254,17 @@ void QcMFTDigitTask::monitorData(o2::framework::ProcessingContext& ctx)
   mDigitChipOccupancy->Fill(-1, nROFs);
   mDigitOccupancySummary->Fill(-1, -1, nROFs);
 
+  // get correct timing info of the first TF orbit
+  mRefOrbit = ctx.services().get<o2::framework::TimingInfo>().firstTForbit;
+
+  // fill the digits time histograms
+  for (const auto& rof : rofs) {
+    mDigitsROFSize->Fill(rof.getNEntries());
+    float seconds = orbitToSeconds(rof.getBCData().orbit, mRefOrbit) + rof.getBCData().bc * o2::constants::lhc::LHCBunchSpacingNS * 1e-9;
+    mNOfDigitsTime->Fill(seconds, rof.getNEntries());
+    mDigitsBC->Fill(rof.getBCData().bc, rof.getNEntries());
+  }
+
   // fill the pixel hit maps and overview histograms
   for (auto& oneDigit : digits) {
 
@@ -266,6 +320,9 @@ void QcMFTDigitTask::reset()
   if (mNoiseScan == 1)
     mDigitChipStdDev->Reset();
   mDigitOccupancySummary->Reset();
+  mDigitsROFSize->Reset();
+  mNOfDigitsTime->Reset();
+  mDigitsBC->Reset();
 
   // maps
   for (int iVectorOccupancyMapIndex = 0; iVectorOccupancyMapIndex < 4; iVectorOccupancyMapIndex++) {