[EMCAL-915] Error handling for STU decoding

mfasDa · shahor02 · commit de61d45a2c8f · 2023-04-27T09:10:44.000+02:00
- STU error base class with main error codes
- Integration of STU decoding errors into
  ErrorTypeFEE
diff --git a/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/ErrorTypeFEE.h b/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/ErrorTypeFEE.h
@@ -57,6 +57,7 @@ class ErrorTypeFEE
     FIT_ERROR,         ///< Raw fit failed
     GEOMETRY_ERROR,    ///< Decoded position outside EMCAL
     GAIN_ERROR,        ///< Error due to gain type
+    STU_ERROR,         ///< Error from STU data
     UNDEFINED          ///< Error source undefined
   };
   /// \brief Constructor
@@ -97,6 +98,10 @@ class ErrorTypeFEE
   /// \param gainError Error code of the gain type error
   void setGainErrorType(int gainError) { setError(ErrorSource_t::GAIN_ERROR, gainError); }
 
+  /// \brief Set the error as STU decoder error and store the error code
+  /// \param gainError Error code of the STU decoder error
+  void setSTUDecoderErrorType(int gainError) { setError(ErrorSource_t::STU_ERROR, gainError); }
+
   /// \brief Set the error type of the object
   /// \param errorsource Error type of the object
   void setErrorType(ErrorSource_t errorsource) { mErrorSource = errorsource; }
@@ -157,6 +162,10 @@ class ErrorTypeFEE
   /// \return Error code (-1 in case the object is not a gain type error)
   int getGainTypeErrorType() const { return getRawErrorForType(ErrorSource_t::GAIN_ERROR); }
 
+  /// \brief Get the error code of the obect in case the object is a STU decoder error
+  /// \return Error code (-1 in case the object is not a STU decoder error)
+  int getSTUDecoderErrorType() const { return getRawErrorForType(ErrorSource_t::STU_ERROR); }
+
   /// \brief Get subspecification of the error
   /// \return Subspecification of the error
   int getSubspecification() const { return mSubspecification; }
diff --git a/DataFormats/Detectors/EMCAL/src/ErrorTypeFEE.cxx b/DataFormats/Detectors/EMCAL/src/ErrorTypeFEE.cxx
@@ -34,9 +34,12 @@ void ErrorTypeFEE::PrintStream(std::ostream& stream) const
     case ErrorSource_t::GEOMETRY_ERROR:
       typestring = "geometry error";
       break;
-    case ErrorTypeFEE::GAIN_ERROR:
+    case ErrorSource_t::GAIN_ERROR:
       typestring = "gain type error";
       break;
+    case ErrorSource_t::STU_ERROR:
+      typestring = "STU decoder error";
+      break;
     case ErrorSource_t::UNDEFINED:
       typestring = "unknown error";
       break;
@@ -66,8 +69,10 @@ const char* ErrorTypeFEE::getErrorTypeName(unsigned int errorTypeID)
       return "Fit";
     case ErrorSource_t::GEOMETRY_ERROR:
       return "Geometry";
-    case ErrorTypeFEE::GAIN_ERROR:
+    case ErrorSource_t::GAIN_ERROR:
       return "GainType";
+    case ErrorSource_t::STU_ERROR:
+      return "STUDecoding";
     case ErrorSource_t::UNDEFINED:
       return "Undefined";
     default:
@@ -88,8 +93,10 @@ const char* ErrorTypeFEE::getErrorTypeTitle(unsigned int errorTypeID)
       return "Fit";
     case ErrorSource_t::GEOMETRY_ERROR:
       return "Geometry";
-    case ErrorTypeFEE::GAIN_ERROR:
+    case ErrorSource_t::GAIN_ERROR:
       return "Gain";
+    case ErrorSource_t::STU_ERROR:
+      return "STUDecoding";
     case ErrorSource_t::UNDEFINED:
       return "Unknown";
     default:
diff --git a/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/STUDecoderError.h b/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/STUDecoderError.h
@@ -18,22 +18,82 @@
 namespace o2::emcal
 {
 
+/// \class STUDecoderError
+/// \brief Handling of STU reconstruction errors
+/// \ingroup EMCALreconstruction
+/// \since April 25, 2023
+///
+/// In order to distinguish different error types the STUDecoder error
+/// carries an error code which can be uniquely identified with a
+/// condition raising the excpetion. Source is always the DDL of the
+/// STU raising the exception.
 class STUDecoderError : public std::exception
 {
  public:
+  /// \enum ErrorCode_t
+  /// \brief Error codes of STU decoding
   enum class ErrorCode_t {
-    PAGE_ERROR,
-    WORD_UNEXPECTED,
-    INDEX_UNEXPECTED,
-    ADC_OVERFLOW
+    PAGE_ERROR,       ///< Page decoding failed (missing header)
+    WORD_UNEXPECTED,  ///< Word unexpected
+    INDEX_UNEXPECTED, ///< Patch index unexpected
+    ADC_OVERFLOW,     ///< ADC overflow
+    UNKNOWN           ///< Unknown error code (needed for conversion to int)
   };
-  STUDecoderError() = default;
+
+  /// \brief Get integer representation of error code
+  /// \param errorcode Error code
+  /// \return Integer representation
+  static int errorCodeToInt(ErrorCode_t errorcode);
+
+  /// \brief Convert integer to error code
+  /// \param errorcode Error code as integer
+  /// \return Error code (symbolic) - UNKNOWN for invalid integer error codes
+  static ErrorCode_t intToErrorCode(int errorcode);
+
+  /// \brief Get the name of the error code
+  /// \param errorcode Error code
+  /// \return Name of the error code
+  static std::string getErrorCodeName(ErrorCode_t errorcode);
+
+  /// \brief Get the name of the error code
+  /// \param errorcode Error code (integer representation)
+  /// \return Name of the error code
+  static std::string getErrorCodeName(int errorcode) { return getErrorCodeName(intToErrorCode(errorcode)); }
+
+  /// \brief Get the title of the error code
+  /// \param errorcode Error code
+  /// \return Title of the error code
+  static std::string getErrorCodeTitle(ErrorCode_t errorcode);
+
+  /// \brief Get the title of the error code
+  /// \param errorcode Error code (integer representation)
+  /// \return Title of the error code
+  static std::string getErrorCodeTitle(int errorcode) { return getErrorCodeTitle(intToErrorCode(errorcode)); }
+
+  /// \brief Constructor
+  /// \param ddlID ID of the DDL for which the exception is raised
+  /// \param errcode Error code of the exception
+  STUDecoderError(int ddlID, ErrorCode_t errcode);
+
+  /// \brief Destructor
   ~STUDecoderError() noexcept final = default;
 
+  /// \brief Access to error message
+  /// \return Error message
   const char* what() const noexcept final { return mMessage.data(); }
 
+  /// \brief Get the ID of the DDL in which the exception is raised
+  /// \return ID of the DDL
   int getDDLID() const noexcept { return mDDLId; }
 
+  /// \brief Get error code of the exception
+  /// \return Error code
+  ErrorCode_t getErrorCode() const noexcept { return mErrorCode; }
+
+  /// \brief Print details of the error on the stream
+  /// \param stream Stream to print on
+  ///
+  /// Helper function for streaming operator
   void printStream(std::ostream& stream) const;
 
  private:
@@ -42,6 +102,10 @@ class STUDecoderError : public std::exception
   std::string mMessage;   ///< Message buffer
 };
 
+/// \brief Streaming operator of STU decoding errors
+/// \param stream Stream to print the error on
+/// \param error Error to be streamed
+/// \return Stream after printing
 std::ostream& operator<<(std::ostream& stream, const STUDecoderError& error);
 
 } // namespace o2::emcal
diff --git a/Detectors/EMCAL/reconstruction/src/STUDecoderError.cxx b/Detectors/EMCAL/reconstruction/src/STUDecoderError.cxx
@@ -8,13 +8,79 @@
 // 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.
-
+#include <array>
+#include <iostream>
 #include "EMCALReconstruction/STUDecoderError.h"
 
 using namespace o2::emcal;
 
+STUDecoderError::STUDecoderError(int ddlID, ErrorCode_t errcode) : mDDLId(ddlID),
+                                                                   mErrorCode(errcode)
+{
+  mMessage = "STU decoding error of type" + getErrorCodeTitle(mErrorCode) + " in DDL " + std::to_string(mDDLId);
+}
+
+void STUDecoderError::printStream(std::ostream& stream) const
+{
+}
+
 std::ostream& o2::emcal::operator<<(std::ostream& stream, const STUDecoderError& error)
 {
   error.printStream(stream);
   return stream;
+}
+
+int STUDecoderError::errorCodeToInt(ErrorCode_t errorcode)
+{
+  switch (errorcode) {
+    case ErrorCode_t::PAGE_ERROR:
+      return 0;
+    case ErrorCode_t::WORD_UNEXPECTED:
+      return 1;
+    case ErrorCode_t::INDEX_UNEXPECTED:
+      return 2;
+    case ErrorCode_t::ADC_OVERFLOW:
+      return 3;
+    default:
+      return -1;
+  }
+}
+STUDecoderError::ErrorCode_t STUDecoderError::intToErrorCode(int errorcode)
+{
+  static constexpr std::size_t NUMERRORCODES = 4;
+  static constexpr std::array<ErrorCode_t, NUMERRORCODES> errorcodes = {{ErrorCode_t::PAGE_ERROR, ErrorCode_t::WORD_UNEXPECTED, ErrorCode_t::INDEX_UNEXPECTED, ErrorCode_t::ADC_OVERFLOW}};
+  if (errorcode < 0 || errorcode >= NUMERRORCODES) {
+    return ErrorCode_t::UNKNOWN;
+  }
+  return errorcodes[errorcode];
+}
+std::string STUDecoderError::getErrorCodeName(ErrorCode_t errorcode)
+{
+  switch (errorcode) {
+    case ErrorCode_t::PAGE_ERROR:
+      return "PageDecoding";
+    case ErrorCode_t::WORD_UNEXPECTED:
+      return "WordUnexpected";
+    case ErrorCode_t::INDEX_UNEXPECTED:
+      return "IndexUnexpected";
+    case ErrorCode_t::ADC_OVERFLOW:
+      return "ADCOverflow";
+    default:
+      return "Unknown";
+  }
+}
+std::string STUDecoderError::getErrorCodeTitle(ErrorCode_t errorcode)
+{
+  switch (errorcode) {
+    case ErrorCode_t::PAGE_ERROR:
+      return "page decoding";
+    case ErrorCode_t::WORD_UNEXPECTED:
+      return "unexpected word";
+    case ErrorCode_t::INDEX_UNEXPECTED:
+      return "invalid index";
+    case ErrorCode_t::ADC_OVERFLOW:
+      return "ADC overflow";
+    default:
+      return "Unknown";
+  }
 }
