ErrorTypeFEE.h

Go to the documentation of this file.

// 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.
 
#ifndef ALICEO2_EMCAL_ERRORTYPEFEE_H
#define ALICEO2_EMCAL_ERRORTYPEFEE_H
 
#include <iostream>
#include "Rtypes.h"
 
namespace o2
{
 
namespace emcal
{
 
class ErrorTypeFEE
{
 public:
  enum ErrorSource_t {
    PAGE_ERROR,        
    ALTRO_ERROR,       
    MINOR_ALTRO_ERROR, 
    FIT_ERROR,         
    GEOMETRY_ERROR,    
    GAIN_ERROR,        
    LINK_ERROR,        
    TRU_ERROR,         
    STU_ERROR,         
    UNDEFINED          
  };
  ErrorTypeFEE() = default;
 
  ErrorTypeFEE(int FEEID, ErrorSource_t errortype, int errorCode, int subspec, int hardwareAddress) : mFEEID(FEEID), mErrorSource(errortype), mErrorCode(errorCode), mSubspecification(subspec), mHardwareAddress(hardwareAddress) {}
 
  ~ErrorTypeFEE() = default;
 
  void setFEEID(int feeid) { mFEEID = feeid; }
 
  void setDecodeErrorType(int decodeError) { setError(ErrorSource_t::ALTRO_ERROR, decodeError); }
 
  void setMinorDecodingErrorType(int decodeError) { setError(ErrorSource_t::MINOR_ALTRO_ERROR, decodeError); }
 
  void setRawFitErrorType(int rawfitterError) { setError(ErrorSource_t::FIT_ERROR, rawfitterError); }
 
  void setPageErrorType(int pageError) { setError(ErrorSource_t::PAGE_ERROR, pageError); }
 
  void setGainErrorType(int gainError) { setError(ErrorSource_t::GAIN_ERROR, gainError); }
 
  void setLinkErrorTYpe(int linkError) { setError(ErrorSource_t::LINK_ERROR, linkError); }
 
  void setSTUDecoderErrorType(int stuerror) { setError(ErrorSource_t::STU_ERROR, stuerror); }
 
  void setTRUDecoderErrorType(int truerror) { setError(ErrorSource_t::TRU_ERROR, truerror); }
 
  void setErrorType(ErrorSource_t errorsource) { mErrorSource = errorsource; }
 
  void setErrorCode(int errorcode) { mErrorCode = errorcode; }
 
  void setError(ErrorSource_t errorsource, int errorcode)
  {
    setErrorType(errorsource);
    setErrorCode(errorcode);
  }
 
  void setSubspecification(int subspec) { mSubspecification = subspec; }
 
  void setHardwareAddress(int hardwareAddress) { mHardwareAddress = hardwareAddress; }
 
  int getFEEID() const
  {
    return mFEEID;
  }
 
  ErrorSource_t getErrorType() const { return mErrorSource; }
 
  int getErrorCode() const { return mErrorCode; }
 
  int getDecodeErrorType() const { return getRawErrorForType(ErrorSource_t::ALTRO_ERROR); }
 
  int getMinorDecodeErrorType() const { return getRawErrorForType(ErrorSource_t::MINOR_ALTRO_ERROR); }
 
  int getRawFitErrorType() const { return getRawErrorForType(ErrorSource_t::FIT_ERROR); }
 
  int getRawPageErrorType() const { return getRawErrorForType(ErrorSource_t::PAGE_ERROR); }
 
  int getGainTypeErrorType() const { return getRawErrorForType(ErrorSource_t::GAIN_ERROR); }
 
  int getLinkErrorType() const { return getRawErrorForType(ErrorSource_t::LINK_ERROR); }
 
  int getSTUDecoderErrorType() const { return getRawErrorForType(ErrorSource_t::STU_ERROR); }
 
  int getTRUDecoderErrorType() const { return getRawErrorForType(ErrorSource_t::TRU_ERROR); }
 
  int getSubspecification() const { return mSubspecification; }
 
  int getHarwareAddress() const { return mHardwareAddress; }
 
  void PrintStream(std::ostream& stream) const;
 
  static constexpr int getNumberOfErrorTypes() { return 10; }
 
  static const char* getErrorTypeName(unsigned int errorTypeID);
 
  static const char* getErrorTypeTitle(unsigned int errorTypeID);
 
 private:
  int getRawErrorForType(ErrorSource_t source) const { return mErrorSource == source ? mErrorCode : -1; }
 
  int mFEEID = -1;                                       
  ErrorSource_t mErrorSource = ErrorSource_t::UNDEFINED; 
  int mErrorCode = -1;                                   
  int mSubspecification;                                 
  int mHardwareAddress;                                  
 
  ClassDefNV(ErrorTypeFEE, 1);
};
 
std::ostream& operator<<(std::ostream& stream, const ErrorTypeFEE& errorType);
 
} // namespace emcal
 
} // namespace o2
 
#endif