CalArray.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_TPC_CALARRAY_H_
#define ALICEO2_TPC_CALARRAY_H_
 
#include <algorithm>
#include <memory>
#include <vector>
#include <string>
#include <numeric>
#include <type_traits>
 
#include "TPCBase/Mapper.h"
 
#ifndef GPUCA_ALIGPUCODE
#include "Framework/Logger.h"
#include <boost/format.hpp>
#endif
 
#ifdef NDEBUG
#undef NDEBUG
#include <cassert>
#endif
 
namespace o2
{
namespace tpc
{
 
template <class T>
class CalArray
{
 public:
  CalArray() = default;
 
  ~CalArray() = default;
 
  CalArray(const PadSubset padSubset, const int padSubsetNumber)
    : mName(),
      mData(),
      mPadSubset(padSubset),
      mPadSubsetNumber(padSubsetNumber)
  {
    // initialize the data array
    initData();
  }
 
  CalArray(const std::string_view name, const int padSubsetNumber)
    : mName(name),
      mData(),
      mPadSubset(PadSubset::ROC),
      mPadSubsetNumber(padSubsetNumber)
  {
    // initialize the data array
    initData();
  }
 
  CalArray(const std::string_view name, const PadSubset padSubset, const int padSubsetNumber)
    : mName(name),
      mData(),
      mPadSubset(padSubset),
      mPadSubsetNumber(padSubsetNumber)
  {
    // initialize the data array
    initData();
  }
 
  PadSubset getPadSubset() const { return mPadSubset; }
 
  int getPadSubsetNumber() const { return mPadSubsetNumber; }
 
  void setValue(const size_t channel, const T& value) { mData[channel] = value; }
  const T getValue(const size_t channel) const
  {
    assert(channel < mData.size());
    return mData[channel];
  }
 
  void setValue(const size_t row, const size_t pad, const T& value);
  const T getValue(const size_t row, const size_t pad) const;
 
  void setName(const std::string& name) { mName = name; }
  const std::string& getName() const { return mName; }
 
  const std::vector<T>& getData() const { return mData; }
  std::vector<T>& getData() { return mData; }
 
  template <typename U = T>
  const U getSum() const
  {
    return std::accumulate(mData.begin(), mData.end(), U{});
  }
 
  const CalArray<T>& multiply(const T& val) { return *this *= val; }
 
  const CalArray& operator+=(const CalArray& other);
 
  const CalArray& operator-=(const CalArray& other);
 
  const CalArray& operator*=(const CalArray& other);
 
  const CalArray& operator/=(const CalArray& other);
 
  bool operator==(const CalArray& other) const;
 
  const CalArray& operator+=(const T& val);
 
  const CalArray& operator-=(const T& val);
 
  const CalArray& operator*=(const T& val);
 
  const CalArray& operator/=(const T& val);
 
  const CalArray& operator=(const T& val)
  {
    std::fill(mData.begin(), mData.end(), val);
    return *this;
  }
 
  template <typename U = T>
  U getMean() const
  {
    const auto& vals = mData;
    const U nVal = static_cast<U>(vals.size());
    const U sum = std::accumulate(vals.begin(), vals.end(), 0.f);
 
    return (nVal > 0) ? sum / nVal : U{0};
  }
 
 private:
  std::string mName;
  // better to use std::array?
  // std::vector<T, Vc::Allocator<T>> mData;
  // how to use Vc::Allocator in this case? Specialisation for float, double, etc?
  std::vector<T> mData; 
  PadSubset mPadSubset; 
  int mPadSubsetNumber; 
 
  void initData();
};
 
#ifndef GPUCA_ALIGPUCODE
 
// ===| pad region etc. initialisation |========================================
template <class T>
void CalArray<T>::initData()
{
  const auto& mapper = Mapper::instance();
 
  switch (mPadSubset) {
    case PadSubset::ROC: {
      mData.resize(ROC(mPadSubsetNumber).rocType() == RocType::IROC ? mapper.getPadsInIROC() : mapper.getPadsInOROC());
      if (mName.empty()) {
        setName(boost::str(boost::format("ROC_%1$02d") % mPadSubsetNumber));
      }
      break;
    }
    case PadSubset::Partition: {
      mData.resize(mapper.getPartitionInfo(mPadSubsetNumber % mapper.getNumberOfPartitions()).getNumberOfPads());
      if (mName.empty()) {
        setName(boost::str(boost::format("Partition_%1$03d") % mPadSubsetNumber));
      }
      break;
    }
    case PadSubset::Region: {
      mData.resize(mapper.getPadRegionInfo(mPadSubsetNumber % mapper.getNumberOfPadRegions()).getNumberOfPads());
      if (mName.empty()) {
        setName(boost::str(boost::format("Region_%1$03d") % mPadSubsetNumber));
      }
      break;
    }
  }
}
//______________________________________________________________________________
template <class T>
inline void CalArray<T>::setValue(const size_t row, const size_t pad, const T& value)
{
  const auto& mapper = Mapper::instance();
  size_t position = mapper.getPadNumber(mPadSubset, mPadSubsetNumber, row, pad);
  setValue(position, value);
}
 
//______________________________________________________________________________
template <class T>
inline const T CalArray<T>::getValue(const size_t row, const size_t pad) const
{
  const auto& mapper = Mapper::instance();
  size_t position = mapper.getPadNumber(mPadSubset, mPadSubsetNumber, row, pad);
  return getValue(position);
}
 
//______________________________________________________________________________
template <class T>
inline const CalArray<T>& CalArray<T>::operator+=(const CalArray<T>& other)
{
  if (!((mPadSubset == other.mPadSubset) && (mPadSubsetNumber == other.mPadSubsetNumber))) {
    LOG(error) << "You are trying to operate on incompatible objects: Pad subset type and number must be the same on both objects";
    return *this;
  }
  for (size_t i = 0; i < mData.size(); ++i) {
    if constexpr (std::is_same_v<T, bool>) {
      mData[i] = mData[i] | other.getValue(i);
    } else {
      mData[i] += other.getValue(i);
    }
  }
  return *this;
}
 
//______________________________________________________________________________
template <class T>
inline const CalArray<T>& CalArray<T>::operator-=(const CalArray<T>& other)
{
  if (!((mPadSubset == other.mPadSubset) && (mPadSubsetNumber == other.mPadSubsetNumber))) {
    LOG(error) << "You are trying to operate on incompatible objects: Pad subset type and number must be the same on both objects";
    return *this;
  }
  for (size_t i = 0; i < mData.size(); ++i) {
    mData[i] -= other.getValue(i);
  }
  return *this;
}
 
//______________________________________________________________________________
template <class T>
inline const CalArray<T>& CalArray<T>::operator*=(const CalArray<T>& other)
{
  if (!((mPadSubset == other.mPadSubset) && (mPadSubsetNumber == other.mPadSubsetNumber))) {
    LOG(error) << "pad subset type of the objects it not compatible";
    return *this;
  }
  for (size_t i = 0; i < mData.size(); ++i) {
    if constexpr (std::is_same_v<T, bool>) {
      mData[i] = mData[i] & other.getValue(i);
    } else {
      mData[i] *= other.getValue(i);
    }
  }
  return *this;
}
 
//______________________________________________________________________________
template <class T>
inline const CalArray<T>& CalArray<T>::operator/=(const CalArray<T>& other)
{
  if (!((mPadSubset == other.mPadSubset) && (mPadSubsetNumber == other.mPadSubsetNumber))) {
    LOG(error) << "pad subset type of the objects it not compatible";
    return *this;
  }
  for (size_t i = 0; i < mData.size(); ++i) {
    if (other.getValue(i) != 0) {
      mData[i] /= other.getValue(i);
    } else {
      mData[i] = 0;
      LOG(debug) << "Division by 0 detected! Value was set to 0.";
    }
  }
  return *this;
}
 
//______________________________________________________________________________
template <class T>
inline bool CalArray<T>::operator==(const CalArray<T>& other) const
{
  if (!((mPadSubset == other.mPadSubset) && (mPadSubsetNumber == other.mPadSubsetNumber))) {
    LOG(error) << "pad subset type of the objects it not compatible";
    return false;
  }
  bool isSame = (mData == other.mData);
  return isSame;
}
 
//______________________________________________________________________________
template <class T>
inline const CalArray<T>& CalArray<T>::operator+=(const T& val)
{
  for (auto& data : mData) {
    data += val;
  }
  return *this;
}
 
//______________________________________________________________________________
template <class T>
inline const CalArray<T>& CalArray<T>::operator-=(const T& val)
{
  for (auto& data : mData) {
    data -= val;
  }
  return *this;
}
 
//______________________________________________________________________________
template <class T>
inline const CalArray<T>& CalArray<T>::operator*=(const T& val)
{
  for (auto& data : mData) {
    data *= val;
  }
  return *this;
}
 
//______________________________________________________________________________
template <class T>
inline const CalArray<T>& CalArray<T>::operator/=(const T& val)
{
  for (auto& data : mData) {
    data /= val;
  }
  return *this;
}
 
using CalROC = CalArray<float>;
 
#endif // GPUCA_ALIGPUCODE
 
} // namespace tpc
} // namespace o2
 
#endif