GBTRawDataChecker.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_MID_GBTRawDataChecker_H
#define O2_MID_GBTRawDataChecker_H
 
#include <cstdint>
#include <map>
#include <string>
#include <unordered_map>
#include <vector>
#include <gsl/gsl>
#include "DataFormatsMID/ROBoard.h"
#include "DataFormatsMID/ROFRecord.h"
#include "MIDRaw/ElectronicsDelay.h"
 
namespace o2
{
namespace mid
{
class GBTRawDataChecker
{
 public:
  void init(uint16_t gbtUniqueId, uint8_t mask);
  bool process(gsl::span<const ROBoard> localBoards, gsl::span<const ROFRecord> rofRecords, gsl::span<const ROFRecord> pageRecords);
  unsigned int getNEventsProcessed() const { return mStatistics[0]; }
  unsigned int getNEventsFaulty() const { return mStatistics[1]; }
  unsigned int getNBusyRaised() const { return mStatistics[2]; }
  std::string getDebugMessage() const { return mDebugMsg; }
  uint16_t getGBTUniqueId() const { return mGBTUniqueId; }
  void clear(bool all = false);
 
  void setElectronicsDelay(const ElectronicsDelay& electronicsDelay) { mElectronicsDelay = electronicsDelay; }
 
  void setSyncTrigger(uint32_t syncTrigger) { mSyncTrigger = syncTrigger; }
 
 private:
  struct Mask {
    std::array<uint16_t, 4> patternsBP{};  
    std::array<uint16_t, 4> patternsNBP{}; 
  };
 
  struct GBT {
    std::vector<ROBoard> regs{};   
    std::vector<ROBoard> locs{};   
    std::vector<long int> pages{}; 
  };
 
  struct BoardInfo {
    ROBoard board{};
    o2::InteractionRecord interactionRecord{};
    long int page{-1};
  };
 
  struct BusyInfo {
    bool isBusy{0};
    o2::InteractionRecord interactionRecord{};
  };
 
  void clearChecked(bool isTriggered, bool clearTrigEvents);
  bool checkEvent(bool isTriggered, const std::vector<ROBoard>& regs, const std::vector<ROBoard>& locs, const InteractionRecord& ir);
  bool checkEvents(bool isTriggered);
  bool checkConsistency(const ROBoard& board);
  bool checkConsistency(const std::vector<ROBoard>& boards);
  bool checkMasks(const std::vector<ROBoard>& locs);
  bool checkLocalBoardSize(const ROBoard& board);
  bool checkLocalBoardSize(const std::vector<ROBoard>& boards);
  bool checkRegLocConsistency(const std::vector<ROBoard>& regs, const std::vector<ROBoard>& locs, const InteractionRecord& ir);
  uint8_t getElinkId(const ROBoard& board) const;
  InteractionRecord getRawIR(uint8_t id, bool isTrigger, InteractionRecord ir) const;
  unsigned int getLastCompleteTrigEvent();
  bool isCompleteSelfTrigEvent(const o2::InteractionRecord& ir) const;
  std::string printBoards(const std::vector<ROBoard>& boards) const;
  bool runCheckEvents(unsigned int completeMask);
  void sortEvents(bool isTriggered);
 
  std::string mEventDebugMsg{};                   
  std::string mDebugMsg{};                        
  std::array<unsigned long int, 3> mStatistics{}; 
  std::unordered_map<uint8_t, Mask> mMasks;       
  uint8_t mCrateMask{0xFF};                       
  uint16_t mGBTUniqueId{0};                       
  uint16_t mResetVal{0};                          
  ElectronicsDelay mElectronicsDelay{};           
  uint32_t mSyncTrigger{raw::sORB};               
 
  std::map<o2::InteractionRecord, uint16_t> mTrigEvents{}; 
 
  std::array<std::vector<BusyInfo>, 10> mBusyPeriods{}; 
 
  std::array<std::vector<BoardInfo>, 10> mBoardsTrig{};     
  std::array<std::vector<BoardInfo>, 10> mBoardsSelfTrig{}; 
 
  std::unordered_map<uint64_t, std::vector<std::pair<uint8_t, size_t>>> mOrderedIndexesTrig{};     
  std::unordered_map<uint64_t, std::vector<std::pair<uint8_t, size_t>>> mOrderedIndexesSelfTrig{}; 
 
  std::unordered_map<uint8_t, long int> mLastIndexTrig{};     
  std::unordered_map<uint8_t, long int> mLastIndexSelfTrig{}; 
 
  o2::InteractionRecord mLastCompleteIRTrig{};     
  o2::InteractionRecord mLastCompleteIRSelfTrig{}; 
};
} // namespace mid
} // namespace o2
 
#endif /* O2_MID_GBTRawDataChecker_H */