SACs.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_SACS_H
#define AliceO2_TPC_SACS_H
 
// root includes
#include "TCanvas.h"
 
// o2 includes
#include "TPCCalibration/IDCContainer.h"
#include "DataFormatsTPC/Defs.h"
 
namespace o2::tpc::qc
{
 
class SACs
{
 public:
  SACs() = default;
 
  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); }
 
  void setSACZeroVal(float factor, const unsigned int stack) const { mSACZero->setValueSACZero(factor, getSide(stack), stack % GEMSTACKSPERSIDE); }
 
  float getSACOneVal(const Side side, unsigned int integrationInterval) const;
 
  float getSACDeltaVal(const unsigned int stack, unsigned int interval) const { return mSACDelta->getValue(getSide(stack), getSACDeltaIndex(stack, interval)); }
 
  unsigned int getSACDeltaIndex(const unsigned int stack, unsigned int interval) const { return stack % GEMSTACKSPERSIDE + GEMSTACKSPERSIDE * interval; }
 
  int getSACRejection(const unsigned int stack) const { return mIsSACZeroOutlier[stack]; }
 
  void setSACZero(SACZero* sacZero) { mSACZero = sacZero; }
  void setSACOne(SACOne* sacOne, const Side side = Side::A) { mSACOne[side] = sacOne; }
  void setSACZeroMaxDeviation(float maxdeviation) { mSACZeroMaxDeviation = maxdeviation; }
 
  template <typename T>
  void setSACDelta(SACDelta<T>* sacDelta)
  {
    mSACDelta = sacDelta;
  }
 
  void setFourierCoeffSAC(FourierCoeffSAC* fourier) { mFourierSAC = fourier; }
 
  TCanvas* drawSACTypeSides(const SACType type, const unsigned int integrationInterval, const int minZ = 0, const int maxZ = -1, TCanvas* canv = nullptr);
  TCanvas* drawSACOneCanvas(int nbins1D, float xMin1D, float xMax1D, int integrationIntervals = -1, TCanvas* outputCanvas = nullptr) const;
  TCanvas* drawFourierCoeffSAC(Side side, int nbins1D, float xMin1D, float xMax1, TCanvas* outputCanvas = nullptr) const;
  TCanvas* drawSACZeroScale(TCanvas* outputCanvas = nullptr) const;
 
  void scaleSAC0(const float factor, const Side side);
  void setSACZeroScale(const bool rejectOutlier);
  float getMeanSACZero(const o2::tpc::Side side, bool rejectOutliers);
 
  void dumpToFile(std::string filename, int type = 0);
 
 private:
  std::array<std::vector<int32_t>, o2::tpc::GEMSTACKS> mSACs{};
  SACZero* mSACZero = nullptr;
  std::array<SACOne*, SIDES> mSACOne{}; 
  SACDelta<unsigned char>* mSACDelta = nullptr;
  FourierCoeffSAC* mFourierSAC = nullptr; 
  float mScaleSACZeroAside = 1.0;
  float mScaleSACZeroCside = 1.0;
  float mSACZeroMaxDeviation = 0.;
  int mIsSACZeroOutlier[GEMSTACKSPERSIDE * o2::tpc::SECTORSPERSIDE * 2] = {0};
 
  Side getSide(const unsigned int gemStack) const { return (gemStack < GEMSTACKSPERSIDE) ? Side::A : Side::C; }
 
  unsigned int getStack(const unsigned int sector, const unsigned int stack) const { return static_cast<unsigned int>(stack + sector * GEMSTACKSPERSECTOR); }
 
  ClassDefNV(SACs, 2)
};
} // namespace o2::tpc::qc
#endif