IDCContainer.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_IDCCONTAINER_H_
#define ALICEO2_TPC_IDCCONTAINER_H_
 
#include <array>
#include <vector>
#include <limits>
#include "DataFormatsTPC/Defs.h"
#include "TPCCalibration/IDCGroupingParameter.h"
#include "TPCCalibration/SACParameter.h"
 
namespace o2
{
namespace tpc
{
 
enum class IDCType { IDC = 0,       
                     IDCZero = 1,   
                     IDCOne = 2,    
                     IDCDelta = 3,  
                     IDCOutlier = 4 //< IDCOutlier: for outlier maps
};
 
using SACType = IDCType;
 
enum class IDCDeltaCompression { NO = 0,     
                                 MEDIUM = 1, 
                                 HIGH = 2    
};
 
template <typename DataT>
struct IDCDeltaContainer {
  std::vector<DataT> mIDCDeltaCont{}; 
};
 
struct IDCDeltaCompressionFactors {
  std::pair<float, float> mFactors{std::pair{1.f, 1.f}}; 
};
 
template <typename DataT>
struct IDCDelta {
 
  void setValue(const float idcDelta, const unsigned int index) { mIDCDelta.mIDCDeltaCont[index] = compressValue(idcDelta); }
 
  void emplace_back(const float idcDelta) { mIDCDelta.mIDCDeltaCont.emplace_back(compressValue(idcDelta)); }
 
  DataT compressValue(float idcDelta) const
  {
    idcDelta = (std::clamp(idcDelta, mCompressionFactor.mFactors.first, mCompressionFactor.mFactors.second) - mCompressionFactor.mFactors.first) * std::numeric_limits<DataT>::max() / (mCompressionFactor.mFactors.second - mCompressionFactor.mFactors.first);
    return std::nearbyint(idcDelta);
  }
 
  float getValue(const unsigned int index) const { return mCompressionFactor.mFactors.first + (mCompressionFactor.mFactors.second - mCompressionFactor.mFactors.first) * static_cast<float>(mIDCDelta.mIDCDeltaCont[index]) / std::numeric_limits<DataT>::max(); }
 
  void setCompressionFactor(const float factorMin, const float factorMax) { mCompressionFactor.mFactors = std::pair{factorMin, factorMax}; }
 
  const auto& getIDCDelta() const { return mIDCDelta.mIDCDeltaCont; }
 
  auto& getIDCDelta() { return mIDCDelta.mIDCDeltaCont; }
 
  void setIDCDelta(const unsigned int index, const DataT val) { mIDCDelta.mIDCDeltaCont[index] = val; }
 
  const auto& getCompressionFactors() const { return mCompressionFactor; }
 
  auto getCompressionFactor() const { return mCompressionFactor.mFactors; }
 
  auto getNIDCs() const { return getIDCDelta().size(); }
 
  IDCDeltaContainer<DataT> mIDCDelta{};            
  IDCDeltaCompressionFactors mCompressionFactor{}; 
  ClassDefNV(IDCDelta, 2)
};
 
// template specialization for float as no compression factor is needed in this case
template <>
struct IDCDelta<float> {
  void setValue(const float idcDelta, const unsigned int index) { mIDCDelta.mIDCDeltaCont[index] = idcDelta; }
 
  float getValue(const unsigned int index) const { return mIDCDelta.mIDCDeltaCont[index]; }
 
  const auto& getIDCDelta() const { return mIDCDelta.mIDCDeltaCont; }
 
  auto& getIDCDelta() { return mIDCDelta.mIDCDeltaCont; }
 
  auto getIDCDeltaContainer() && { return std::move(mIDCDelta); }
 
  void setIDCDelta(const unsigned int index, const float val) { mIDCDelta.mIDCDeltaCont[index] = val; }
 
  void resize(const unsigned int size) { mIDCDelta.mIDCDeltaCont.resize(size); }
 
  auto getNIDCs() const { return getIDCDelta().size(); }
 
  IDCDeltaContainer<float> mIDCDelta{}; 
  ClassDefNV(IDCDelta, 2)
};
 
struct IDCZero {
 
  void setValueIDCZero(const float idcZero, const unsigned int index) { mIDCZero[index] = idcZero; }
 
  void fillValueIDCZero(const float idcZero, const unsigned int index) { mIDCZero[index] += idcZero; }
 
  float getValueIDCZero(const unsigned int index) const { return mIDCZero[index]; }
 
  void clear() { mIDCZero.clear(); }
 
  bool empty() const { return mIDCZero.empty(); }
 
  void resize(const unsigned int size) { mIDCZero.resize(size); }
 
  auto getNIDC0() const { return mIDCZero.size(); }
 
  IDCZero& operator+=(const IDCZero& idczero)
  {
    std::transform(mIDCZero.begin(), mIDCZero.end(), idczero.mIDCZero.begin(), mIDCZero.begin(), std::plus<>());
    return *this;
  }
 
  IDCZero& operator/=(const float value)
  {
    std::transform(mIDCZero.begin(), mIDCZero.end(), mIDCZero.begin(), [value](float idczero) { return idczero / value; });
    return *this;
  }
 
  std::vector<float> mIDCZero{}; 
  ClassDefNV(IDCZero, 2)
};
 
struct ITPCZero {
  IDCZero mIQMaxA; 
  IDCZero mIQMaxC; 
  IDCZero mIQTotA; 
  IDCZero mIQTotC; 
  IDCZero mINClA;  
  IDCZero mINClC;  
  ClassDefNV(ITPCZero, 1)
};
 
struct IDCOne {
 
  IDCOne() = default;
 
  IDCOne(const unsigned int nIDC) : mIDCOne{std::vector<float>(nIDC)} {};
 
  IDCOne(const unsigned int nIDC, const float val) : mIDCOne{std::vector<float>(nIDC, val)} {};
 
  void setValueIDCOne(const float idcOne, const unsigned int index) { mIDCOne[index] = idcOne; }
 
  float getValueIDCOne(const unsigned int index) const { return mIDCOne[index]; }
 
  auto getNIDCs() const { return mIDCOne.size(); }
 
  void clear() { mIDCOne.clear(); }
 
  void resize(const unsigned int size) { mIDCOne.resize(size); }
 
  void append(const IDCOne& idcone) { mIDCOne.insert(mIDCOne.end(), idcone.mIDCOne.begin(), idcone.mIDCOne.end()); }
 
  IDCOne& operator*=(const float value)
  {
    std::transform(mIDCOne.begin(), mIDCOne.end(), mIDCOne.begin(), [value](float idcone) { return idcone * value; });
    return *this;
  }
 
  std::vector<float> mIDCOne{};       
  std::vector<float> mIDCOneMedian{}; 
  std::vector<float> mIDCOneRMS{};    
  ClassDefNV(IDCOne, 3)
};
 
class IDCOneAggregator
{
 public:
  void aggregate1DIDCs(const o2::tpc::Side side, const std::vector<float>& idc)
  {
    if (mIDCOneAgg[side].mIDCOne.empty()) {
      mIDCOneAgg[side].mIDCOne = idc;
    } else {
      std::transform(mIDCOneAgg[side].mIDCOne.begin(), mIDCOneAgg[side].mIDCOne.end(), idc.begin(), mIDCOneAgg[side].mIDCOne.begin(), std::plus<>());
    }
  }
 
  void aggregate1DIDCsWeights(const o2::tpc::Side side, const std::vector<unsigned int>& idcCount)
  {
    if (mWeight[side].empty()) {
      mWeight[side] = idcCount;
    } else {
      std::transform(mWeight[side].begin(), mWeight[side].end(), idcCount.begin(), mWeight[side].begin(), std::plus<>());
    }
  }
 
  void normalizeIDCOne()
  {
    normalizeIDCOne(Side::A);
    normalizeIDCOne(Side::C);
  }
 
  void normalizeIDCOne(const o2::tpc::Side side)
  {
    std::transform(mIDCOneAgg[side].mIDCOne.begin(), mIDCOneAgg[side].mIDCOne.end(), mWeight[side].begin(), mIDCOneAgg[side].mIDCOne.begin(), std::divides<>());
  }
 
  auto get(const Side side) &&
  {
    mWeight[side].clear();
    return std::move(mIDCOneAgg[side]);
  }
 
  const auto& getWeight() const { return mWeight; }
 
 private:
  std::array<IDCOne, SIDES> mIDCOneAgg{};                          
  std::array<std::vector<unsigned int>, o2::tpc::SIDES> mWeight{}; 
};
 
struct FourierCoeff {
  FourierCoeff(const unsigned int nTimeFrames, const unsigned int nCoeff)
    : mFourierCoefficients{std::vector<float>(nTimeFrames * nCoeff)}, mCoeffPerTF{nCoeff} {};
 
  FourierCoeff() = default;
 
  unsigned long getNCoefficients() const { return mFourierCoefficients.size(); }
 
  unsigned int getNCoefficientsPerTF() const { return mCoeffPerTF; }
 
  const auto& getFourierCoefficients() const { return mFourierCoefficients; }
 
  unsigned int getIndex(const unsigned int interval, const unsigned int coefficient) const { return interval * mCoeffPerTF + coefficient; }
 
  unsigned int getNTimeFrames() const { return getNCoefficients() / mCoeffPerTF; }
 
  float operator()(unsigned int index) const { return mFourierCoefficients[index]; }
 
  float& operator()(unsigned int index) { return mFourierCoefficients[index]; }
 
  void reset() { std::fill(mFourierCoefficients.begin(), mFourierCoefficients.end(), 0.f); };
 
  void resize(const unsigned int nTimeFrames) { mFourierCoefficients.resize(nTimeFrames * mCoeffPerTF); }
 
  std::vector<float> mFourierCoefficients{}; 
  unsigned int mCoeffPerTF{};                
 
  ClassDefNV(FourierCoeff, 2)
};
 
struct SACZero {
  float getValueIDCZero(const Side side, const int stackInSector) const { return mSACZero[side].getValueIDCZero(stackInSector); }
  void clear()
  {
    mSACZero[Side::A].clear();
    mSACZero[Side::C].clear();
  }
 
  void resize(const unsigned int size)
  {
    mSACZero[Side::A].resize(size);
    mSACZero[Side::C].resize(size);
  }
 
  void setValueSACZero(const float sacZero, const Side side, const unsigned int index) { mSACZero[side].setValueIDCZero(sacZero, index); }
 
  std::array<IDCZero, SIDES> mSACZero{};
};
 
struct SACOne {
  float getValue(const Side side, const int interval) const { return mSACOne[side].mIDCOne[interval]; }
  void setValueIDCOne(const float sacOne, const Side side, const unsigned int index) { mSACOne[side].setValueIDCOne(sacOne, index); }
 
  void clear()
  {
    mSACOne[Side::A].clear();
    mSACOne[Side::C].clear();
  }
  void resize(const unsigned int size)
  {
    mSACOne[Side::A].resize(size);
    mSACOne[Side::C].resize(size);
  }
  std::array<IDCOne, SIDES> mSACOne{};
};
 
template <typename DataT>
struct SACDelta {
  float getValue(const Side side, const int index) const { return mSACDelta[side].getValue(index); }
  void setSACDelta(const Side side, const unsigned int index, const float sacDelta) { mSACDelta[side].setIDCDelta(index, sacDelta); }
 
  void resize(const unsigned int size)
  {
    mSACDelta[Side::A].resize(size);
    mSACDelta[Side::C].resize(size);
  }
  std::array<IDCDelta<DataT>, SIDES> mSACDelta{};
};
 
struct FourierCoeffSAC {
  std::array<FourierCoeff, SIDES> mCoeff{};
};
 
template <typename DataT>
class IDCDeltaCompressionHelper
{
 public:
  IDCDeltaCompressionHelper() = default;
 
  static IDCDelta<DataT> getCompressedIDCs(const IDCDelta<float>& idcDeltaUncompressed)
  {
    const auto& paramIDCGroup = ParameterIDCCompression::Instance();
 
    IDCDelta<DataT> idcCompressed{};
    compress(idcDeltaUncompressed, idcCompressed, paramIDCGroup.minIDCDeltaValue, paramIDCGroup.maxIDCDeltaValue);
    return idcCompressed;
  }
 
  static SACDelta<DataT> getCompressedSACs(const SACDelta<float>& sacDeltaUncompressed)
  {
    const auto& paramSAC = ParameterSAC::Instance();
    SACDelta<DataT> sacCompressed{};
    compress(sacDeltaUncompressed.mSACDelta[Side::A], sacCompressed.mSACDelta[Side::A], paramSAC.minSACDeltaValue, paramSAC.maxSACDeltaValue);
    compress(sacDeltaUncompressed.mSACDelta[Side::C], sacCompressed.mSACDelta[Side::C], paramSAC.minSACDeltaValue, paramSAC.maxSACDeltaValue);
    return sacCompressed;
  }
 
 private:
  static void compress(const IDCDelta<float>& idcDeltaUncompressed, IDCDelta<DataT>& idcCompressed, const float minValue, const float maxValue)
  {
    if (idcDeltaUncompressed.getIDCDelta().empty()) {
      return;
    }
    idcCompressed.getIDCDelta().reserve(idcDeltaUncompressed.getIDCDelta().size());
    const auto minmaxIDC = std::minmax_element(std::begin(idcDeltaUncompressed.getIDCDelta()), std::end(idcDeltaUncompressed.getIDCDelta()));
    const auto& paramIDCGroup = ParameterIDCCompression::Instance();
    const float minIDCDelta = std::clamp(*minmaxIDC.first, minValue, maxValue);
    const float maxIDCDelta = std::clamp(*minmaxIDC.second, minValue, maxValue);
    idcCompressed.setCompressionFactor(minIDCDelta, maxIDCDelta);
    for (auto& idc : idcDeltaUncompressed.getIDCDelta()) {
      idcCompressed.emplace_back(idc);
    }
  }
};
 
} // namespace tpc
} // namespace o2
 
#endif