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_EMCAL_RCUTRAILER_H
#define ALICEO2_EMCAL_RCUTRAILER_H
 
#include <exception>
#include <iosfwd>
#include <string>
#include <cstdint>
#include <gsl/span>
#include <Rtypes.h>
 
namespace o2
{
 
namespace emcal
{
 
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; 
  };
 
  enum BufferMode_t {
    NBUFFERS4 = 0, 
    NBUFFERS8 = 1  
  };
 
  RCUTrailer() = default;
 
  ~RCUTrailer() = default;
 
  void reset();
 
  void printStream(std::ostream& stream) const;
 
  void constructFromRawPayload(const gsl::span<const uint32_t> payloadwords);
 
  int getRCUID() const { return mRCUId; }
 
  uint32_t getTrailerSize() const { return mTrailerSize; }
 
  uint32_t getPayloadSize() const { return mPayloadSize; }
 
  uint32_t getTrailerWordCorruptions() const { return mWordCorruptions; }
 
  uint8_t getFirmwareVersion() const { return mFirmwareVersion; }
 
  void setFirmwareVersion(uint8_t version) { mFirmwareVersion = version; }
 
  void setRCUID(int rcuid) { mRCUId = rcuid; }
 
  void setPayloadSize(uint32_t size) { mPayloadSize = size; }
 
  double getTimeSampleNS() const;
 
  double getL1PhaseNS() const;
 
  void setTimeSamplePhaseNS(uint64_t triggertime, uint64_t timesample);
 
  //
  // Error counters
  //
 
  uint16_t getNumberOfChannelAddressMismatch() const { return mErrorCounter.mNumChannelAddressMismatch; }
 
  uint16_t getNumberOfChannelLengthMismatch() const { return mErrorCounter.mNumChannelLengthMismatch; }
 
  void setNumberOfChannelAddressMismatch(uint16_t nchannel) { mErrorCounter.mNumChannelAddressMismatch = nchannel; }
 
  void setNumberOfChannelLengthMismatch(uint8_t nchannel) { mErrorCounter.mNumChannelLengthMismatch = nchannel; }
 
  uint32_t getFECErrorsA() const { return mFECERRA; }
  uint32_t getFECErrorsB() const { return mFECERRB; }
  uint16_t getActiveFECsA() const { return mActiveFECsA; }
  uint16_t getActiveFECsB() const { return mActiveFECsB; }
  void setFECErrorsA(uint32_t value) { mFECERRA = value; }
  void setFECErrorsB(uint32_t value) { mFECERRB = value; }
  void setActiveFECsA(uint16_t value) { mActiveFECsA = value; }
  void setActiveFECsB(uint16_t value) { mActiveFECsB = value; }
 
  //
  // ALTRO configuration
  //
 
  uint16_t getBaselineCorrection() const { return mAltroConfig.mBaselineCorrection; }
 
  bool getPolarity() const { return mAltroConfig.mPolarity; }
 
  uint16_t getNumberOfPresamples() const { return mAltroConfig.mNumPresamples; }
 
  uint16_t getNumberOfPostsamples() const { return mAltroConfig.mNumPostsamples; }
 
  bool hasSecondBaselineCorr() const { return mAltroConfig.mSecondBaselineCorrection; }
 
  uint16_t getGlitchFilter() const { return mAltroConfig.mGlitchFilter; }
 
  uint16_t getNumberOfNonZeroSuppressedPostsamples() const { return mAltroConfig.mNumPostsamplesNoZS; }
 
  uint16_t getNumberOfNonZeroSuppressedPresamples() const { return mAltroConfig.mNumPresamplesNoZS; }
 
  bool hasZeroSuppression() const { return mAltroConfig.mZeroSuppression; }
 
  uint16_t getNumberOfPretriggerSamples() const { return mAltroConfig.mNumSamplesPretrigger; }
 
  uint16_t getNumberOfSamplesPerChannel() const { return mAltroConfig.mNumSamplesChannel; }
 
  uint16_t getNumberOfAltroBuffers() const { return BufferMode_t(mAltroConfig.mAltroBuffers) == BufferMode_t::NBUFFERS4 ? 4 : 8; }
 
  bool isSparseReadout() const { return mAltroConfig.mSparseReadout; }
 
  void setBaselineCorrection(uint16_t baselineCorrection) { mAltroConfig.mBaselineCorrection = baselineCorrection; }
 
  void setPolarity(bool doSet) { mAltroConfig.mPolarity = doSet; }
 
  void setNumberOfPresamples(uint16_t npresamples) { mAltroConfig.mNumPresamples = npresamples; }
 
  void setNumberOfPostsamples(uint16_t npostsamples) { mAltroConfig.mNumPostsamples = npostsamples; }
 
  void setSecondBaselineCorrection(bool doHave) { mAltroConfig.mSecondBaselineCorrection = doHave; }
 
  void setGlitchFilter(uint16_t glitchfilter) { mAltroConfig.mGlitchFilter = glitchfilter; }
 
  void setNumberOfNonZeroSuppressedPostsamples(uint16_t npostsamples) { mAltroConfig.mNumPostsamplesNoZS = npostsamples; }
 
  void setNumberOfNonZeroSuppressedPresamples(uint16_t npresamples) { mAltroConfig.mNumPresamplesNoZS = npresamples; }
 
  void setNumberOfPretriggerSamples(uint16_t nsamples) { mAltroConfig.mNumSamplesPretrigger = nsamples; }
 
  void setNumberOfSamplesPerChannel(uint16_t nsamples) { mAltroConfig.mNumSamplesChannel = nsamples; }
 
  void setZeroSuppression(bool doHave) { mAltroConfig.mZeroSuppression = doHave ? 1 : 0; }
 
  void setSparseReadout(bool isSparse) { mAltroConfig.mSparseReadout = isSparse; }
 
  void setNumberOfAltroBuffers(BufferMode_t bufmode) { mAltroConfig.mAltroBuffers = uint8_t(bufmode); }
 
 
  uint16_t getErrorsG2() const { return mErrorCounter.mErrorRegister2; }
 
  uint32_t getErrorsG3() const { return mErrorCounter.mErrorRegister3; }
 
  uint32_t getAltroCFGReg1() const { return mAltroConfig.mWord1; }
 
  uint32_t getAltroCFGReg2() const { return mAltroConfig.mWord2; }
 
  void setErrorsG2(uint16_t value) { mErrorCounter.mErrorRegister2 = value; }
 
  void setErrorsG3(uint32_t value) { mErrorCounter.mErrorRegister3 = value; }
 
  void setAltroCFGReg1(uint32_t value) { mAltroConfig.mWord1 = value; }
 
  void setAltroCFGReg2(uint32_t value) { mAltroConfig.mWord2 = value; }
 
  bool isInitialized() const { return mIsInitialized; }
 
  std::vector<uint32_t> encode() const;
 
  static RCUTrailer constructFromPayloadWords(const gsl::span<const uint32_t> payloadwords);
 
  static bool checkLastTrailerWord(uint32_t trailerword);
 
 private:
  struct AltroConfig {
    union {
      uint32_t mWord1 = 0; 
      struct {
        uint32_t mBaselineCorrection : 4;       
        uint32_t mPolarity : 1;                 
        uint32_t mNumPresamples : 2;            
        uint32_t mNumPostsamples : 4;           
        uint32_t mSecondBaselineCorrection : 1; 
        uint32_t mGlitchFilter : 2;             
        uint32_t mNumPostsamplesNoZS : 3;       
        uint32_t mNumPresamplesNoZS : 2;        
        uint32_t mZeroSuppression : 1;          
        uint32_t mZero1_1 : 12;                 
      };
    };
 
    union {
      uint32_t mWord2 = 0; 
      struct {
        uint32_t mL1Phase : 5;              
        uint32_t mSampleTime : 4;           
        uint32_t mSparseReadout : 1;        
        uint32_t mNumSamplesChannel : 10;   
        uint32_t mNumSamplesPretrigger : 4; 
        uint32_t mAltroBuffers : 1;         
        uint32_t mZero2_2 : 7;              
      };
    };
  };
 
  struct ErrorCounters {
    union {
      uint32_t mErrorRegister2 = 0; 
    };
    union {
      uint32_t mErrorRegister3 = 0; 
      struct {
        uint32_t mNumChannelAddressMismatch : 12; 
        uint32_t mNumChannelLengthMismatch : 13;  
        uint32_t mZero3_1 : 7;                    
      };
    };
  };
 
  int mRCUId = -1;                      
  uint8_t mFirmwareVersion = 0;         
  uint32_t mTrailerSize = 0;            
  uint32_t mPayloadSize = 0;            
  uint32_t mWordCorruptions = 0;        
  uint32_t mFECERRA = 0;                
  uint32_t mFECERRB = 0;                
  ErrorCounters mErrorCounter = {0, 0}; 
  uint16_t mActiveFECsA = 0;            
  uint16_t mActiveFECsB = 0;            
  AltroConfig mAltroConfig = {0, 0};    
  bool mIsInitialized = false;          
 
  ClassDefNV(RCUTrailer, 1);
};
 
std::ostream& operator<<(std::ostream& stream, const RCUTrailer& trailer);
 
} // namespace emcal
 
} // namespace o2
 
#endif