DataDecoder.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 O2_MCH_DATADECODER_H_
#define O2_MCH_DATADECODER_H_
 
#include <gsl/span>
#include <unordered_set>
#include <unordered_map>
#include <fstream>
 
#include "Headers/RDHAny.h"
#include "DataFormatsMCH/Digit.h"
#include "MCHBase/DecoderError.h"
#include "MCHBase/HeartBeatPacket.h"
#include "MCHRawDecoder/OrbitInfo.h"
#include "MCHRawDecoder/PageDecoder.h"
 
namespace o2
{
namespace mch
{
namespace raw
{
 
using RdhHandler = std::function<void(o2::header::RDHAny*)>;
 
// custom hash for OrbitInfo objects
struct OrbitInfoHash {
  std::size_t operator()(const OrbitInfo& info) const noexcept
  {
    return std::hash<uint64_t>{}(info.get());
  }
};
 
void dumpOrbits(const std::unordered_set<OrbitInfo, OrbitInfoHash>& mOrbits);
 
//_________________________________________________________________
//
// Data decoder
//_________________________________________________________________
class DataDecoder
{
 public:
  static constexpr int32_t tfTimeMax{0x7FFFFFFF};
  static constexpr int32_t tfTimeInvalid{-tfTimeMax};
 
  enum class TimeRecoMode : uint8_t {
    HBPackets = 0,
    BCReset = 1
  };
 
  struct SampaInfo {
    union {
      uint32_t id = 0;
      struct {
        uint32_t chip : 1;
        uint32_t ds : 6;
        uint32_t solar : 16;
        uint32_t unused : 9;
      };
    };
 
    union {
      // default value
      uint64_t time = 0x0000000000000000;
      struct {                       
        uint32_t sampaTime : 10;     
        uint32_t bunchCrossing : 20; 
        uint32_t reserved : 2;       
        uint32_t orbit;              
      };                             
    };
    uint32_t getBXTime() const
    {
      return (bunchCrossing + (sampaTime * 4));
    }
    int32_t tfTime;
    bool timeValid() const
    {
      return (tfTime != tfTimeInvalid);
    }
 
    bool operator==(const SampaInfo&) const;
    bool operator<(const SampaInfo& rhs) const
    {
      if (id < rhs.id) {
        return true;
      } else if (time < rhs.time) {
        return true;
      }
      return false;
    }
  };
 
  struct TimeFrameStartRecord {
    TimeFrameStartRecord() = default;
 
    bool update(uint32_t orbit, uint32_t bunchCrossing, bool verbose = false);
    bool check(int32_t orbit, uint32_t bc, int32_t orbitRef, uint32_t bcRef, bool verbose = false);
 
    int64_t mOrbit{-1};
    int64_t mBunchCrossing{-1};
 
    int64_t mOrbitPrev{-1};
    int64_t mBunchCrossingPrev{-1};
 
    bool mValid{true};
  };
 
  struct RawDigit {
    o2::mch::Digit digit;
    SampaInfo info;
    auto getDetID() const { return digit.getDetID(); }
    auto getPadID() const { return digit.getPadID(); }
    uint32_t getADC() const { return digit.getADC(); }
    auto getTime() const { return info.tfTime; }
    bool timeValid() const { return info.timeValid(); }
    auto getOrbit() const { return info.orbit; }
    auto getBunchCrossing() const { return info.bunchCrossing; }
    auto getSampaTime() const { return info.sampaTime; }
    auto getBXTime() const { return info.getBXTime(); }
 
    bool operator==(const RawDigit&) const;
  };
 
  using RawDigitVector = std::vector<RawDigit>;
 
  DataDecoder(SampaChannelHandler channelHandler, RdhHandler rdhHandler,
              std::string mapCRUfile, std::string mapFECfile,
              bool ds2manu, bool verbose, bool useDummyElecMap,
              TimeRecoMode timeRecoMode = TimeRecoMode::HBPackets,
              uint32_t nofOrbitsPerTF = 32);
 
  void reset();
 
  /* set the number of orbits that comprise one time frame. */
  void setOrbitsInTF(uint32_t nofOrbitsPerTF) { mOrbitsInTF = nofOrbitsPerTF; }
 
  void setFirstOrbitInTF(uint32_t orbit);
 
  bool decodeBuffer(gsl::span<const std::byte> buf);
 
  void updateTimeFrameStartRecord(uint64_t chipId, uint32_t mFirstOrbitInTF, uint32_t bcTF);
  static uint64_t getChipId(uint32_t solar, uint32_t ds, uint32_t chip);
  static int32_t getDigitTimeHBPackets(uint32_t orbitTF, uint32_t bcTF, uint32_t orbitDigit, uint32_t bcDigit);
  void computeDigitsTimeHBPackets();
  int32_t getDigitTimeBCRst(uint32_t orbitTF, uint32_t bcTF, uint32_t orbitDigit, uint32_t bcDigit);
  void computeDigitsTimeBCRst();
  void computeDigitsTime();
 
  const RawDigitVector& getDigits() const { return mDigits; }
  const std::unordered_set<OrbitInfo, OrbitInfoHash>& getOrbits() const { return mOrbits; }
  const std::vector<o2::mch::DecoderError>& getErrors() const { return mErrors; }
  const std::vector<o2::mch::HeartBeatPacket>& getHBPackets() const { return mHBPackets; }
  void setDigits(const RawDigitVector& digits) { mDigits = digits; }
 
  void logErrorMap(int tfcount) const;
 
 private:
  void initElec2DetMapper(std::string filename);
  void initFee2SolarMapper(std::string filename);
  void init();
  void decodePage(gsl::span<const std::byte> page);
  void dumpDigits();
  bool getPadMapping(const DsElecId& dsElecId, DualSampaChannelId channel, int& deId, int& dsIddet, int& padId);
  bool addDigit(const DsElecId& dsElecId, DualSampaChannelId channel, const o2::mch::raw::SampaCluster& sc);
  bool getTimeFrameStartRecord(const RawDigit& digit, uint32_t& orbit, uint32_t& bc);
  bool getMergerChannelId(const DsElecId& dsElecId, DualSampaChannelId channel, uint32_t& chId, uint32_t& dsId);
  uint64_t getMergerChannelBitmask(DualSampaChannelId channel);
  void updateMergerRecord(uint32_t mergerChannelId, uint32_t mergerBoardId, uint64_t mergerChannelBitmask, uint32_t digitId);
  bool mergeDigits(uint32_t mergerChannelId, uint32_t mergerBoardId, uint64_t mergerChannelBitmask, o2::mch::raw::SampaCluster& sc);
 
  // structure that stores the index of the last decoded digit for a given readout channel,
  // as well as the time stamp of the last ADC sample of the digit
  struct MergerChannelRecord {
    MergerChannelRecord() = default;
    uint32_t digitId{0xFFFF};
    uint32_t bcEnd{0xFFFF};
  };
 
  static constexpr uint32_t sMaxSolarId = 200 * 8 - 1;
  static constexpr uint32_t sReadoutBoardsNum = (sMaxSolarId + 1) * 40;
  static constexpr uint32_t sReadoutChipsNum = sReadoutBoardsNum * 2;
  static constexpr uint32_t sReadoutChannelsNum = sReadoutChipsNum * 32;
  // table storing the last recorded TF time stamp in SAMPA BC counter units
  std::vector<TimeFrameStartRecord> mTimeFrameStartRecords;
 
  TimeRecoMode mTimeRecoMode{TimeRecoMode::HBPackets}; 
 
  // table storing the digits merging information for each readout channel in the MCH system
  std::vector<MergerChannelRecord> mMergerRecords; 
  std::vector<uint64_t> mMergerRecordsReady;       
 
  Elec2DetMapper mElec2Det{nullptr};       
  FeeLink2SolarMapper mFee2Solar{nullptr}; 
  std::string mMapFECfile;                 
  std::string mMapCRUfile;                 
 
  o2::mch::raw::PageDecoder mDecoder; 
 
  RawDigitVector mDigits;                               
  std::unordered_set<OrbitInfo, OrbitInfoHash> mOrbits; 
  std::vector<o2::mch::DecoderError> mErrors;           
  std::vector<o2::mch::HeartBeatPacket> mHBPackets;     
 
  uint32_t mOrbitsInTF;         
  uint32_t mBcInOrbit;          
  uint32_t mFirstOrbitInTF;     
  uint32_t mSampaTimeOffset{0}; 
 
  SampaChannelHandler mChannelHandler;                  
  std::function<void(o2::header::RDHAny*)> mRdhHandler; 
 
  bool mDebug{false};
  int mErrorCount{0};
  bool mDs2manu{false};
  uint32_t mOrbit{0};
  bool mUseDummyElecMap{false};
  std::map<std::string, uint64_t> mErrorMap; // counts for error messages
};
 
bool operator<(const DataDecoder::RawDigit& d1, const DataDecoder::RawDigit& d2);
 
std::ostream& operator<<(std::ostream& os, const DataDecoder::RawDigit& d);
 
std::string asString(const DataDecoder::RawDigit& d);
 
} // namespace raw
} // namespace mch
} // end namespace o2
#endif // O2_MCH_DATADECODER_H_