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_PHOS_ALTRODECODER_H
#define ALICEO2_PHOS_ALTRODECODER_H
 
#include <iosfwd>
#include <gsl/span>
#include <string>
#include <bitset>
#include "PHOSBase/RCUTrailer.h"
#include "DataFormatsPHOS/Cell.h"
#include "PHOSBase/Mapping.h"
#include "PHOSReconstruction/RawReaderError.h"
#include "PHOSReconstruction/CaloRawFitter.h"
#include "PHOSReconstruction/RawReaderMemory.h"
 
namespace o2
{
namespace phos
{
 
class AltroDecoderError : public std::exception
{
 public:
  enum ErrorType_t {
    kOK,                      
    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 char* message) : mErrorType(errtype), mErrorMessage(message) {}
 
  ~AltroDecoderError() 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; 
};
 
 
class AltroDecoder
{
 public:
  AltroDecoder() = default;
 
  ~AltroDecoder() = default;
 
  AltroDecoderError::ErrorType_t decode(RawReaderMemory& rawreader, CaloRawFitter* rawFitter,
                                        std::vector<o2::phos::Cell>& cellContainer,
                                        std::vector<o2::phos::Cell>& truContainer);
 
  const std::vector<o2::phos::RawReaderError>& hwerrors() { return mOutputHWErrors; }
 
  const std::vector<short>& chi2list() { return mOutputFitChi; }
 
  const RCUTrailer& getRCUTrailer() const { return mRCUTrailer; }
 
  void readChannels(const std::vector<uint32_t>& payloadwords, CaloRawFitter* rawFitter,
                    std::vector<o2::phos::Cell>& cellContainer,
                    std::vector<o2::phos::Cell>& truContainer);
  void setPedestalRun()
  {
    mPedestalRun = true;
    mCombineGHLG = false;
  }
  void setCombineHGLG(bool a) { mCombineGHLG = a; }
 
  void setKeepTruNoise(bool a) { mKeepTruNoise = a; }
 
  void setPresamples(int ps) { mPreSamples = ps; }
 
 private:
  union truDigitPack {
    int32_t mDataWord;
    struct {
      int32_t mHeader : 1; 
      int32_t mAmp : 15;   
      int32_t mTime : 16;  
    };
  };
 
  static constexpr int kGeneralSRUErr = 15; 
  static constexpr int kGeneralTRUErr = 16; 
  // check and convert HW address to absId and caloFlag
  bool hwToAbsAddress(short hwaddress, short& absId, Mapping::CaloFlag& caloFlag);
  // read trigger digits
  void readTRUDigits(short absId, int payloadSize);
  // read trigger summary tables
  void readTRUFlags(short hwAddress, int payloadSize);
  // Check if TRU digit belongs/matches TRU flag
  bool matchTruDigits(const Cell& cTruFlag, float& sumAmp);
 
  bool mCombineGHLG = true;                              
  bool mPedestalRun = false;                             
  bool mKeepTruNoise = false;                            
  short mddl;                                            
  short mPreSamples = 0;                                 
  std::vector<uint16_t> mBunchwords;                     
  std::vector<o2::phos::RawReaderError> mOutputHWErrors; 
  std::vector<short> mOutputFitChi;                      
  std::vector<Cell> mTRUFlags;                           
  std::array<int32_t, 224> mTRUDigits;                   
  std::bitset<128> mFlag4x4Bitset;
  std::bitset<128> mFlag2x2Bitset;
  RCUTrailer mRCUTrailer; 
 
  ClassDefNV(AltroDecoder, 2);
};
 
} // namespace phos
 
} // namespace o2
 
#endif