PedestalData.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_CALIBRATION_PEDESTAL_DATA_H_
#define O2_MCH_CALIBRATION_PEDESTAL_DATA_H_
 
#include "MCHCalibration/PedestalChannel.h"
#include "MCHCalibration/PedestalDigit.h"
#include "MCHRawElecMap/Mapper.h"
#include "Rtypes.h"
#include <array>
#include <gsl/span>
#include <unordered_map>
 
namespace o2::mch::calibration
{
 
class PedestalDigit;
class PedestalData;
 
namespace impl
{
template <typename T>
class PedestalDataIterator;
}
 
class PedestalData
{
 public:
  using iterator = impl::PedestalDataIterator<PedestalChannel>;
  using const_iterator = impl::PedestalDataIterator<const PedestalChannel>;
 
  friend iterator;
  friend const_iterator;
 
  iterator begin();
  iterator end();
  const_iterator cbegin() const;
  const_iterator cend() const;
 
  PedestalData();
  ~PedestalData() = default;
 
  void reset();
 
  static constexpr int MAXDS = 40;      // max number of dual sampas per solar
  static constexpr int MAXCHANNEL = 64; // max number of channels per dual sampa
 
  using PedestalMatrix = std::array<std::array<PedestalChannel, MAXCHANNEL>, MAXDS>;
  using PedestalsMap = std::unordered_map<int, PedestalMatrix>;
 
  void fill(const gsl::span<const PedestalDigit> digits);
 
  void merge(const PedestalData* other);
 
  void print() const;
 
  uint32_t size() const;
 
 private:
  PedestalData::PedestalMatrix initPedestalMatrix(uint16_t solarId);
 
  o2::mch::raw::Solar2FeeLinkMapper mSolar2FeeLinkMapper;
  o2::mch::raw::Elec2DetMapper mElec2DetMapper;
 
  PedestalsMap mPedestals{}; 
  uint32_t mSize{0};         
 
  ClassDefNV(PedestalData, 1)
};
 
namespace impl
{
template <typename T>
class PedestalDataIterator
{
 public:
  using value_type = T;
  using difference_type = std::ptrdiff_t;
  using pointer = T*;
  using reference = T&;
  using iterator_category = std::forward_iterator_tag;
 
  PedestalDataIterator() = default;
  explicit PedestalDataIterator(PedestalData* data) : mData{data},
                                                      mMapIt{},
                                                      mCol{0},
                                                      mRow{0}
  {
    if (mData && mData->size() == 0) {
      mData = nullptr;
    }
    if (mData) {
      mMapIt = mData->mPedestals.begin();
    }
  }
 
  reference operator*() const
  {
    return mMapIt->second[mRow][mCol];
  }
  pointer operator->() const
  {
    return &mMapIt->second[mRow][mCol];
  }
 
  bool advance()
  {
    if (mMapIt != mData->mPedestals.end()) {
      if (mCol < PedestalData::MAXCHANNEL - 1) {
        mCol++;
        return true;
      }
      if (mRow < PedestalData::MAXDS - 1) {
        mCol = 0;
        mRow++;
        return true;
      }
      ++mMapIt;
      mCol = 0;
      mRow = 0;
      if (mMapIt != mData->mPedestals.end()) {
        return true;
      }
      mData = nullptr;
    }
    // undefined behavior here (should not increment an end iterator)
    return false;
  }
 
  PedestalDataIterator& operator++()
  {
    while (advance()) {
      if ((*this)->isValid()) {
        break;
      }
    }
    // undefined behavior here (should not increment an end iterator)
    return *this;
  }
 
  bool operator==(const PedestalDataIterator& rhs)
  {
    return mData == rhs.mData &&
           mMapIt == rhs.mMapIt &&
           mCol == rhs.mCol &&
           mRow == rhs.mRow;
  }
 
  bool operator!=(const PedestalDataIterator& rhs) { return !(*this == rhs); }
 
  PedestalDataIterator operator++(int)
  {
    auto tmp = *this;
    ++(*this);
    return tmp;
  }
 
 private:
  PedestalData* mData;
  PedestalData::PedestalsMap::iterator mMapIt;
  int mCol;
  int mRow;
};
} // namespace impl
 
} // namespace o2::mch::calibration
#endif