RawReaderMemory.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_RAWREADERMEMORY_H
#define ALICEO2_EMCAL_RAWREADERMEMORY_H
 
#include <vector>
#include <gsl/span>
#include <Rtypes.h>
 
#include "EMCALBase/RCUTrailer.h"
#include "EMCALReconstruction/RawBuffer.h"
#include "EMCALReconstruction/RawDecodingError.h"
#include "EMCALReconstruction/RawPayload.h"
#include "Headers/RAWDataHeader.h"
#include "Headers/RDHAny.h"
 
namespace o2
{
 
namespace emcal
{
 
class RawReaderMemory
{
 public:
  class MinorError
  {
   public:
    MinorError() = default;
 
    MinorError(RawDecodingError::ErrorType_t errortype, int feeID) : mErrorType(errortype), mFEEID(feeID) {}
 
    ~MinorError() = default;
 
    void setErrorType(RawDecodingError::ErrorType_t errortype) { mErrorType = errortype; }
 
    void setFEEID(int feeID) { mFEEID = feeID; }
 
    RawDecodingError::ErrorType_t getErrorType() const { return mErrorType; }
 
    int getFEEID() const { return mFEEID; }
 
   private:
    RawDecodingError::ErrorType_t mErrorType; 
    int mFEEID;                               
  };
 
  RawReaderMemory(const gsl::span<const char> rawmemory);
 
  ~RawReaderMemory() = default;
 
  void setRawMemory(const gsl::span<const char> rawmemory);
 
  void setRangeSRUDDLs(uint16_t minDDL, uint16_t maxDDL)
  {
    mMinSRUDDL = minDDL;
    mMaxSRUDDL = maxDDL;
  }
 
  void next();
 
  void nextPage(bool resetPayload = true);
 
  const o2::header::RDHAny& getRawHeader() const;
 
  const RawBuffer& getRawBuffer() const;
 
  const RawPayload& getPayload() const { return mRawPayload; }
 
  gsl::span<const MinorError> getMinorErrors() const { return mMinorErrors; }
 
  int getPayloadSize() const { return mRawPayload.getPayloadSize(); }
 
  int getFileSize() const noexcept { return mRawMemoryBuffer.size(); }
 
  bool hasNext() const { return mCurrentPosition < mRawMemoryBuffer.size(); }
 
 protected:
  void init();
 
  o2::header::RDHAny decodeRawHeader(const void* headerwords);
 
 private:
  gsl::span<const char> mRawMemoryBuffer; 
  RawBuffer mRawBuffer;                   
  o2::header::RDHAny mRawHeader;          
  RawPayload mRawPayload;                 
  RCUTrailer mCurrentTrailer;             
  uint64_t mTrailerPayloadWords = 0;      
  uint16_t mMinSRUDDL = 0;                
  uint16_t mMaxSRUDDL = 39;               
  int mCurrentPosition = 0;               
  int mCurrentFEE = -1;                   
  bool mRawHeaderInitialized = false;     
  bool mPayloadInitialized = false;       
  std::vector<MinorError> mMinorErrors;   
 
  ClassDefNV(RawReaderMemory, 1);
};
 
} // namespace emcal
 
} // namespace o2
 
#endif