[MFT-Module] Updating the MFT digit QC Task (#588)

* Adding histograms - chip maps, pixel maps, std dev per chip

* Added hot pixel producer

* Added hot pixel producer

* Publishing all pixel hit maps

* Change in folder strucutre for pixel maps to be able to publish them

* Updated folder structer for histogams and deleted the sorting algorithm.

* Forgot to delete a counter from Digit Task.

* Clang format.

* Adjusting cycle length and sampling fraction.

* Publishing only pixel hit maps corresponding to given FLP.

* Moving overview histograms into the chip hit map folder.

* Changing the MO for the checker to correspond to the new location of the chip hit index histogram.

Author: tomas-herman

Modules/Example/o2-qc-example-analysis-derived.json

@@ -38,10 +38,12 @@ add_root_dictionary(QcMFT
 
 set(EXE_SRCS 
      src/runDigitsRootFileReaderMFT.cxx 
+     src/runDigitsHotPixelRootFileReaderMFT.cxx 
      src/runClustersRootFileReaderMFT.cxx
      src/runTracksRootFileReaderMFT.cxx)
 set(EXE_NAMES 
      o2-qc-run-digits-root-file-reader-mft
+     o2-qc-run-digits-hot-pixel-root-file-reader-mft
      o2-qc-run-clusters-root-file-reader-mft
      o2-qc-run-tracks-root-file-reader-mft)
 
@@ -56,6 +58,7 @@ endforeach()
 
 install(
   TARGETS o2-qc-run-digits-root-file-reader-mft
+          o2-qc-run-digits-hot-pixel-root-file-reader-mft
           o2-qc-run-clusters-root-file-reader-mft
           o2-qc-run-tracks-root-file-reader-mft
   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}

Modules/Example/o2-qc-example-analysis-direct.json

@@ -28,15 +28,15 @@
         "className": "o2::quality_control_modules::mft::BasicDigitQcTask",
         "moduleName": "QcMFT",
         "detectorName": "MFT",
-        "cycleDurationSeconds": "10",
+        "cycleDurationSeconds": "60",
         "maxNumberCycles": "-1",
         "dataSource_comment": "The other type of dataSource is \"direct\", see basic-no-sampling.json.",
         "dataSource": {
           "type": "dataSamplingPolicy",
           "name": "mft-digits"
         },
         "taskParameters": {
-          "myOwnKey": "myOwnValue"
+          "FLP": "1"
         },
         "location": "remote"
       }
@@ -47,7 +47,7 @@
         "dataSource": [{
           "type": "Task",
           "name": "BasicDigitQcTask",
-          "MOs": ["mMFT_chip_index_H"]
+          "MOs": ["ChipHitMaps/mMFT_chip_index_H"]
         }],
         "className": "o2::quality_control_modules::mft::BasicDigitQcCheck",
         "moduleName": "QcMFT",
@@ -65,7 +65,7 @@
       "samplingConditions": [
         {
           "condition": "random",
-          "fraction": "0.1",
+          "fraction": "0.2",
           "seed": "1234"
         }
       ],

Modules/MFT/CMakeLists.txt

@@ -12,6 +12,7 @@
 /// \file   BasicDigitQcTask.h
 /// \author Tomas Herman
 /// \author Guillermo Contreras
+/// \author Katarina Krizkova Gajdosova
 ///
 
 #ifndef QC_MODULE_MFT_MFTBasicDIGITQCTASK_H
@@ -20,6 +21,7 @@
 // ROOT
 #include <TCanvas.h>
 #include <TH1.h>
+#include <TH2.h>
 // Quality Control
 #include "QualityControl/TaskInterface.h"
 
@@ -50,7 +52,78 @@ class BasicDigitQcTask final : public TaskInterface
   void reset() override;
 
  private:
+  //  variables
+  const double gPixelHitMapsMaxBinX = 1023.5;
+  const double gPixelHitMapsMaxBinY = 511.5;
+  const double gPixelHitMapsMinBin = -0.5;
+  const int gPixelHitMapsBinWidth = 8;
+
+  const int nhitmaps = 20;
+  const int nchip = 936;
+
+  int FLP;
+  int minChipID;
+  int maxChipID;
+
+  int half[936] = { 0 };
+  int disk[936] = { 0 };
+  int face[936] = { 0 };
+  int zone[936] = { 0 };
+  int ladder[936] = { 0 };
+  int sensor[936] = { 0 };
+  int transID[936] = { 0 };
+  int layer[936] = { 0 };
+  double x[936] = { 0 };
+  double y[936] = { 0 };
+  double z[936] = { 0 };
+  double binx[936] = { 0 };
+  double biny[936] = { 0 };
+
+  //  bin numbers for chip hit maps
+  double binsChipHitMaps[20][6] = {
+    // half0
+    { 12, -10, 10, 4, -12, 0 }, // disk0, face 0
+    { 12, -10, 10, 4, -12, 0 }, // disk0, face 1
+
+    { 12, -10, 10, 4, -12, 0 },
+    { 12, -10, 10, 4, -12, 0 },
+
+    { 13, -11, 10, 4, -12, 0 },
+    { 13, -10, 11, 4, -12, 0 },
+
+    { 16, -13, 14, 5, -15, 0 },
+    { 16, -14, 13, 5, -15, 0 },
+
+    { 17, -14, 14, 5, -15, 0 },
+    { 17, -14, 14, 5, -15, 0 },
+
+    // half1
+    { 12, -10, 10, 4, 0, 12 },
+    { 12, -10, 10, 4, 0, 12 },
+
+    { 12, -10, 10, 4, 0, 12 },
+    { 12, -10, 10, 4, 0, 12 },
+
+    { 13, -10, 11, 4, 0, 12 },
+    { 13, -11, 10, 4, 0, 12 },
+
+    { 16, -14, 13, 5, 0, 15 },
+    { 16, -13, 14, 5, 0, 15 },
+
+    { 17, -14, 14, 5, 0, 15 },
+    { 17, -14, 14, 5, 0, 15 },
+  };
+
   std::unique_ptr<TH1F> mMFT_chip_index_H = nullptr;
+  std::unique_ptr<TH1F> mMFT_chip_std_dev_H = nullptr;
+
+  std::vector<std::unique_ptr<TH2F>> mMFTChipHitMap;
+  std::vector<std::unique_ptr<TH2F>> mMFTPixelHitMap;
+
+  //  functions
+  void readTable();
+  void getChipName(TString& FolderName, TString& HistogramName, int iHitMap);
+  void getPixelName(TString& FolderName, TString& HistogramName, int iChipID);
 };
 
 } // namespace o2::quality_control_modules::mft

Modules/MFT/basic-digit-qc-task.json

@@ -36,7 +36,7 @@ Quality BasicDigitQcCheck::check(std::map<std::string, std::shared_ptr<MonitorOb
   for (auto& [moName, mo] : *moMap) {
 
     (void)moName;
-    if (mo->getName() == "mMFT_chip_index_H") {
+    if (mo->getName() == "ChipHitMaps/mMFT_chip_index_H") {
       auto* h = dynamic_cast<TH1F*>(mo->getObject());
       result = Quality::Good;
 
@@ -53,7 +53,7 @@ std::string BasicDigitQcCheck::getAcceptedType() { return "TH1"; }
 
 void BasicDigitQcCheck::beautify(std::shared_ptr<MonitorObject> mo, Quality checkResult)
 {
-  if (mo->getName() == "mMFT_chip_index_H") {
+  if (mo->getName() == "ChipHitMaps/mMFT_chip_index_H") {
     auto* h = dynamic_cast<TH1F*>(mo->getObject());
 
     if (checkResult == Quality::Good) {

Modules/MFT/include/MFT/BasicDigitQcTask.h

@@ -12,17 +12,21 @@
 /// \file   BasicDigitQcTask.cxx
 /// \author Tomas Herman
 /// \author Guillermo Contreras
+/// \author Katarina Krizkova Gajdosova
 ///
 
 // ROOT
 #include <TCanvas.h>
 #include <TH1.h>
+#include <TH2.h>
 // O2
 #include <DataFormatsITSMFT/Digit.h>
 #include <Framework/InputRecord.h>
 // Quality Control
 #include "QualityControl/QcInfoLogger.h"
 #include "MFT/BasicDigitQcTask.h"
+// C++
+#include <fstream>
 
 namespace o2::quality_control_modules::mft
 {
@@ -39,19 +43,78 @@ void BasicDigitQcTask::initialize(o2::framework::InitContext& /*ctx*/)
   ILOG(Info, Support) << "initialize BasicDigitQcTask" << ENDM; // QcInfoLogger is used. FairMQ logs will go to there as well.
 
   // this is how to get access to custom parameters defined in the config file at qc.tasks.<task_name>.taskParameters
-  if (auto param = mCustomParameters.find("myOwnKey"); param != mCustomParameters.end()) {
+  if (auto param = mCustomParameters.find("FLP"); param != mCustomParameters.end()) {
     ILOG(Info, Support) << "Custom parameter - myOwnKey: " << param->second << ENDM;
+    FLP = stoi(param->second);
+    minChipID = (FLP - 1) * nchip / 4;
+    maxChipID = FLP * nchip / 4;
   }
 
-  mMFT_chip_index_H = std::make_unique<TH1F>("mMFT_chip_index_H", "mMFT_chip_index_H", 936, -0.5, 935.5);
+  //  -------------------
+  mMFT_chip_index_H = std::make_unique<TH1F>("ChipHitMaps/mMFT_chip_index_H", "mMFT_chip_index_H", 936, -0.5, 935.5);
   getObjectsManager()->startPublishing(mMFT_chip_index_H.get());
   getObjectsManager()->addMetadata(mMFT_chip_index_H->GetName(), "custom", "34");
+
+  mMFT_chip_std_dev_H = std::make_unique<TH1F>("ChipHitMaps/mMFT_chip_std_dev_H", "mMFT_chip_std_dev_H", 936, -0.5, 935.5);
+  getObjectsManager()->startPublishing(mMFT_chip_std_dev_H.get());
+  getObjectsManager()->addMetadata(mMFT_chip_std_dev_H->GetName(), "custom", "34");
+
+  //==============================================
+  //  chip hit maps
+  readTable();
+  for (int iHitMap = 0; iHitMap < nhitmaps; iHitMap++) {
+    //  generate folder and histogram name using the mapping table
+    TString FolderName = "";
+    TString HistogramName = "";
+    getChipName(FolderName, HistogramName, iHitMap);
+
+    auto chiphitmap = std::make_unique<TH2F>(
+      FolderName, HistogramName,
+      binsChipHitMaps[iHitMap][0], binsChipHitMaps[iHitMap][1], binsChipHitMaps[iHitMap][2],
+      binsChipHitMaps[iHitMap][3], binsChipHitMaps[iHitMap][4], binsChipHitMaps[iHitMap][5]);
+    chiphitmap->SetStats(0);
+    mMFTChipHitMap.push_back(std::move(chiphitmap));
+    getObjectsManager()->startPublishing(mMFTChipHitMap[iHitMap].get());
+    getObjectsManager()->addMetadata(mMFTChipHitMap[iHitMap]->GetName(), "custom", "34");
+  }
+
+  //==============================================
+  //  pixel hit maps
+  for (int iChipID = 0; iChipID < nchip; iChipID++) {
+    //  generate folder and histogram name using the mapping table
+    TString FolderName = "";
+    TString HistogramName = "";
+    getPixelName(FolderName, HistogramName, iChipID);
+
+    //  create pixel hit map
+    auto pxlhitmap = std::make_unique<TH2F>(
+      FolderName, HistogramName,
+      gPixelHitMapsMaxBinX / gPixelHitMapsBinWidth, gPixelHitMapsMinBin, gPixelHitMapsMaxBinX,
+      gPixelHitMapsMaxBinY / gPixelHitMapsBinWidth, gPixelHitMapsMinBin, gPixelHitMapsMaxBinY);
+    pxlhitmap->SetStats(0);
+    mMFTPixelHitMap.push_back(std::move(pxlhitmap));
+
+    if ((iChipID >= minChipID) && (iChipID < maxChipID)) {
+      getObjectsManager()->startPublishing(mMFTPixelHitMap[iChipID].get());
+      getObjectsManager()->addMetadata(mMFTPixelHitMap[iChipID]->GetName(), "custom", "34");
+    }
+  }
 }
 
 void BasicDigitQcTask::startOfActivity(Activity& /*activity*/)
 {
   ILOG(Info, Support) << "startOfActivity" << ENDM;
+
   mMFT_chip_index_H->Reset();
+  mMFT_chip_std_dev_H->Reset();
+
+  for (int iHitMap = 0; iHitMap < nhitmaps; iHitMap++) {
+    mMFTChipHitMap[iHitMap]->Reset();
+  }
+
+  for (int iChipID = 0; iChipID < nchip; iChipID++) {
+    mMFTPixelHitMap[iChipID]->Reset();
+  }
 }
 
 void BasicDigitQcTask::startOfCycle()
@@ -65,9 +128,22 @@ void BasicDigitQcTask::monitorData(o2::framework::ProcessingContext& ctx)
   const auto digits = ctx.inputs().get<gsl::span<o2::itsmft::Digit>>("randomdigit");
   if (digits.size() < 1)
     return;
+
   // fill the histograms
   for (auto& one_digit : digits) {
-    mMFT_chip_index_H->Fill(one_digit.getChipIndex());
+    int chipIndex = one_digit.getChipIndex();
+
+    //  fill pixel hit maps
+    mMFTPixelHitMap[chipIndex]->Fill(one_digit.getColumn(), one_digit.getRow());
+    // fill number of entries and standard dev for all chips
+    mMFT_chip_index_H->SetBinContent(chipIndex, mMFTPixelHitMap[chipIndex]->GetEntries());
+    mMFT_chip_std_dev_H->SetBinContent(chipIndex, mMFTPixelHitMap[chipIndex]->GetStdDev(1));
+  }
+
+  //  fill the chip hit maps
+  for (int iChipID = 0; iChipID < nchip; iChipID++) {
+    int nEntries = mMFTPixelHitMap[iChipID]->GetEntries();
+    mMFTChipHitMap[layer[iChipID] + half[iChipID] * 10]->SetBinContent(binx[iChipID], biny[iChipID], nEntries);
   }
 }
 
@@ -84,9 +160,78 @@ void BasicDigitQcTask::endOfActivity(Activity& /*activity*/)
 void BasicDigitQcTask::reset()
 {
   // clean all the monitor objects here
-
   ILOG(Info, Support) << "Resetting the histogram" << ENDM;
+
   mMFT_chip_index_H->Reset();
+  mMFT_chip_std_dev_H->Reset();
+
+  for (int iHitMap = 0; iHitMap < nhitmaps; iHitMap++) {
+    mMFTChipHitMap[iHitMap]->Reset();
+  }
+
+  for (int iChipID = 0; iChipID < nchip; iChipID++) {
+    mMFTPixelHitMap[iChipID]->Reset();
+  }
+}
+
+void BasicDigitQcTask::getChipName(TString& FolderName, TString& HistogramName, int iHitMap)
+{
+  FolderName = Form("ChipHitMaps/Half_%d/Disk_%d/Face_%d/mMFTChipHitMap",
+                    int(iHitMap / 10), int((iHitMap % 10) / 2), (iHitMap % 10) % 2);
+
+  HistogramName = Form("h%d-d%d-f%d;x (cm);y (cm)",
+                       int(iHitMap / 10), int((iHitMap % 10) / 2), (iHitMap % 10) % 2);
+}
+
+void BasicDigitQcTask::getPixelName(TString& FolderName, TString& HistogramName, int iChipID)
+{
+  FolderName = Form("PixelHitMaps/Half_%d/Disk_%d/Face_%d/mMFTPixelHitMap-z%d-l%d-s%d-tr%d",
+                    half[iChipID], disk[iChipID], face[iChipID], zone[iChipID], ladder[iChipID], sensor[iChipID], transID[iChipID]);
+
+  HistogramName = Form("h%d-d%d-f%d-z%d-l%d-s%d-tr%d",
+                       half[iChipID], disk[iChipID], face[iChipID], zone[iChipID], ladder[iChipID], sensor[iChipID], transID[iChipID]);
+}
+
+void BasicDigitQcTask::readTable()
+{
+  //const int nchip = 936;
+
+  //  reset arrays
+  for (int i = 0; i < nchip; i++) {
+    half[i] = 0;
+    disk[i] = 0;
+    face[i] = 0;
+    zone[i] = 0;
+    ladder[i] = 0;
+    sensor[i] = 0;
+    transID[i] = 0;
+    layer[i] = 0;
+    x[i] = 0;
+    y[i] = 0;
+    z[i] = 0;
+    binx[i] = 0;
+    biny[i] = 0;
+  }
+
+  // read file
+  std::ifstream read_table;
+  read_table.open("./table_file_binidx.txt");
+  for (int i = 0; i < nchip; ++i) {
+    read_table >> half[i];
+    read_table >> disk[i];
+    read_table >> face[i];
+    read_table >> zone[i];
+    read_table >> ladder[i];
+    read_table >> sensor[i];
+    read_table >> transID[i];
+    read_table >> layer[i];
+    read_table >> x[i];
+    read_table >> y[i];
+    read_table >> z[i];
+    read_table >> binx[i];
+    read_table >> biny[i];
+  }
+  read_table.close();
 }
 
 } // namespace o2::quality_control_modules::mft