PixelData.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_ITSMFT_PIXELDATA_H
#define ALICEO2_ITSMFT_PIXELDATA_H
 
#include "DataFormatsITSMFT/Digit.h"
#include "CommonDataFormat/InteractionRecord.h"
#include "ITSMFTReconstruction/DecodingStat.h"
 
#include <string>
#include <vector>
#include <utility>
#include <cstdint>
 
namespace o2
{
namespace itsmft
{
 
class PixelData
{
 
 public:
  PixelData(const Digit* dig) : mRow(dig->getRow()), mCol(dig->getColumn()) {}
  PixelData(uint16_t r = 0, uint16_t c = 0) : mRow(r), mCol(c) {}
  uint16_t getRow() const { return mRow & RowMask; }
  uint16_t getCol() const { return mCol; }
  bool isMasked() const { return mRow & MaskBit; }
  void setMask() { mRow |= MaskBit; }
  void unsetMask() { mRow &= RowMask; }
 
  uint16_t getRowDirect() const { return mRow; }
 
  bool operator==(const PixelData& dt) const
  {
    return (getCol() == dt.getCol()) && (getRow() == dt.getRow());
  }
 
  bool operator>(const PixelData& dt) const
  {
    if (getCol() == dt.getCol()) {
      return getRow() > dt.getRow();
    }
    return getCol() > dt.getCol();
  }
 
  bool operator<(const PixelData& dt) const
  {
    if (getCol() == dt.getCol()) {
      return getRow() < dt.getRow();
    }
    return getCol() < dt.getCol();
  }
 
  bool isNeighbour(const PixelData& dt, int maxDist) const
  {
    return (std::abs(static_cast<int>(getCol()) - static_cast<int>(dt.getCol())) <= maxDist &&
            std::abs(static_cast<int>(getRow()) - static_cast<int>(dt.getRow())) <= maxDist);
  }
 
  int compare(const PixelData& dt) const
  {
    return operator==(dt) ? 0 : (operator>(dt) ? 1 : -1);
  }
 
  static constexpr uint32_t DummyROF = 0xffffffff;
  static constexpr uint32_t DummyChipID = 0xffff;
 
 private:
  void sanityCheck() const;
  static constexpr int RowMask = 0x7FFF; 
  static constexpr int MaskBit = 0x8000; 
  uint16_t mRow = 0;                     
  uint16_t mCol = 0;                     
 
  ClassDefNV(PixelData, 1);
};
 
class ChipPixelData
{
 
 public:
  // total number of raw data bytes to save in case of error and number of bytes (if any) after problematic one
  static constexpr size_t MAXDATAERRBYTES = 16, MAXDATAERRBYTES_AFTER = 2;
  ChipPixelData() = default;
  ~ChipPixelData() = default;
  uint8_t getROFlags() const { return mROFlags; }
  uint16_t getChipID() const { return mChipID; }
  uint32_t getROFrame() const { return mROFrame; }
  uint32_t getStartID() const { return mStartID; }
  uint32_t getFirstUnmasked() const { return mFirstUnmasked; }
  uint32_t getTrigger() const { return mTrigger; }
  const o2::InteractionRecord& getInteractionRecord() const { return mInteractionRecord; }
  void setInteractionRecord(const o2::InteractionRecord& r) { mInteractionRecord = r; }
  const std::vector<PixelData>& getData() const { return mPixels; }
  std::vector<PixelData>& getData() { return (std::vector<PixelData>&)mPixels; }
 
  void setROFlags(uint8_t f = 0) { mROFlags = f; }
  void setChipID(uint16_t id) { mChipID = id; }
  void setROFrame(uint32_t r) { mROFrame = r; }
  void setStartID(uint32_t id) { mStartID = id; }
  void setFirstUnmasked(uint32_t n) { mFirstUnmasked = n; }
  void setTrigger(uint32_t t) { mTrigger = t; }
 
  void setError(ChipStat::DecErrors i) { mErrors |= 0x1UL << i; }
  void addErrorInfo(uint64_t b) { mErrorInfo |= b; }
  void setErrorInfo(uint64_t b) { mErrorInfo = b; }
  void setErrorFlags(uint64_t f) { mErrors |= f; }
  bool isErrorSet(ChipStat::DecErrors i) const { return mErrors & (0x1UL << i); }
  bool isErrorSet() const { return mErrors != 0; }
  auto getErrorFlags() const { return mErrors; }
  auto getErrorInfo() const { return mErrorInfo; }
  auto getNBytesInRawBuff() const { return int(mErrorInfo >> 32) & 0xff; }
  void setNBytesInRawBuff(int n) { mErrorInfo |= (uint64_t(n & 0xff)) << 32; }
  auto& getRawErrBuff() { return mRawBuff; }
  auto& getRawErrBuff() const { return mRawBuff; }
  std::string getErrorDetails(int pos) const;
 
  void resetChipID()
  {
    mChipID = -1;
  }
 
  void clear()
  {
    resetChipID();
    mPixels.clear();
    mROFlags = 0;
    mFirstUnmasked = 0;
    mErrors = 0;
    mErrorInfo = 0;
    mPixIds.clear();
    mPixelsOrder.clear();
  }
 
  void swap(ChipPixelData& other)
  {
    // swap content of two objects
    std::swap(mROFlags, other.mROFlags);
    std::swap(mChipID, other.mChipID);
    std::swap(mROFrame, other.mROFrame);
    std::swap(mFirstUnmasked, other.mFirstUnmasked); // strictly speaking, not needed
    std::swap(mStartID, other.mStartID);             // strictly speaking, not needed
    std::swap(mTrigger, other.mTrigger);
    std::swap(mErrors, other.mErrors);
    std::swap(mInteractionRecord, other.mInteractionRecord);
    mPixels.swap(other.mPixels);
  }
 
  void maskFiredInSample(const ChipPixelData& sample)
  {
    const auto& pixelsS = sample.getData();
    uint32_t nC = mPixels.size();
    if (!nC) {
      return;
    }
    uint32_t nS = pixelsS.size();
    if (!nS) {
      return;
    }
    uint32_t itC = 0, itS = 0;
    while (itC < nC && itS < nS) {
      auto& pix0 = mPixels[itC];
      const auto& pixC = pixelsS[itS];
      if (pix0 == pixC) { // same
        pix0.setMask();
        if (mFirstUnmasked == itC++) { // mFirstUnmasked should flag 1st unmasked pixel entry
          mFirstUnmasked = itC;
        }
        itS++;
      } else if (pix0 < pixC) {
        itC++;
      } else {
        itS++;
      }
    }
  }
 
  void maskFiredInSample(const ChipPixelData& sample, int maxDist)
  {
    const auto& pixelsS = sample.getData();
    int nC = mPixels.size();
    if (!nC) {
      return;
    }
    int nS = pixelsS.size();
    if (!nS) {
      return;
    }
    for (int itC = 0, itS = 0; itC < nC; itC++) {
      auto& pix0 = mPixels[itC];
 
      // seek to itS which is inferior than itC - maxDist
      auto mincol = pix0.getCol() > maxDist ? pix0.getCol() - maxDist : 0;
      auto minrow = pix0.getRowDirect() > maxDist ? pix0.getRowDirect() - maxDist : 0;
      if (itS == nS) { // in case itS lool below reached the end
        itS--;
      }
      while ((pixelsS[itS].getCol() > mincol || pixelsS[itS].getRow() > minrow) && itS > 0) {
        itS--;
      }
      for (; itS < nS; itS++) {
        const auto& pixC = pixelsS[itS];
 
        auto drow = static_cast<int>(pixC.getRow()) - static_cast<int>(pix0.getRowDirect());
        auto dcol = static_cast<int>(pixC.getCol()) - static_cast<int>(pix0.getCol());
 
        if (dcol > maxDist || (dcol == maxDist && drow > maxDist)) {
          break; // all higher itS will not match to this itC also
        }
        if (dcol < -maxDist || (drow > maxDist || drow < -maxDist)) {
          continue;
        } else {
          pix0.setMask();
          if (int(mFirstUnmasked) == itC) { // mFirstUnmasked should flag 1st unmasked pixel entry
            mFirstUnmasked = itC + 1;
          }
          break;
        }
      }
    }
  }
 
  template <typename Func>
  void forEachSetError(Func f) const
  {
    auto outer = [&](int errIdx) {
      if (getErrorFlags() && (getErrorFlags() & (0x1UL << errIdx))) {
        f(errIdx);
      }
    };
    ChipStat::forEachError(outer);
  }
 
  std::string reportErrors() const
  {
    std::string res;
    bool first = true;
    auto inner = [&](int errIdx) {
      if (!first) {
        res += ", ";
      }
      res += ChipStat::ErrNames[errIdx];
      first = false;
    };
    forEachSetError(inner);
    return res;
  }
 
  void print() const;
  std::vector<uint32_t>& getPixIds() { return mPixIds; }
  std::vector<int>& getPixelsOrder() { return mPixelsOrder; }
  uint32_t getOrderedPixId(int pos) const { return mPixIds[mPixelsOrder[pos]]; }
 
 private:
  uint8_t mROFlags = 0;                            // readout flags from the chip trailer
  uint16_t mChipID = 0;                            // chip id within the detector
  uint32_t mROFrame = 0;                           // readout frame ID
  uint32_t mFirstUnmasked = 0;                     // first unmasked entry in the mPixels
  uint32_t mStartID = 0;                           // entry of the 1st pixel data in the whole detector data, for MCtruth access
  uint32_t mTrigger = 0;                           // trigger pattern
  uint64_t mErrors = 0;                            // errors set during decoding
  uint64_t mErrorInfo = 0;                         // optional extra info on the error
  std::array<uint8_t, MAXDATAERRBYTES> mRawBuff{}; // buffer for raw data showing an error
  o2::InteractionRecord mInteractionRecord = {};   // interaction record
  std::vector<PixelData> mPixels;                  // vector of pixels
  std::vector<uint32_t> mPixIds;                   // vector of label indices in case of squashing+Monte Carlo
  std::vector<int> mPixelsOrder;                   // vector to get ordered access to pixel ids
 
  ClassDefNV(ChipPixelData, 2);
};
} // namespace itsmft
} // namespace o2
 
#endif // ALICEO2_ITSMFT_PIXELDATA_H