[PWGCF] DptDpt - Tracking the ITS dead chips (#10237)

Co-authored-by: Victor <victor@cern.ch>

Author: victor-gonzalez

PWGCF/TwoParticleCorrelations/Tasks/perRunQc.cxx

@@ -8,16 +8,25 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-//
-// Minimal example to run this task:
-// o2-analysis-centrality-table -b --configuration json://configuration.json | o2-analysis-timestamp -b --configuration json://configuration.json | o2-analysis-event-selection -b --configuration json://configuration.json | o2-analysis-multiplicity-table -b --configuration json://configuration.json | o2-analysis-lf-zdcsp -b --configuration json://configuration.json --aod-file @input_data.txt --aod-writer-json OutputDirector.json
+
+/// \file perRunQc.cxx
+/// \brief basic per run check of the ITS dead chips and of the hadronic interaction rate
+/// \author victor.gonzalez.sebastian@gmail.com
 
 #include <array>
 #include <cmath>
+#include <unordered_map>
+#include <memory>
+#include <vector>
 
 #include "CCDB/BasicCCDBManager.h"
 #include "Common/CCDB/ctpRateFetcher.h"
 
+#include "DataFormatsParameters/AggregatedRunInfo.h"
+#include "DataFormatsITSMFT/NoiseMap.h" // missing include in TimeDeadMap.h
+#include "DataFormatsITSMFT/TimeDeadMap.h"
+#include "ITSMFTReconstruction/ChipMappingITS.h"
+
 #include "Framework/AnalysisDataModel.h"
 #include "Framework/AnalysisTask.h"
 #include "Framework/ASoAHelpers.h"
@@ -35,17 +44,22 @@ using BCsWithTimestamps = soa::Join<aod::BCs, aod::Timestamps>;
 
 namespace perrunqatask
 {
+static const int32_t nBCsPerOrbit = o2::constants::lhc::LHCMaxBunches;
 std::unordered_map<int, TH2*> gHadronicRate;
+std::unordered_map<int, std::vector<std::shared_ptr<TH2>>> gDeadChipsVsOrbitInLayer;
+std::unordered_map<int, std::shared_ptr<TH1>> gCollisionOrbitBefore;
+std::unordered_map<int, std::shared_ptr<TH1>> gCollisionOrbitAfter;
 
 TH2* gCurrentHadronicRate;
+std::shared_ptr<TH1> gCurrentCollisionOrbitBefore;
+std::shared_ptr<TH1> gCurrentCollisionOrbitAfter;
 } // namespace perrunqatask
 
 struct DptDptPerRunQa {
 
   Service<o2::ccdb::BasicCCDBManager> ccdb;
 
   int mRunNumber{-1};
-  uint64_t mSOR{0};
   double mMinSeconds{-1.};
 
   ctpRateFetcher mRateFetcher;
@@ -62,13 +76,63 @@ struct DptDptPerRunQa {
     mRunNumber = bc.runNumber();
     if (gHadronicRate.find(mRunNumber) == gHadronicRate.end()) {
       auto runDuration = ccdb->getRunDuration(mRunNumber);
-      mSOR = runDuration.first;
+      uint64_t mSOR = runDuration.first;
       mMinSeconds = std::floor(mSOR * 1.e-3);                /// round tsSOR to the highest integer lower than tsSOR
       double maxSec = std::ceil(runDuration.second * 1.e-3); /// round tsEOR to the lowest integer higher than tsEOR
       const AxisSpec axisSeconds{static_cast<int>(maxSec - mMinSeconds), 0, maxSec - mMinSeconds, "Seconds since SOR"};
       gHadronicRate[mRunNumber] = mHistos.add<TH2>(Form("%i/hadronicRate", mRunNumber), ";Time since SOR (s);Hadronic rate (kHz)", kTH2D, {{static_cast<int>((maxSec - mMinSeconds) / 20.f), 0, maxSec - mMinSeconds, "Seconds since SOR"}, {1010, 0., 1010.}}).get();
+
+      /* initializing the ITS chips dead map*/
+      /* inspired in DPG/Tasks/AOTEvent/eventSelectionQa.cxx */
+      auto runInfo = o2::parameters::AggregatedRunInfo::buildAggregatedRunInfo(o2::ccdb::BasicCCDBManager::instance(), mRunNumber);
+      int64_t tsSOR = runInfo.sor;
+      int64_t tsEOR = runInfo.eor;
+      o2::itsmft::TimeDeadMap* itsDeadMap = ccdb->getForTimeStamp<o2::itsmft::TimeDeadMap>("ITS/Calib/TimeDeadMap", (tsSOR + tsEOR) / 2);
+      auto itsDeadMapOrbits = itsDeadMap->getEvolvingMapKeys(); // roughly every second, ~350 TFs = 350x32 orbits
+      if (itsDeadMapOrbits.size() > 0) {
+        std::vector<double> itsDeadMapOrbitsDouble(itsDeadMapOrbits.begin(), itsDeadMapOrbits.end());
+        const AxisSpec axisItsDeadMapOrbits{itsDeadMapOrbitsDouble};
+        gDeadChipsVsOrbitInLayer[mRunNumber] = std::vector<std::shared_ptr<TH2>>(o2::itsmft::ChipMappingITS::NLayers, nullptr);
+        for (int layer = 0; layer < o2::itsmft::ChipMappingITS::NLayers; ++layer) {
+          int nChips = o2::itsmft::ChipMappingITS::getNChipsOnLayer(layer);
+          double idFirstChip = o2::itsmft::ChipMappingITS::getFirstChipsOnLayer(layer);
+          gDeadChipsVsOrbitInLayer[mRunNumber][layer] = mHistos.add<TH2>(TString::Format("%d/Before/hDeadChipsVsOrbitInLayer%d", mRunNumber, layer),
+                                                                         TString::Format("Dead chips in ITS layer %d, before;orbit; chip", layer),
+                                                                         kTH2C, {axisItsDeadMapOrbits, {nChips, idFirstChip, idFirstChip + nChips}});
+        }
+        gCollisionOrbitBefore[mRunNumber] = mHistos.add<TH1>(TString::Format("%d/Before/hCollisionOrbitB", mRunNumber), "Collision orbit before; orbit", kTH1I, {axisItsDeadMapOrbits});
+        gCollisionOrbitAfter[mRunNumber] = mHistos.add<TH1>(TString::Format("%d/After/hCollisionOrbitA", mRunNumber), "Collision orbit; orbit", kTH1I, {axisItsDeadMapOrbits});
+        LOGF(info, "Created the histograms");
+
+        std::vector<uint16_t> vClosest;
+        for (const auto& orbit : itsDeadMapOrbits) {
+          itsDeadMap->getMapAtOrbit(orbit, vClosest);
+          for (size_t iel = 0; iel < vClosest.size(); iel++) {
+            // dead chips are stored as ranges
+            // vClosest contains first and last chip ids in the range
+            // last chip id in the range is marked with 0x8000 bit set to 1
+            uint16_t w1 = vClosest[iel];
+            bool isLastInSequence = (w1 & 0x8000) == 0;
+            uint16_t w2 = isLastInSequence ? w1 + 1 : vClosest[iel + 1];
+            uint16_t chipId1 = w1 & 0x7FFF;
+            uint16_t chipId2 = w2 & 0x7FFF;
+            for (int chipId = chipId1; chipId < chipId2; chipId++) {
+              for (int layer = 0; layer < o2::itsmft::ChipMappingITS::NLayers; ++layer) {
+                gDeadChipsVsOrbitInLayer[mRunNumber][layer]->Fill(orbit, chipId, 1);
+              }
+            }
+          }
+        }
+        LOGF(info, "Initializing the current ones");
+        gCurrentCollisionOrbitBefore = gCollisionOrbitBefore[mRunNumber];
+        gCurrentCollisionOrbitAfter = gCollisionOrbitAfter[mRunNumber];
+      } else {
+        gCurrentCollisionOrbitBefore = nullptr;
+        gCurrentCollisionOrbitAfter = nullptr;
+      }
     }
     gCurrentHadronicRate = gHadronicRate[mRunNumber];
+    LOGF(info, "Getting out");
   }
 
   void init(o2::framework::InitContext&)
@@ -78,20 +142,24 @@ struct DptDptPerRunQa {
     ccdb->setFatalWhenNull(false);
   }
 
-  void process(soa::Join<aod::Collisions, aod::DptDptCFCollisionsInfo>::iterator const& collision, aod::BCsWithTimestamps const&)
+  void process(soa::Join<aod::Collisions, aod::EvSels, aod::DptDptCFCollisionsInfo>::iterator const& collision, aod::BCsWithTimestamps const&)
   {
     using namespace perrunqatask;
     using namespace analysis::dptdptfilter;
 
+    auto bc = collision.bc_as<aod::BCsWithTimestamps>();
+    initCCDB(bc);
+    int64_t orbit = bc.globalBC() / nBCsPerOrbit;
+    gCurrentCollisionOrbitBefore->Fill(orbit);
+
     if (!collision.collisionaccepted()) {
       return;
     }
 
-    auto bc = collision.bc_as<aod::BCsWithTimestamps>();
-    initCCDB(bc);
     double hadronicRate = mRateFetcher.fetch(ccdb.service, bc.timestamp(), mRunNumber, "T0VTX") * 1.e-3; //
     double seconds = bc.timestamp() * 1.e-3 - mMinSeconds;
     gCurrentHadronicRate->Fill(seconds, hadronicRate);
+    gCurrentCollisionOrbitAfter->Fill(orbit);
   }
 };