add treatment of TOF DRM Errors

noferini · noferini · commit 9fa912428d46 · 2026-02-23T15:04:56.000+01:00
diff --git a/DataFormats/Detectors/TOF/include/DataFormatsTOF/Diagnostic.h b/DataFormats/Detectors/TOF/include/DataFormatsTOF/Diagnostic.h
@@ -44,6 +44,13 @@ class Diagnostic
   uint32_t fillEmptyTOF(uint32_t frequency = 1) { return fill(1, frequency); }
   static ULong64_t getEmptyCrateKey(int crate);
   static ULong64_t getNoisyChannelKey(int channel);
+  static ULong64_t getDRMKey(int crate) { return 1000000 + crate * 1000; }
+  static ULong64_t getDRMerrorKey(int crate, int error) { return getDRMKey(crate) + error; }
+  uint32_t getFrequencyDRM(int crate) const { return getFrequency(getDRMKey(crate)); }
+  uint32_t getFrequencyDRMerror(int crate, int error) const { return getFrequency(getDRMerrorKey(crate, error)); }
+  uint32_t fillDRM(int crate, uint32_t frequency) { return fill(getDRMKey(crate), frequency); }
+  uint32_t fillDRMerror(int crate, int error, uint32_t frequency) { return fill(getDRMerrorKey(crate, error), frequency); }
+
   static ULong64_t getTRMKey(int crate, int trm);
   void print(bool longFormat = false) const;
   void clear() { mVector.clear(); }
diff --git a/Detectors/TOF/base/include/TOFBase/CalibTOFapi.h b/Detectors/TOF/base/include/TOFBase/CalibTOFapi.h
@@ -24,6 +24,8 @@
 #include "DataFormatsTOF/Diagnostic.h"
 #include "DataFormatsTOF/TOFFEElightInfo.h"
 
+class TH2F;
+
 namespace o2
 {
 namespace tof
@@ -38,10 +40,12 @@ class CalibTOFapi
   using CcdbApi = o2::ccdb::CcdbApi;
 
  public:
+  static o2::tof::Diagnostic doDRMerrCalibFromQCHisto(const TH2F* histo, const char* file_output_name);
+
   void resetDia();
   CalibTOFapi() = default;
   CalibTOFapi(const std::string url);
-  CalibTOFapi(long timestamp, o2::dataformats::CalibLHCphaseTOF* phase, o2::dataformats::CalibTimeSlewingParamTOF* slew, Diagnostic* dia = nullptr) : mTimeStamp(timestamp), mLHCphase(phase), mSlewParam(slew), mDiaFreq(dia) {}
+  CalibTOFapi(long timestamp, o2::dataformats::CalibLHCphaseTOF* phase, o2::dataformats::CalibTimeSlewingParamTOF* slew, Diagnostic* dia = nullptr, Diagnostic* diaDRM = nullptr) : mTimeStamp(timestamp), mLHCphase(phase), mSlewParam(slew), mDiaFreq(dia), mDiaDRMFreq(diaDRM) {}
   ~CalibTOFapi()
   {
     if (mLHCphase) {
@@ -53,6 +57,9 @@ class CalibTOFapi
     if (mDiaFreq) {
       //      delete mDiaFreq;
     }
+    if (mDiaDRMFreq) {
+      //      delete mDiaDRMFreq;
+    }
   }
 
   void setTimeStamp(long t)
@@ -69,6 +76,8 @@ class CalibTOFapi
   void readTimeSlewingParamFromFile(const char* filename);
   void readDiagnosticFrequencies();
   void loadDiagnosticFrequencies();
+  void readDiagnosticDRMFrequencies();
+  void loadDiagnosticDRMFrequencies();
   void readActiveMap();
   void loadActiveMap(TOFFEElightInfo* fee);
   void writeLHCphase(LhcPhase* phase, std::map<std::string, std::string> metadataLHCphase, uint64_t minTimeSTamp, uint64_t maxTimeStamp);
@@ -89,6 +98,8 @@ class CalibTOFapi
   void setLhcPhase(LhcPhase* obj) { mLHCphase = obj; }
   Diagnostic* getDiagnostic() { return mDiaFreq; }
   void setDiagnostic(Diagnostic* obj) { mDiaFreq = obj; }
+  Diagnostic* getDiagnosticDRM() { return mDiaDRMFreq; }
+  void setDiagnosticDRM(Diagnostic* obj) { mDiaDRMFreq = obj; }
 
   int getNoisyThreshold() const { return mNoisyThreshold; }
   void setNoisyThreshold(int val) { mNoisyThreshold = val; }
@@ -104,10 +115,11 @@ class CalibTOFapi
   bool checkTRMPolicy(int mask) const;
 
  private:
-  long mTimeStamp;                 ///< timeStamp for queries
-  LhcPhase* mLHCphase = nullptr;   ///< object for LHC phase
-  SlewParam* mSlewParam = nullptr; ///< object for timeslewing (containing info also for offset and problematic)
-  Diagnostic* mDiaFreq = nullptr;  ///< object for Diagnostic Frequency
+  long mTimeStamp;                   ///< timeStamp for queries
+  LhcPhase* mLHCphase = nullptr;     ///< object for LHC phase
+  SlewParam* mSlewParam = nullptr;   ///< object for timeslewing (containing info also for offset and problematic)
+  Diagnostic* mDiaFreq = nullptr;    ///< object for Diagnostic Frequency
+  Diagnostic* mDiaDRMFreq = nullptr; ///< object for Diagnostic Frequency
 
   // info from diagnostic
   int mNoisyThreshold = 1;                          ///< threshold to be noisy
diff --git a/Detectors/TOF/base/src/CalibTOFapi.cxx b/Detectors/TOF/base/src/CalibTOFapi.cxx
@@ -11,11 +11,40 @@
 
 #include "TOFBase/CalibTOFapi.h"
 #include <fairlogger/Logger.h> // for LOG
+#include <TH2F.h>
 
 using namespace o2::tof;
 
 ClassImp(o2::tof::CalibTOFapi);
 
+o2::tof::Diagnostic CalibTOFapi::doDRMerrCalibFromQCHisto(const TH2F* histo, const char* file_output_name)
+{
+  // this is a method which translate the QC output in qc/TOF/MO/TaskRaw/DRMCounter (TH2F) into a Diagnotic object for DRM (patter(crate, error), frequency)
+  // note that, differently from TRM errors, DRM ones are not stored in CTF by design (since very rare, as expected). Such an info is available only at the level of raw sync QC
+  o2::tof::Diagnostic drmDia;
+
+  for (int j = 1; j <= 72; j++) {
+    drmDia.fillDRM(j - 1, histo->GetBinContent(1, j));
+    for (int i = 2; i <= histo->GetXaxis()->GetNbins(); i++) {
+      if (histo->GetBinContent(1, j)) {
+        if (histo->GetBinContent(i, j) > 0) {
+          drmDia.fillDRMerror(j - 1, i - 1, histo->GetBinContent(i, j));
+        }
+      }
+    }
+  }
+
+  TFile* fo = new TFile(file_output_name, "RECREATE");
+  fo->WriteObjectAny(&drmDia, drmDia.Class_Name(), "ccdb_object");
+  fo->Close();
+  LOG(info) << "DRM error ccdb object created in " << file_output_name << " with this content";
+  drmDia.print(true);
+
+  return drmDia;
+}
+
+//______________________________________________________________________
+
 void CalibTOFapi::resetDia()
 {
   memset(mEmptyCrateProb, 0., Geo::kNCrate * 4);
@@ -116,11 +145,23 @@ void CalibTOFapi::readDiagnosticFrequencies()
 {
   auto& mgr = CcdbManager::instance();
   long timems = long(mTimeStamp) * 1000;
-  LOG(info) << "TOF get Diagnostics with timestamp (ms) = " << timems;
+  LOG(info) << "TOF get TRM Diagnostics with timestamp (ms) = " << timems;
   mDiaFreq = mgr.getForTimeStamp<Diagnostic>("TOF/Calib/Diagnostic", timems);
 
   loadDiagnosticFrequencies();
 }
+
+//______________________________________________________________________
+
+void CalibTOFapi::readDiagnosticDRMFrequencies()
+{
+  auto& mgr = CcdbManager::instance();
+  long timems = long(mTimeStamp) * 1000;
+  LOG(info) << "TOF get DRM Diagnostics with timestamp (ms) = " << timems;
+  mDiaFreq = mgr.getForTimeStamp<Diagnostic>("TOF/Calib/TRMerrors", timems);
+
+  loadDiagnosticDRMFrequencies();
+}
 //______________________________________________________________________
 
 void CalibTOFapi::loadDiagnosticFrequencies()
@@ -210,6 +251,13 @@ void CalibTOFapi::loadDiagnosticFrequencies()
 
 //______________________________________________________________________
 
+void CalibTOFapi::loadDiagnosticDRMFrequencies()
+{
+  mDiaDRMFreq->print();
+}
+
+//______________________________________________________________________
+
 void CalibTOFapi::writeLHCphase(LhcPhase* phase, std::map<std::string, std::string> metadataLHCphase, uint64_t minTimeStamp, uint64_t maxTimeStamp)
 {
 
diff --git a/Detectors/TOF/prototyping/CMakeLists.txt b/Detectors/TOF/prototyping/CMakeLists.txt
@@ -32,6 +32,16 @@ o2_add_test_root_macro(findLabels.C
                                              O2::TOFBase
                        LABELS tof)
 
+o2_add_test_root_macro(makeDRMobj_tof.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF
+                                             O2::TOFBase
+                       LABELS tof)
+
+o2_add_test_root_macro(checkDRMobj_tof.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF
+                                             O2::TOFBase
+                       LABELS tof)
+
 o2_add_test_root_macro(findTOFclusterFromLabel.C
                        PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF
                                              O2::SimulationDataFormat
@@ -59,3 +69,8 @@ o2_add_test_root_macro(macroEvTime.C
                        PUBLIC_LINK_LIBRARIES O2::TOFBase
                                              O2::TOFReconstruction
                        LABELS tof)
+
+install(
+  FILES makeDRMobj_tof.C
+  checkDRMobj_tof.C
+  DESTINATION share/macro/)
diff --git a/Detectors/TOF/prototyping/checkDRMobj_tof.C b/Detectors/TOF/prototyping/checkDRMobj_tof.C
@@ -0,0 +1,41 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// 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.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include "TFile.h"
+#include "TH2F.h"
+#include "TOFBase/CalibTOFapi.h"
+#endif
+
+void checkDRMobj_tof(const char* fname = "ccdb.root")
+{
+  TFile* f = new TFile(fname);
+
+  TH2F* hErrors = new TH2F("hDRMerrors", ";error code; frequency", 30, 0, 30, 72, 0, 72);
+
+  o2::tof::Diagnostic* drmDia = (o2::tof::Diagnostic*)f->Get("ccdb_object");
+
+  for (int j = 1; j <= 72; j++) {
+    uint32_t patternRDH = o2::tof::Diagnostic::getDRMKey(j - 1);
+    for (int i = 1; i <= hErrors->GetXaxis()->GetNbins(); i++) {
+      uint32_t pattern = o2::tof::Diagnostic::getDRMerrorKey(j - 1, i - 1);
+      if (drmDia->getFrequency(patternRDH)) {
+        hErrors->SetBinContent(i, j, drmDia->getFrequency(pattern) * 1. / drmDia->getFrequency(patternRDH));
+      }
+    }
+  }
+
+  TCanvas* c = new TCanvas();
+  c->cd(1);
+  hErrors->Draw("colz");
+
+  drmDia->print(true);
+}
diff --git a/Detectors/TOF/prototyping/makeDRMobj_tof.C b/Detectors/TOF/prototyping/makeDRMobj_tof.C
@@ -0,0 +1,39 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// 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.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include "TFile.h"
+#include "TH2F.h"
+#include "TOFBase/CalibTOFapi.h"
+#endif
+
+void makeDRMobj_tof(const char* inputfile = "TObject_1764607157510.root", bool dummy = false)
+{
+  if (dummy) {
+    o2::tof::Diagnostic drmDia;
+    for (int j = 1; j <= 72; j++) {
+      drmDia.fill(o2::tof::Diagnostic::getDRMKey(j - 1));
+    }
+
+    TFile* fo = new TFile("ccdb.root", "RECREATE");
+    fo->WriteObjectAny(&drmDia, drmDia.Class_Name(), "ccdb_object");
+    fo->Close();
+
+    return;
+  }
+
+  TFile* f = new TFile(inputfile);
+  TH2F* h = (TH2F*)f->Get("ccdb_object");
+
+  o2::tof::Diagnostic drmDia;
+
+  drmDia = o2::tof::CalibTOFapi::doDRMerrCalibFromQCHisto(h, "ccdb.root");
+}
diff --git a/Steer/DigitizerWorkflow/src/TOFDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TOFDigitizerSpec.cxx
@@ -77,6 +77,10 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
       mUpdateCCDB = true;
       return;
     }
+    if (matcher == ConcreteDataMatcher("TOF", "DiagnosticDRM", 0)) {
+      mUpdateCCDB = true;
+      return;
+    }
     if (matcher == ConcreteDataMatcher("TOF", "LHCphaseCal", 0)) {
       mUpdateCCDB = true;
       return;
@@ -127,6 +131,7 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
       const auto lhcPhaseIn = pc.inputs().get<o2::dataformats::CalibLHCphaseTOF*>("tofccdbLHCphase");
       const auto channelCalibIn = pc.inputs().get<o2::dataformats::CalibTimeSlewingParamTOF*>("tofccdbChannelCalib");
       const auto diagnosticIn = pc.inputs().get<o2::tof::Diagnostic*>("tofccdbDia");
+      const auto diagnosticDRM = pc.inputs().get<o2::tof::Diagnostic*>("tofccdbDrm");
       const auto statusIn = pc.inputs().get<o2::tof::TOFFEElightInfo*>("tofccdbStatus");
       const auto tofParams = pc.inputs().get<o2::tof::ParameterCollection*>("tofccdbParams");
 
@@ -165,10 +170,12 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
         o2::dataformats::CalibLHCphaseTOF* lhcPhase = new o2::dataformats::CalibLHCphaseTOF(std::move(*lhcPhaseIn));
         o2::dataformats::CalibTimeSlewingParamTOF* channelCalib = new o2::dataformats::CalibTimeSlewingParamTOF(std::move(*channelCalibIn));
         o2::tof::Diagnostic* diagnostic = new o2::tof::Diagnostic(std::move(*diagnosticIn));
+        o2::tof::Diagnostic* diagnosticDRMerr = new o2::tof::Diagnostic(std::move(*diagnosticDRM));
         o2::tof::TOFFEElightInfo* status = new o2::tof::TOFFEElightInfo(std::move(*statusIn));
 
-        mCalibApi = new o2::tof::CalibTOFapi(long(0), lhcPhase, channelCalib, diagnostic);
+        mCalibApi = new o2::tof::CalibTOFapi(long(0), lhcPhase, channelCalib, diagnostic, diagnosticDRMerr);
         mCalibApi->loadDiagnosticFrequencies();
+        mCalibApi->loadDiagnosticDRMFrequencies();
         mCalibApi->loadActiveMap(status);
         mUpdateCCDB = false;
       } else { // update if necessary
@@ -178,9 +185,11 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
           o2::dataformats::CalibLHCphaseTOF* lhcPhase = new o2::dataformats::CalibLHCphaseTOF(*lhcPhaseIn);
           o2::dataformats::CalibTimeSlewingParamTOF* channelCalib = new o2::dataformats::CalibTimeSlewingParamTOF(*channelCalibIn);
           o2::tof::Diagnostic* diagnostic = new o2::tof::Diagnostic(std::move(*diagnosticIn));
+          o2::tof::Diagnostic* diagnosticDRMerr = new o2::tof::Diagnostic(std::move(*diagnosticDRM));
           o2::tof::TOFFEElightInfo* status = new o2::tof::TOFFEElightInfo(std::move(*statusIn));
           mCalibApi = new o2::tof::CalibTOFapi(long(0), lhcPhase, channelCalib, diagnostic);
           mCalibApi->loadDiagnosticFrequencies();
+          mCalibApi->loadDiagnosticDRMFrequencies();
           mCalibApi->loadActiveMap(status);
           mUpdateCCDB = false;
         } else {
@@ -205,6 +214,7 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
       if (mUseCCDB) {
         mCalibApi->setURL(mCCDBurl);
         mCalibApi->readDiagnosticFrequencies();
+        mCalibApi->readDiagnosticDRMFrequencies();
         mCalibApi->readLHCphase();
         mCalibApi->readActiveMap();
         mCalibApi->readTimeSlewingParam();
@@ -319,6 +329,7 @@ DataProcessorSpec getTOFDigitizerSpec(int channel, bool useCCDB, bool mctruth, s
   if (useCCDB) {
     inputs.emplace_back("tofccdbStatus", "TOF", "StatusTOF", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/FEELIGHT"));
     inputs.emplace_back("tofccdbDia", "TOF", "DiagnosticCal", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/Diagnostic"));
+    inputs.emplace_back("tofccdbDrm", "TOF", "DiagnosticDRM", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/DRMerrors"));
     inputs.emplace_back("tofccdbLHCphase", "TOF", "LHCphaseCal", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/LHCphase"));
     inputs.emplace_back("tofccdbChannelCalib", "TOF", "ChannelCalibCal", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/ChannelCalib"));
     inputs.emplace_back("tofccdbParams", "TOF", "parameters", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/Params"));
