IDCFourierTransformBase.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_IDCFOURIERTRANSFORMBASE_H_
#define ALICEO2_IDCFOURIERTRANSFORMBASE_H_
 
#include <vector>
#include "Rtypes.h"
#include "DataFormatsTPC/Defs.h"
#include "TPCCalibration/IDCContainer.h"
 
namespace o2::tpc
{
 
template <class Type>
class IDCFourierTransformBase;
 
// do not use enum class as type to avoid problems with ROOT dictionary generation!
class IDCFourierTransformBaseEPN;        
class IDCFourierTransformBaseAggregator; 
using IDCFourierTransformEPN = o2::tpc::IDCFourierTransformBase<o2::tpc::IDCFourierTransformBaseEPN>;
using IDCFourierTransformAggregator = o2::tpc::IDCFourierTransformBase<o2::tpc::IDCFourierTransformBaseAggregator>;
 
template <>
class IDCFourierTransformBase<IDCFourierTransformBaseEPN>
{
 public:
  IDCFourierTransformBase(const unsigned int rangeIDC) : mRangeIDC{rangeIDC} {};
 
  void setIDCs(IDCOne&& oneDIDCs) { mIDCOne = std::move(oneDIDCs); }
 
  void setIDCs(const IDCOne& oneDIDCs) { mIDCOne = oneDIDCs; }
 
  static constexpr unsigned int getNIntervals() { return 1; }
 
  std::vector<unsigned int> getLastIntervals() const { return std::vector<unsigned int>{static_cast<unsigned int>(mIDCOne.getNIDCs()) - mRangeIDC}; }
 
  std::vector<float> getExpandedIDCOne() const { return mIDCOne.mIDCOne; }
 
  const IDCOne& getIDCOne() const { return mIDCOne; }
 
  unsigned long getNIDCs() const { return mIDCOne.mIDCOne.size(); }
 
 protected:
  const unsigned int mRangeIDC{}; 
  IDCOne mIDCOne{};               
  ClassDefNV(IDCFourierTransformBase, 1)
};
 
template <>
class IDCFourierTransformBase<IDCFourierTransformBaseAggregator>
{
 public:
  IDCFourierTransformBase(const unsigned int rangeIDC) : mRangeIDC{rangeIDC} {};
 
  void setIDCs(IDCOne&& oneDIDCs, std::vector<unsigned int>&& integrationIntervalsPerTF);
 
  void setIDCs(IDCOne&& oneDIDCs, const std::vector<unsigned int>& integrationIntervalsPerTF);
 
  void setIDCs(const IDCOne& oneDIDCs, const std::vector<unsigned int>& integrationIntervalsPerTF);
 
  unsigned long getNIDCs() const { return mIDCOne[!mBufferIndex].mIDCOne.size(); }
 
  unsigned int getNIntervals() const { return mIntegrationIntervalsPerTF[!mBufferIndex].size(); }
 
  const IDCOne& getIDCOne() const { return mIDCOne[!mBufferIndex]; }
 
  std::vector<unsigned int> getLastIntervals() const;
 
  std::vector<float> getExpandedIDCOne() const;
 
  const auto& getIntegrationIntervalsPerTF(const bool buffer) const { return mIntegrationIntervalsPerTF[buffer]; }
 
  float* allocMemFFTW() const;
 
 protected:
  const unsigned int mRangeIDC{};                                        
  std::array<IDCOne, 2> mIDCOne{IDCOne(mRangeIDC), IDCOne(mRangeIDC)};   
  std::array<std::vector<unsigned int>, 2> mIntegrationIntervalsPerTF{}; 
  bool mBufferIndex{true};                                               
 
  bool useLastBuffer() const { return (mRangeIDC > mIntegrationIntervalsPerTF[!mBufferIndex][0]); }
 
  ClassDefNV(IDCFourierTransformBase, 1)
};
 
} // namespace o2::tpc
 
#endif