OufOfBcCheck for FEE modules

Modules/FIT/FV0/CMakeLists.txt

@@ -9,7 +9,8 @@ target_sources(O2QcFV0 PRIVATE src/TH1ReductorLaser.cxx
                                src/CFDEffCheck.cxx
                                src/PostProcTask.cxx
                                src/OutOfBunchCollCheck.cxx
-                               src/TriggersSwVsTcmCheck.cxx)
+                               src/TriggersSwVsTcmCheck.cxx
+                               src/OutOfBunchCollFeeModulesCheck.cxx)
 
 target_include_directories(
   O2QcFV0
@@ -37,6 +38,7 @@ add_root_dictionary(O2QcFV0
           include/FV0/OutOfBunchCollCheck.h
           include/FV0/GenericCheck.h
           include/FV0/TriggersSwVsTcmCheck.h
+          include/FV0/OutOfBunchCollFeeModulesCheck.h
   LINKDEF include/FV0/LinkDef.h)
 
 install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/FV0

Modules/FIT/FV0/include/FV0/LinkDef.h

@@ -9,6 +9,7 @@
 #pragma link C++ class o2::quality_control_modules::fv0::OutOfBunchCollCheck + ;
 #pragma link C++ class o2::quality_control_modules::fv0::GenericCheck + ;
 #pragma link C++ class o2::quality_control_modules::fv0::TriggersSwVsTcmCheck + ;
+#pragma link C++ class o2::quality_control_modules::fv0::OutOfBunchCollFeeModulesCheck + ;
 //#pragma link C++ class o2::quality_control_modules::fv0::CalibrationTask + ;
 //#pragma link C++ class o2::quality_control_modules::fv0::ChannelTimeCalibrationCheck + ;
 

Modules/FIT/FV0/include/FV0/OutOfBunchCollFeeModulesCheck.h

@@ -0,0 +1,52 @@
+// Copyright 2023 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.
+
+///
+/// \file   OutOfBunchCollFeeModulesCheck.h
+/// \author Dawid Skora dawid.mateusz.skora@cern.ch
+///
+
+#ifndef QC_MODULE_FV0_OUTOFBUNCHCOLLFEEMODULESCHECK_H
+#define QC_MODULE_FV0_OUTOFBUNCHCOLLFEEMODULESCHECK_H
+
+#include "QualityControl/CheckInterface.h"
+
+#include "FV0Base/Constants.h"
+#include "CommonConstants/LHCConstants.h"
+
+#include <string>
+
+namespace o2::quality_control_modules::fv0
+{
+
+class OutOfBunchCollFeeModulesCheck : public o2::quality_control::checker::CheckInterface
+{
+ public:
+  OutOfBunchCollFeeModulesCheck() = default;
+  ~OutOfBunchCollFeeModulesCheck() override = default;
+
+  void configure() override;
+  Quality check(std::map<std::string, std::shared_ptr<MonitorObject>>* moMap) override;
+  void beautify(std::shared_ptr<MonitorObject> mo, Quality checkResult = Quality::Null) override;
+  std::string getAcceptedType() override;
+
+  ClassDefOverride(OutOfBunchCollFeeModulesCheck, 2);
+
+ private:
+  float mThreshWarning;
+  float mThreshError;
+  float mFractionOutOfBunchColl = 0;
+  constexpr static std::size_t sBCperOrbit = o2::constants::lhc::LHCMaxBunches;
+};
+
+} // namespace o2::quality_control_modules::fv0
+
+#endif // QC_MODULE_FV0_OUTOFBUNCHCOLLFEEMODULESCHECK_H

Modules/FIT/FV0/include/FV0/PostProcTask.h

@@ -29,6 +29,8 @@
 #include <TH2.h>
 #include <TCanvas.h>
 #include <TGraph.h>
+#include <regex>
+#include <array>
 
 class TH1F;
 class TCanvas;
@@ -87,9 +89,15 @@ class PostProcTask final : public quality_control::postprocessing::PostProcessin
   // if storage size matters it can be replaced with TH1
   // and TH2 can be created based on it on the fly, but only TH1 would be stored
   std::unique_ptr<TH2F> mHistBcPattern;
+  std::unique_ptr<TH2F> mHistBcPatternFee;
   std::unique_ptr<TH2F> mHistBcTrgOutOfBunchColl;
+  std::unique_ptr<TH2F> mHistBcFeeOutOfBunchColl;
 
+  uint8_t mTCMhash;
+  std::array<uint8_t, sNCHANNELS_FV0_PLUSREF> mChID2PMhash; // map chID->hashed PM value
+  std::map<uint8_t, bool> mMapPMhash2isInner;
   std::map<unsigned int, TH1D*> mMapTrgHistBC;
+  std::map<std::string, uint8_t> mMapFEE2hash;
 };
 
 } // namespace o2::quality_control_modules::fv0

Modules/FIT/FV0/src/OutOfBunchCollFeeModulesCheck.cxx

@@ -0,0 +1,160 @@
+// Copyright 2023 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.
+
+///
+/// \file   OutOfBunchCollFeeModulesCheck.cxx
+/// \author Dawid Skora dawid.mateusz.skora@cern.ch
+///
+
+#include "FV0/OutOfBunchCollFeeModulesCheck.h"
+#include "QualityControl/MonitorObject.h"
+#include "QualityControl/Quality.h"
+#include "QualityControl/QcInfoLogger.h"
+#include "DataFormatsParameters/GRPLHCIFData.h"
+
+// ROOT
+#include <TH1.h>
+#include <TH2.h>
+#include <TPaveText.h>
+#include <TLine.h>
+#include <TList.h>
+
+#include <map>
+#include <DataFormatsQualityControl/FlagReasons.h>
+
+using namespace std;
+using namespace o2::quality_control;
+
+namespace o2::quality_control_modules::fv0
+{
+
+void OutOfBunchCollFeeModulesCheck::configure()
+{
+  if (auto param = mCustomParameters.find("thresholdWarning"); param != mCustomParameters.end()) {
+    mThreshWarning = stof(param->second);
+    ILOG(Debug, Support) << "configure() : using thresholdWarning = " << mThreshWarning << ENDM;
+  } else {
+    mThreshWarning = 1e-3;
+    ILOG(Debug, Support) << "configure() : using default thresholdWarning = " << mThreshWarning << ENDM;
+  }
+
+  if (auto param = mCustomParameters.find("thresholdError"); param != mCustomParameters.end()) {
+    mThreshError = stof(param->second);
+    ILOG(Debug, Support) << "configure() : using thresholdError = " << mThreshError << ENDM;
+  } else {
+    mThreshError = 0.1;
+    ILOG(Debug, Support) << "configure() : using default thresholdError = " << mThreshError << ENDM;
+  }
+
+  if (mThreshError < mThreshWarning) {
+    ILOG(Debug, Support) << "thresholdError lower than thresholdWarning. Swaping values." << ENDM;
+    std::swap(mThreshError, mThreshWarning);
+  }
+}
+
+Quality OutOfBunchCollFeeModulesCheck::check(std::map<std::string, std::shared_ptr<MonitorObject>>* moMap)
+{
+  Quality result = Quality::Null;
+
+  for (auto& [moName, mo] : *moMap) {
+    (void)moName;
+    if (mo->getName() == "OutOfBunchColl_BCvsFeeModules") {
+      auto* histogram = dynamic_cast<TH2*>(mo->getObject());
+
+      if (!histogram) {
+        ILOG(Error, Support) << "check(): MO " << mo->getName() << " not found" << ENDM;
+        result.addReason(FlagReasonFactory::Unknown(), "MO " + mo->getName() + " not found");
+        result.set(Quality::Null);
+        return result;
+      }
+
+      std::vector<float> allCollPerFeeModule(mo->getMetadataMap().size() + 1, 0);
+      for (auto metainfo : mo->getMetadataMap()) {
+        int bin = 0;
+        float value = 0;
+        try {
+          bin = std::stoi(metainfo.first);
+          value = std::stof(metainfo.second);
+          allCollPerFeeModule[bin] = value;
+        } catch (const std::invalid_argument& e) {
+          ILOG(Warning, Support) << "Could not get value for key " << metainfo.first << ENDM;
+          continue;
+        }
+      }
+
+      // Calculate out-of-bunch-coll fraction for Fee Modules
+      for (int binY = 1; binY <= histogram->GetNbinsY(); binY++) {
+        auto outOfBcCollisions = histogram->Integral(1, sBCperOrbit, binY, binY);
+        float fraction = 0;
+        if (allCollPerFeeModule[binY]) {
+          fraction = outOfBcCollisions / allCollPerFeeModule[binY];
+        }
+
+        if (fraction > mFractionOutOfBunchColl) {
+          mFractionOutOfBunchColl = fraction;
+        }
+      }
+
+      // Check the biggest fraction of out-of-bunch-coll
+      if (mFractionOutOfBunchColl > mThreshError) {
+        result.set(Quality::Bad);
+        result.addReason(FlagReasonFactory::Unknown(),
+                         Form("Fraction of out of bunch collisions (%.2e) is above \"Error\" threshold (%.2e)",
+                              mFractionOutOfBunchColl, mThreshError));
+      } else if (mFractionOutOfBunchColl > mThreshWarning) {
+        result.set(Quality::Medium);
+        result.addReason(FlagReasonFactory::Unknown(),
+                         Form("Fraction of out of bunch collisions (%.2e) is above \"Warning\" threshold (%.2e)",
+                              mFractionOutOfBunchColl, mThreshWarning));
+      } else {
+        result.set(Quality::Good);
+      }
+    }
+  }
+
+  return result;
+}
+
+std::string OutOfBunchCollFeeModulesCheck::getAcceptedType() { return "TH2"; }
+
+void OutOfBunchCollFeeModulesCheck::beautify(std::shared_ptr<MonitorObject> mo, Quality checkResult)
+{
+  if (mo->getName() == "OutOfBunchColl_BCvsFeeModules") {
+    auto* histogram = dynamic_cast<TH2*>(mo->getObject());
+
+    if (!histogram) {
+      ILOG(Error, Support) << "beautify(): MO " << mo->getName() << " not found" << ENDM;
+      return;
+    }
+
+    TPaveText* msg = new TPaveText(0.1, 0.85, 0.9, 0.9, "NDC");
+    histogram->GetListOfFunctions()->Add(msg);
+    msg->SetName(Form("%s_msg", mo->GetName()));
+    msg->Clear();
+    if (checkResult.isWorseThan(Quality::Good)) {
+      msg->AddText(checkResult.getReasons()[0].second.c_str());
+    }
+    int color = kWhite;
+    if (checkResult == Quality::Good) {
+      color = kGreen + 1;
+      msg->AddText(">> Quality::Good <<");
+    } else if (checkResult == Quality::Medium) {
+      color = kOrange - 1;
+      msg->AddText(">> Quality::Medium <<");
+    } else if (checkResult == Quality::Bad) {
+      color = kRed;
+      msg->AddText(">> Quality::Bad <<");
+    }
+    msg->SetFillColor(color);
+  }
+}
+
+} // namespace o2::quality_control_modules::fv0