[EMCAL-792] Make threshods for all error classes adjustable (#2229)

mfasDa · web-flow · commit 3244d13d2974 · 2024-04-10T17:00:58.000+02:00
- Threshods defined per error class and error histogram
- Threshold on errors from all links summed up
diff --git a/Modules/EMCAL/include/EMCAL/RawErrorCheck.h b/Modules/EMCAL/include/EMCAL/RawErrorCheck.h
@@ -19,6 +19,8 @@
 
 #include "QualityControl/CheckInterface.h"
 
+#include <map>
+
 namespace o2::emcal
 {
 class Geometry;
@@ -36,15 +38,26 @@ namespace o2::quality_control_modules::emcal
 class RawErrorCheck : public o2::quality_control::checker::CheckInterface
 {
  public:
-  /// Default constructor
+  /// \brief Default constructor
   RawErrorCheck() = default;
-  /// Destructor
+  /// \brief Destructor
   ~RawErrorCheck() override = default;
 
-  // Override interface
+  /// \brief Configure checker setting thresholds from taskParameters where specified
   void configure() override;
+
+  /// \brief Check for each object whether the number of errors of type is above the expected threshold
+  /// \param moMap List of histos to check
+  /// \return Quality of the selection
   Quality check(std::map<std::string, std::shared_ptr<MonitorObject>>* moMap) override;
+
+  /// \brief Beautify the monitoring objects showing the quality determination and a supermodule grid for channel based histograms
+  /// \param mo Monitoring object to beautify
+  /// \param checkResult Quality status of this checker
   void beautify(std::shared_ptr<MonitorObject> mo, Quality checkResult = Quality::Null) override;
+
+  /// \brief Accept only TH2 histograms as input
+  /// \return Name of the accepted object: TH2
   std::string getAcceptedType() override;
 
   ClassDefOverride(RawErrorCheck, 2);
@@ -56,8 +69,50 @@ class RawErrorCheck : public o2::quality_control::checker::CheckInterface
   /// \throw std::runtime_error in case value is not a boolean value
   bool decodeBool(std::string value) const;
 
-  o2::emcal::Geometry* mGeometry; ///< Geometry for mapping position between SM and full EMCAL
-  bool mNotifyInfologger = true;  ///< Switch for notification to infologger
+  /// \brief Find error code of the raw decoder error
+  /// \param errorname Name of the raw decoder error
+  /// \return Error code of the error name (-1 in case not found)
+  int findErrorCodeRDE(const std::string_view errorname) const;
+
+  /// \brief Find error code of the page error
+  /// \param errorname Name of the page error
+  /// \return Error code of the error name (-1 in case not found)
+  int findErrorCodePE(const std::string_view errorname) const;
+
+  /// \brief Find error code of the major ALTRO decoding error
+  /// \param errorname Name of the major ALTRO decoding error
+  /// \return Error code of the error name (-1 in case not found)
+  int findErrorCodeMAAE(const std::string_view errorname) const;
+
+  /// \brief Find error code of the minor ALTRO decoding error
+  /// \param errorname Name of minor ALTRO decoding error
+  /// \return Error code of the error name (-1 in case not found)
+  int findErrorCodeMIAE(const std::string_view errorname) const;
+
+  /// \brief Find error code of the raw fit error
+  /// \param errorname Name of the raw fit error
+  /// \return Error code of the error name (-1 in case not found)
+  int findErrorCodeRFE(const std::string_view errorname) const;
+
+  /// \brief Find error code of the geometry error
+  /// \param errorname Name of the geometry error
+  /// \return Error code of the error name (-1 in case not found)
+  int findErrorCodeGEE(const std::string_view errorname) const;
+
+  /// \brief Find error code of the gain type error
+  /// \param errorname Name of the gain type error
+  /// \return Error code of the error name (-1 in case not found)
+  int findErrorCodeGTE(const std::string_view errorname) const;
+
+  o2::emcal::Geometry* mGeometry;              ///< Geometry for mapping position between SM and full EMCAL
+  bool mNotifyInfologger = true;               ///< Switch for notification to infologger
+  std::map<int, int> mErrorCountThresholdRDE;  ///< Thresholds for Raw Decoder Error histogram
+  std::map<int, int> mErrorCountThresholdPE;   ///< Thresholds for Page Error histogram
+  std::map<int, int> mErrorCountThresholdMAAE; ///< Thresholds for Major ALTRO Error histogram
+  std::map<int, int> mErrorCountThresholdMIAE; ///< Thresholds for Minor ALTRO Error histogram
+  std::map<int, int> mErrorCountThresholdRFE;  ///< Thresholds for Raw Fit Error histogram
+  std::map<int, int> mErrorCountThresholdGEE;  ///< Thresholds for Geometry Error histogram
+  std::map<int, int> mErrorCountThresholdGTE;  ///< Thresholds for Gain Type Error histogram
 };
 
 } // namespace o2::quality_control_modules::emcal
diff --git a/Modules/EMCAL/src/RawErrorCheck.cxx b/Modules/EMCAL/src/RawErrorCheck.cxx
@@ -14,7 +14,12 @@
 #include <string>
 #include <boost/algorithm/string.hpp>
 
+#include "DataFormatsEMCAL/ErrorTypeFEE.h"
 #include "EMCALBase/Geometry.h"
+#include "EMCALReconstruction/AltroDecoder.h"
+#include "EMCALReconstruction/CaloRawFitter.h"
+#include "EMCALReconstruction/RawDecodingError.h"
+#include "EMCALReconstruction/ReconstructionErrors.h"
 
 #include "EMCAL/RawErrorCheck.h"
 #include "QualityControl/MonitorObject.h"
@@ -48,6 +53,126 @@ void RawErrorCheck::configure()
       ILOG(Error, Support) << e.what() << ENDM;
     }
   }
+  const std::string keyThreshRawdataErrors = "ThresholdRDE",
+                    keyThreshPageError = "ThresholdPE",
+                    keyThreshMajorAltroError = "ThresholdMAAE",
+                    keyThreshMinorAltroError = "ThresholdMIAE",
+                    keyThresRawFitError = "ThresholdRFE",
+                    keyThresholdGeometryError = "ThresholdGEE",
+                    keyThresholdGainTypeError = "ThresholdGTE";
+  for (auto [param, value] : mCustomParameters.getAllDefaults()) {
+    if (param.find(keyThreshRawdataErrors) == 0) {
+      auto errortype = param.substr(keyThreshRawdataErrors.length());
+      auto errorcode = findErrorCodeRDE(errortype);
+      if (errorcode > -1) {
+        try {
+          auto threshold = std::stoi(value);
+          ILOG(Info) << "Setting custom threshold in Histogram RawDataErrors: " << errortype << " <= " << threshold << ENDM;
+          mErrorCountThresholdRDE[errorcode] = threshold;
+        } catch (...) {
+          ILOG(Error) << "Thresholds for histogram RawDataErrors: Failure in decoding threshold value (" << value << ") for error type " << errortype << ENDM;
+        }
+      } else {
+        ILOG(Error) << "Thresholds for histogram RawDataErrors: Requested error type " << errortype << " not found" << ENDM;
+      }
+    }
+
+    if (param.find(keyThreshPageError) == 0) {
+      auto errortype = param.substr(keyThreshPageError.length());
+      auto errorcode = findErrorCodePE(errortype);
+      if (errorcode > -1) {
+        try {
+          auto threshold = std::stoi(value);
+          ILOG(Info) << "Setting custom threshold in Histogram PageErrors: " << errortype << " <= " << threshold << ENDM;
+          mErrorCountThresholdPE[errorcode] = threshold;
+        } catch (...) {
+          ILOG(Error) << "Thresholds for histogram PageErrors: Failure in decoding threshold value (" << value << ") for error type " << errortype << ENDM;
+        }
+      } else {
+        ILOG(Error) << "Thresholds for histogram PageErrors: Requested error type " << errortype << " not found" << ENDM;
+      }
+    }
+
+    if (param.find(keyThreshMajorAltroError) == 0) {
+      auto errortype = param.substr(keyThreshMajorAltroError.length());
+      auto errorcode = findErrorCodeMAAE(errortype);
+      if (errorcode > -1) {
+        try {
+          auto threshold = std::stoi(value);
+          ILOG(Info) << "Setting custom threshold in Histogram MajorAltroErrors: " << errortype << " <= " << threshold << ENDM;
+          mErrorCountThresholdMAAE[errorcode] = threshold;
+        } catch (...) {
+          ILOG(Error) << "Thresholds for histogram MajorAltroErrors: Failure in decoding threshold value (" << value << ") for error type " << errortype << ENDM;
+        }
+      } else {
+        ILOG(Error) << "Thresholds for histogram MajorAltroErrors: Requested error type " << errortype << " not found" << ENDM;
+      }
+    }
+
+    if (param.find(keyThreshMinorAltroError) == 0) {
+      auto errortype = param.substr(keyThreshMinorAltroError.length());
+      auto errorcode = findErrorCodeMIAE(errortype);
+      if (errorcode > -1) {
+        try {
+          auto threshold = std::stoi(value);
+          ILOG(Info) << "Setting custom threshold in Histogram MinorAltroError: " << errortype << " <= " << threshold << ENDM;
+          mErrorCountThresholdMAAE[errorcode] = threshold;
+        } catch (...) {
+          ILOG(Error) << "Thresholds for histogram MinorAltroError: Failure in decoding threshold value (" << value << ") for error type " << errortype << ENDM;
+        }
+      } else {
+        ILOG(Error) << "Thresholds for histogram MinorAltroError: Requested error type " << errortype << " not found" << ENDM;
+      }
+    }
+
+    if (param.find(keyThresRawFitError) == 0) {
+      auto errortype = param.substr(keyThresRawFitError.length());
+      auto errorcode = findErrorCodeRFE(errortype);
+      if (errorcode > -1) {
+        try {
+          auto threshold = std::stoi(value);
+          ILOG(Info) << "Setting custom threshold in Histogram RawFitError: " << errortype << " <= " << threshold << ENDM;
+          mErrorCountThresholdRFE[errorcode] = threshold;
+        } catch (...) {
+          ILOG(Error) << "Thresholds for histogram RawFitError: Failure in decoding threshold value (" << value << ") for error type " << errortype << ENDM;
+        }
+      } else {
+        ILOG(Error) << "Thresholds for histogram RawFitError: Requested error type " << errortype << " not found" << ENDM;
+      }
+    }
+
+    if (param.find(keyThresholdGeometryError) == 0) {
+      auto errortype = param.substr(keyThresholdGeometryError.length());
+      auto errorcode = findErrorCodeGEE(errortype);
+      if (errorcode > -1) {
+        try {
+          auto threshold = std::stoi(value);
+          ILOG(Info) << "Setting custom threshold in Histogram GeometryError: " << errortype << " <= " << threshold << ENDM;
+          mErrorCountThresholdGEE[errorcode] = threshold;
+        } catch (...) {
+          ILOG(Error) << "Thresholds for histogram GeometryError: Failure in decoding threshold value (" << value << ") for error type " << errortype << ENDM;
+        }
+      } else {
+        ILOG(Error) << "Thresholds for histogram GeometryError: Requested error type " << errortype << " not found" << ENDM;
+      }
+    }
+
+    if (param.find(keyThresholdGainTypeError) == 0) {
+      auto errortype = param.substr(keyThresholdGainTypeError.length());
+      auto errorcode = findErrorCodeGTE(errortype);
+      if (errorcode > -1) {
+        try {
+          auto threshold = std::stoi(value);
+          ILOG(Info) << "Setting custom threshold in Histogram GainTypeError: " << errortype << " <= " << threshold << ENDM;
+          mErrorCountThresholdGTE[errorcode] = threshold;
+        } catch (...) {
+          ILOG(Error) << "Thresholds for histogram GainTypeError: Failure in decoding threshold value (" << value << ") for error type " << errortype << ENDM;
+        }
+      } else {
+        ILOG(Error) << "Thresholds for histogram GainTypeError: Requested error type " << errortype << " not found" << ENDM;
+      }
+    }
+  }
 }
 
 Quality RawErrorCheck::check(std::map<std::string, std::shared_ptr<MonitorObject>>* moMap)
@@ -57,20 +182,41 @@ Quality RawErrorCheck::check(std::map<std::string, std::shared_ptr<MonitorObject
   std::array<std::string, 2> channelgainhists = { { "ChannelLGnoHG", "ChannelHGnoLG" } };
   Quality result = Quality::Good;
 
+  std::map<std::string, const std::map<int, int>*> thresholdConfigErrorHists = {
+    { "RawDataErrors", &mErrorCountThresholdRDE },
+    { "PageErrors", &mErrorCountThresholdPE },
+    { "MajorAltroErrors", &mErrorCountThresholdMAAE },
+    { "MinorAltroError", &mErrorCountThresholdMIAE },
+    { "RawFitError", &mErrorCountThresholdRFE },
+    { "GeometryError", &mErrorCountThresholdGEE },
+    { "GainTypeError", &mErrorCountThresholdGTE }
+  };
+
   for (auto& [moName, mo] : *moMap) {
     if (std::find(errorhists.begin(), errorhists.end(), mo->getName()) != errorhists.end()) {
       // Check for presence of error codes
       auto* errorhist = dynamic_cast<TH2*>(mo->getObject());
 
-      for (int linkID = 0; linkID < errorhist->GetXaxis()->GetNbins(); linkID++) {
-        for (int errorcode = 0; errorcode < errorhist->GetYaxis()->GetNbins(); errorcode++) {
-          if (errorhist->GetBinContent(linkID + 1, errorcode + 1)) {
-            // Found raw data error
-            if (result != Quality::Bad) {
-              result = Quality::Bad;
-            }
-            result.addReason(FlagReasonFactory::Unknown(), "Raw error " + std::string(errorhist->GetYaxis()->GetBinLabel(errorcode + 1)) + " found in DDL " + std::to_string(linkID));
+      for (int errorcode = 0; errorcode < errorhist->GetYaxis()->GetNbins(); errorcode++) {
+        // try to find a threshold
+        int threshold = 0;
+        auto thresholdHandler = thresholdConfigErrorHists.find(mo->getName());
+        if (thresholdHandler != thresholdConfigErrorHists.end()) {
+          auto thresholdFound = thresholdHandler->second->find(errorcode);
+          if (thresholdFound != thresholdHandler->second->end()) {
+            threshold = thresholdFound->second;
+          }
+        }
+        int numErrors = 0;
+        for (int linkID = 0; linkID < errorhist->GetXaxis()->GetNbins(); linkID++) {
+          numErrors += errorhist->GetBinContent(linkID + 1, errorcode + 1);
+        }
+        if (numErrors > threshold) {
+          // Found number of raw data errors is above threshold for bin
+          if (result != Quality::Bad) {
+            result = Quality::Bad;
           }
+          result.addReason(FlagReasonFactory::Unknown(), "Raw error " + std::string(errorhist->GetYaxis()->GetBinLabel(errorcode + 1)) + " above threshold " + std::to_string(threshold));
         }
       }
     } else if (std::find(gainhists.begin(), gainhists.end(), mo->GetName()) != gainhists.end()) {
@@ -150,7 +296,7 @@ void RawErrorCheck::beautify(std::shared_ptr<MonitorObject> mo, Quality checkRes
       }
     }
   }
-  //SM grid
+  // SM grid
   if (mo->getName().find("Channel") != std::string::npos) {
     auto* h2D = dynamic_cast<TH2*>(mo->getObject());
     // orizontal
@@ -170,7 +316,7 @@ void RawErrorCheck::beautify(std::shared_ptr<MonitorObject> mo, Quality checkRes
     TLine* l11 = new TLine(-0.5, 200, 95.5, 200);
     TLine* l12 = new TLine(47.5, 200, 47.5, 207.5);
 
-    //vertical
+    // vertical
     TLine* l13 = new TLine(47.5, -0.5, 47.5, 128);
     TLine* l14 = new TLine(31.5, 128, 31.5, 200);
     TLine* l15 = new TLine(63.5, 128, 63.5, 200);
@@ -221,4 +367,88 @@ bool RawErrorCheck::decodeBool(std::string value) const
   throw std::runtime_error(fmt::format("Value {} not a boolean", value.data()).data());
 }
 
+int RawErrorCheck::findErrorCodeRDE(const std::string_view errorname) const
+{
+  int result = -1;
+  for (int error = 0; error < o2::emcal::ErrorTypeFEE::getNumberOfErrorTypes(); error++) {
+    if (std::string_view(o2::emcal::ErrorTypeFEE::getErrorTypeName(error)) == errorname) {
+      result = error;
+      break;
+    }
+  }
+  return result;
+}
+
+int RawErrorCheck::findErrorCodePE(const std::string_view errorname) const
+{
+  int result = -1;
+  for (int error = 0; error < o2::emcal::RawDecodingError::getNumberOfErrorTypes(); error++) {
+    if (std::string_view(o2::emcal::RawDecodingError::getErrorCodeNames(error)) == errorname) {
+      result = error;
+      break;
+    }
+  }
+  return result;
+}
+
+int RawErrorCheck::findErrorCodeMAAE(const std::string_view errorname) const
+{
+  int result = -1;
+  for (int error = 0; error < o2::emcal::AltroDecoderError::getNumberOfErrorTypes(); error++) {
+    if (std::string_view(o2::emcal::AltroDecoderError::getErrorTypeName(error)) == errorname) {
+      result = error;
+      break;
+    }
+  }
+  return result;
+}
+
+int RawErrorCheck::findErrorCodeMIAE(const std::string_view errorname) const
+{
+  int result = -1;
+  for (int error = 0; error < o2::emcal::MinorAltroDecodingError::getNumberOfErrorTypes(); error++) {
+    if (std::string_view(o2::emcal::MinorAltroDecodingError::getErrorTypeName(error)) == errorname) {
+      result = error;
+      break;
+    }
+  }
+  return result;
+}
+
+int RawErrorCheck::findErrorCodeRFE(const std::string_view errorname) const
+{
+  int result = -1;
+  for (int error = 0; error < o2::emcal::CaloRawFitter::getNumberOfErrorTypes(); error++) {
+    if (std::string_view(o2::emcal::CaloRawFitter::getErrorTypeName(error)) == errorname) {
+      result = error;
+      break;
+    }
+  }
+  return result;
+}
+
+int RawErrorCheck::findErrorCodeGEE(const std::string_view errorname) const
+{
+  int result = -1;
+  for (int error = 0; error < o2::emcal::reconstructionerrors::getNumberOfGeometryErrorCodes(); error++) {
+    if (std::string_view(o2::emcal::reconstructionerrors::getGeometryErrorName(error)) == errorname) {
+      result = error;
+      break;
+    }
+  }
+  return result;
+}
+
+int RawErrorCheck::findErrorCodeGTE(const std::string_view errorname) const
+{
+  int result = -1;
+  for (int error = 0; error < o2::emcal::reconstructionerrors::getNumberOfGainErrorCodes(); error++) {
+    if (std::string_view(o2::emcal::reconstructionerrors::getGainErrorName(error)) == errorname) {
+      result = error;
+      break;
+    }
+  }
+  return result;
+}
+
 } // namespace o2::quality_control_modules::emcal
