AltroDecoder.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_ALTRODECODER_H
#define ALICEO2_EMCAL_ALTRODECODER_H
 
#include <climits>
#include <exception>
#include <iosfwd>
#include <gsl/span>
#include <string>
#include <string_view>
#include "EMCALBase/RCUTrailer.h"
#include "EMCALReconstruction/Bunch.h"
#include "EMCALReconstruction/Channel.h"
#include "EMCALReconstruction/RawReaderMemory.h"
 
namespace o2
{
namespace emcal
{
 
class AltroDecoderError : public std::exception
{
 public:
  enum class ErrorType_t {
    RCU_TRAILER_ERROR,        
    RCU_VERSION_ERROR,        
    RCU_TRAILER_SIZE_ERROR,   
    ALTRO_BUNCH_HEADER_ERROR, 
    ALTRO_BUNCH_LENGTH_ERROR, 
    ALTRO_PAYLOAD_ERROR,      
    ALTRO_MAPPING_ERROR,      
    CHANNEL_ERROR             
  };
 
  AltroDecoderError(ErrorType_t errtype, const std::string_view message) : mErrorType(errtype), mErrorMessage(message) {}
 
  ~AltroDecoderError() noexcept override = default;
 
  const char* what() const noexcept override { return mErrorMessage.data(); }
 
  static int errorTypeToInt(ErrorType_t errortype);
 
  static ErrorType_t intToErrorType(int errornumber);
 
  static constexpr int getNumberOfErrorTypes() noexcept { return 8; }
 
  const ErrorType_t getErrorType() const noexcept { return mErrorType; }
 
  static const char* getErrorTypeName(ErrorType_t errortype);
 
  static const char* getErrorTypeName(unsigned int errortype)
  {
    return getErrorTypeName(intToErrorType(errortype));
  }
 
  static const char* getErrorTypeTitle(ErrorType_t errortype);
 
  static const char* getErrorTypeTitle(unsigned int errortype)
  {
    return getErrorTypeTitle(intToErrorType(errortype));
  }
 
  static const char* getErrorTypeDescription(ErrorType_t errortype);
 
  static const char* getErrorTypeDescription(unsigned int errortype)
  {
    return getErrorTypeDescription(intToErrorType(errortype));
  }
 
 private:
  ErrorType_t mErrorType;    
  std::string mErrorMessage; 
};
 
class MinorAltroDecodingError
{
 public:
  enum class ErrorType_t {
    BUNCH_HEADER_NULL,            
    CHANNEL_HEADER,               
    CHANNEL_END_PAYLOAD_UNEXPECT, 
    CHANNEL_PAYLOAD_EXCEED,       
    CHANNEL_ORDER,                
    BUNCH_LENGTH_EXCEED,          
    BUNCH_LENGTH_ALLOW_EXCEED,    
    BUNCH_STARTTIME               
  };
 
  MinorAltroDecodingError() = default;
 
  MinorAltroDecodingError(ErrorType_t errtype, uint32_t channelHeader, uint32_t payloadword) : mErrorType(errtype),
                                                                                               mChannelHeader(channelHeader),
                                                                                               mPayloadWord(payloadword)
  {
  }
 
  ~MinorAltroDecodingError() noexcept = default;
 
  uint32_t getChannelHeader() const noexcept { return mChannelHeader; };
 
  uint32_t getPayloadWord() const noexcept { return mPayloadWord; }
 
  ErrorType_t getErrorType() const noexcept { return mErrorType; }
 
  std::string what() const noexcept;
 
  static int errorTypeToInt(ErrorType_t errortype);
 
  static ErrorType_t intToErrorType(int errornumber);
 
  static constexpr int getNumberOfErrorTypes() noexcept { return 8; }
 
  static const char* getErrorTypeName(ErrorType_t errortype);
 
  static const char* getErrorTypeName(unsigned int errortype)
  {
    return getErrorTypeName(intToErrorType(errortype));
  }
 
  static const char* getErrorTypeTitle(ErrorType_t errortype);
 
  static const char* getErrorTypeTitle(unsigned int errortype)
  {
    return getErrorTypeTitle(intToErrorType(errortype));
  }
 
  static const char* getErrorTypeDescription(ErrorType_t errortype);
 
  static const char* getErrorTypeDescription(unsigned int errortype)
  {
    return getErrorTypeDescription(intToErrorType(errortype));
  }
 
 private:
  ErrorType_t mErrorType;  
  uint32_t mChannelHeader; 
  uint32_t mPayloadWord;   
};
 
 
class AltroDecoder
{
 public:
  AltroDecoder(RawReaderMemory& reader);
 
  ~AltroDecoder() = default;
 
  void setMaxBunchLength(int maxBunchLength) { mMaxBunchLength = maxBunchLength; }
 
  void decode();
 
  const RCUTrailer& getRCUTrailer() const;
 
  const std::vector<Channel>& getChannels() const;
 
  void readRCUTrailer();
 
  void readChannels();
 
  const std::vector<MinorAltroDecodingError>& getMinorDecodingErrors() const { return mMinorDecodingErrors; }
 
 private:
  void checkRCUTrailer();
 
  bool checkChannelHWAddress(int hwaddress);
 
  RawReaderMemory& mRawReader;                               
  RCUTrailer mRCUTrailer;                                    
  std::vector<Channel> mChannels;                            
  std::vector<MinorAltroDecodingError> mMinorDecodingErrors; 
  bool mChannelsInitialized = false;                         
  unsigned int mMaxBunchLength = UINT_MAX;                   
 
  ClassDefNV(AltroDecoder, 1);
};
 
std::ostream& operator<<(std::ostream& stream, const AltroDecoderError& error);
 
std::ostream& operator<<(std::ostream& stream, const AltroDecoderError::ErrorType_t& errortype);
 
std::ostream& operator<<(std::ostream& stream, const MinorAltroDecodingError& error);
 
std::ostream& operator<<(std::ostream& stream, const MinorAltroDecodingError::ErrorType_t& errortype);
 
} // namespace emcal
 
} // namespace o2
 
#endif