SACFactorization.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_SACFACTORIZATION_H_
#define ALICEO2_SACFACTORIZATION_H_
 
#include <vector>
#include "Rtypes.h"
#include "TPCCalibration/IDCContainer.h"
#include "DataFormatsTPC/Defs.h"
#include <boost/property_tree/ptree.hpp>
 
namespace o2::tpc
{
 
class SACFactorization
{
 public:
  using SACDeltaCompression = IDCDeltaCompression;
 
  SACFactorization(const unsigned int timeFrames) : mTimeFrames{timeFrames} {};
 
  SACFactorization() = default;
 
  void factorizeSACs();
 
  void calcSACZero();
 
  void calcSACOne();
 
  void calcSACDelta();
 
  void createStatusMap();
 
  auto getSACValue(const unsigned int stack, const unsigned int interval) const { return mSACs[stack][interval]; }
 
  float getSACZeroVal(const unsigned int stack) const { return mSACZero.getValueIDCZero(getSide(stack), stack % GEMSTACKSPERSIDE); }
 
  float getSACDeltaVal(const unsigned int stack, unsigned int interval) const { return mSACDelta.getValue(getSide(stack), getSACDeltaIndex(stack, interval)); }
 
  float getSACOneVal(const Side side, unsigned int interval) const { return mSACOne.getValue(side, interval); }
 
  static unsigned int getSACDeltaIndex(const unsigned int stack, unsigned int interval) { return stack % GEMSTACKSPERSIDE + GEMSTACKSPERSIDE * interval; }
 
  unsigned int getNTimeframes() const { return mTimeFrames; }
 
  unsigned long getNintervals(const int stack = 0) const { return mSACs[stack].size(); }
 
  unsigned long getNIntegrationIntervals(const int stack = 0) const { return mSACs[stack].size(); }
 
  const std::vector<float>& getSACZero(const o2::tpc::Side side) const { return mSACZero.mSACZero[side].mIDCZero; }
 
  const std::vector<float>& getSACOne(const o2::tpc::Side side) const { return mSACOne.mSACOne[side].mIDCOne; }
 
  const std::vector<float>& getSACDeltaUncompressed(const o2::tpc::Side side) const { return mSACDelta.mSACDelta[side].getIDCDelta(); }
 
  const auto& getSACDeltaUncompressed() const& { return mSACDelta; }
 
  auto getSACDeltaUncompressed() && { return std::move(mSACDelta); }
 
  auto getSACDeltaMediumCompressed() const { return IDCDeltaCompressionHelper<unsigned short>::getCompressedSACs(mSACDelta); }
 
  auto getSACDeltaHighCompressed() const { return IDCDeltaCompressionHelper<unsigned char>::getCompressedSACs(mSACDelta); }
 
  const auto& getSACZero() const { return mSACZero; }
 
  const auto& getSACOne() const& { return mSACOne; }
 
  auto getSACOne() && { return std::move(mSACOne); }
 
  const auto& getSACs() const { return mSACs; }
 
  const auto& getOutlierMap() const { return mOutlierMap; }
 
  static int getNThreads() { return sNThreads; }
 
  void setSACs(std::vector<int32_t>&& SACs, const unsigned int stack) { mSACs[stack] = std::move(SACs); }
 
  static void setNThreads(const int nThreads) { sNThreads = nThreads; }
 
  static void setMinCompressedSACDelta(const float minSACDeltaValue) { o2::conf::ConfigurableParam::setValue<float>("TPCSACCompressionParam", "minSACDeltaValue", minSACDeltaValue); }
 
  static void setMaxCompressedSACDelta(const float maxSACDeltaValue) { o2::conf::ConfigurableParam::setValue<float>("TPCSACCompressionParam", "maxSACDeltaValue", maxSACDeltaValue); }
 
  void drawSACsSector(const unsigned int sector, const unsigned int interval, const float minZ = 0, const float maxZ = -1, const std::string filename = "SACsSector.pdf") const { drawSACHelper(false, Sector(sector), interval, filename, minZ, maxZ); }
 
  void drawSACZeroSector(const unsigned int sector, const float minZ = 0, const float maxZ = -1, const std::string filename = "SACZeroSector.pdf") const { drawSACZeroHelper(false, Sector(sector), filename, minZ, maxZ); }
 
  void drawSACZeroOutlierSector(const unsigned int sector, const float minZ = 0, const float maxZ = -1, const std::string filename = "SACZeroOutlierSector.pdf") const { drawSACZeroOutlierHelper(false, Sector(sector), filename, minZ, maxZ); }
 
  void drawSACDeltaSector(const unsigned int sector, const unsigned int interval, const float minZ = 0, const float maxZ = -1, const SACDeltaCompression compression = SACDeltaCompression::NO, const std::string filename = "SACDeltaSector.pdf") const { drawSACDeltaHelper(false, Sector(sector), interval, compression, filename, minZ, maxZ); }
 
  void drawSACsSide(const o2::tpc::Side side, const unsigned int interval, const float minZ = 0, const float maxZ = -1, const std::string filename = "SACsSide.pdf") const { drawSACHelper(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), interval, filename, minZ, maxZ); }
 
  void drawSACZeroSide(const o2::tpc::Side side, const float minZ = 0, const float maxZ = -1, const std::string filename = "SACZeroSide.pdf") const { drawSACZeroHelper(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), filename, minZ, maxZ); }
 
  void drawSACZeroOutlierSide(const o2::tpc::Side side, const float minZ = 0, const float maxZ = -1, const std::string filename = "SACZeroOutlierSide.pdf") const { drawSACZeroOutlierHelper(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), filename, minZ, maxZ); }
 
  void drawSACDeltaSide(const o2::tpc::Side side, const unsigned int interval, const float minZ = 0, const float maxZ = -1, const SACDeltaCompression compression = SACDeltaCompression::NO, const std::string filename = "SACDeltaSide.pdf") const { drawSACDeltaHelper(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), interval, compression, filename, minZ, maxZ); }
 
  void dumpToFile(const char* outFileName = "SACFactorized.root", const char* outName = "SACFactorized") const;
 
  void dumpToTree(int intervals = -1, const char* outFileName = "SACTree.root") const;
 
  void reset();
 
  static Side getSide(const unsigned int gemStack) { return (gemStack < GEMSTACKSPERSIDE) ? Side::A : Side::C; }
 
  static unsigned int getStack(const unsigned int sector, const unsigned int stack) { return static_cast<unsigned int>(stack + sector * GEMSTACKSPERSECTOR); }
 
  static unsigned int getStackInSide(const unsigned int sector, const unsigned int stack) { return getStack(sector, stack) % (GEMSTACKS / 2); }
 
  void setSACZero(const SACZero& sacZero) { mSACZero = sacZero; }
 
 private:
  const unsigned int mTimeFrames{};                             
  std::array<std::vector<int32_t>, o2::tpc::GEMSTACKS> mSACs{}; 
  SACZero mSACZero{};                                           
  SACOne mSACOne{};                                             
  std::array<int, GEMSTACKS> mOutlierMap{};                     
  SACDelta<float> mSACDelta{};                                  
  inline static int sNThreads{1};                               
 
  void drawSACDeltaHelper(const bool type, const Sector sector, const unsigned int interval, const SACDeltaCompression compression, const std::string filename, const float minZ, const float maxZ) const;
 
  void drawSACHelper(const bool type, const Sector sector, const unsigned int interval, const std::string filename, const float minZ, const float maxZ) const;
 
  void drawSACZeroHelper(const bool type, const Sector sector, const std::string filename, const float minZ, const float maxZ) const;
 
  void drawSACZeroOutlierHelper(const bool type, const Sector sector, const std::string filename, const float minZ, const float maxZ) const;
 
  ClassDefNV(SACFactorization, 1)
};
 
} // namespace o2::tpc
 
#endif