RCUTrailer.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_PHOS_RCUTRAILER_H
#define ALICEO2_PHOS_RCUTRAILER_H
 
#include <exception>
#include <iosfwd>
#include <string>
#include <cstdint>
#include <gsl/span>
#include "Rtypes.h"
 
namespace o2
{
 
namespace phos
{
 
union ChannelHeader {
  uint32_t mDataWord;
  struct {
    uint32_t mHardwareAddress : 16; 
    uint32_t mPayloadSize : 10;     
    uint32_t mZero1 : 3;            
    uint32_t mBadChannel : 1;       
    uint32_t mMark : 1;             
  };
};
 
union CaloBunchWord {
  uint32_t mDataWord;
  struct {
    uint32_t mWord2 : 10; 
    uint32_t mWord1 : 10; 
    uint32_t mWord0 : 10; 
    uint32_t mZero : 2;   
  };
};
 
class RCUTrailer
{
 public:
  class Error : public std::exception
  {
   public:
    enum class ErrorType_t {
      DECODING_INVALID,     
      SIZE_INVALID,         
      SAMPLINGFREQ_INVALID, 
      L1PHASE_INVALID       
    };
 
    Error(ErrorType_t errtype, const char* message) : mErrorType(errtype), mErrorMessage(message) {}
 
    ~Error() noexcept override = default;
 
    const char* what() const noexcept override { return mErrorMessage.data(); }
 
    ErrorType_t getErrorType() const noexcept { return mErrorType; }
 
   private:
    ErrorType_t mErrorType;    
    std::string mErrorMessage; 
  };
 
  RCUTrailer() = default;
 
  RCUTrailer(const gsl::span<const uint32_t> payloadwords);
 
  ~RCUTrailer() = default;
 
  void reset();
 
  void printStream(std::ostream& stream) const;
 
  void constructFromRawPayload(const gsl::span<const uint32_t> payloadwords);
 
  unsigned int getFECErrorsA() const { return mFECERRA; }
  unsigned int getFECErrorsB() const { return mFECERRB; }
  unsigned short getErrorsG2() const { return mERRREG2; }
  unsigned int getErrorsG3() const { return mERRREG3; }
  unsigned short getActiveFECsA() const { return mActiveFECsA; }
  unsigned short getActiveFECsB() const { return mActiveFECsB; }
  unsigned int getAltroCFGReg1() const { return mAltroCFG1; }
  unsigned int getAltroCFGReg2() const { return mAltroCFG2; }
  int getRCUID() const { return mRCUId; }
  unsigned int getTrailerSize() const { return mTrailerSize; }
  unsigned int getPayloadSize() const { return mPayloadSize; }
  unsigned char getFirmwareVersion() const { return mFirmwareVersion; }
 
  unsigned short getNumberOfChannelAddressMismatch() const { return (mERRREG3 & 0xFFF); }
  unsigned short getNumberOfChannelLengthMismatch() const { return ((mERRREG3 >> 12) & 0x1FFF); }
  unsigned char getBaselineCorrection() const { return mAltroCFG1 & 0xF; }
  bool getPolarity() const { return (mAltroCFG1 >> 4) & 0x1; }
  unsigned char getNumberOfPresamples() const { return (mAltroCFG1 >> 5) & 0x3; }
  unsigned char getNumberOfPostsamples() const { return (mAltroCFG1 >> 7) & 0xF; }
  bool hasSecondBaselineCorr() const { return (mAltroCFG1 >> 11) & 0x1; }
  unsigned char getGlitchFilter() const { return (mAltroCFG1 >> 12) & 0x3; }
  unsigned char getNumberOfNonZeroSuppressedPostsamples() const { return (mAltroCFG1 >> 14) & 0x7; }
  unsigned char getNumberOfNonZeroSuppressedPresamples() const { return (mAltroCFG1 >> 17) & 0x3; }
  bool hasZeroSuppression() const { return (mAltroCFG1 >> 19) & 0x1; }
  bool getNumberOfAltroBuffers() const { return (mAltroCFG2 >> 24) & 0x1; }
  unsigned char getNumberOfPretriggerSamples() const { return (mAltroCFG2 >> 20) & 0xF; }
  unsigned short getNumberOfSamplesPerChannel() const { return (mAltroCFG2 >> 10) & 0x3FF; }
  bool isSparseReadout() const { return (mAltroCFG2 >> 9) & 0x1; }
 
  double getTimeSample() const;
 
  void setTimeSample(double timesample);
 
  double getL1Phase() const;
 
  void setL1Phase(double l1phase);
 
  void setFECErrorsA(unsigned int value) { mFECERRA = value; }
  void setFECErrorsB(unsigned int value) { mFECERRB = value; }
  void setErrorsG2(unsigned short value) { mERRREG2 = value; }
  void setErrorsG3(unsigned int value) { mERRREG3 = value; }
  void setActiveFECsA(unsigned short value) { mActiveFECsA = value; }
  void setActiveFECsB(unsigned short value) { mActiveFECsB = value; }
  void setAltroCFGReg1(unsigned int value) { mAltroCFG1 = value; }
  void setAltroCFGReg2(unsigned int value) { mAltroCFG2 = value; }
  void setFirmwareVersion(unsigned char version) { mFirmwareVersion = version; }
  void setPayloadSize(unsigned int size) { mPayloadSize = size; }
 
  bool isInitialized() const { return mIsInitialized; }
 
  std::vector<uint32_t> encode() const;
 
  static RCUTrailer constructFromPayloadWords(const gsl::span<const uint32_t> payloadwords);
 
 private:
  int mRCUId = -1;                    
  unsigned char mFirmwareVersion = 0; 
  unsigned int mTrailerSize = 0;      
  unsigned int mPayloadSize = 0;      
  unsigned int mFECERRA = 0;          
  unsigned int mFECERRB = 0;          
  unsigned short mERRREG2 = 0;        
  unsigned int mERRREG3 = 0;          
  unsigned short mActiveFECsA = 0;    
  unsigned short mActiveFECsB = 0;    
  unsigned int mAltroCFG1 = 0;        
  unsigned int mAltroCFG2 = 0;        
  bool mIsInitialized = false;        
 
  ClassDefNV(RCUTrailer, 1);
};
 
std::ostream& operator<<(std::ostream& stream, const RCUTrailer& trailer);
 
} // namespace phos
 
} // namespace o2
 
#endif