IDCCCDBHelper.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_IDCCCDBHELPER_H_
#define ALICEO2_TPC_IDCCCDBHELPER_H_
#include <Framework/Logger.h>
#include "DataFormatsTPC/Defs.h"
#include "TPCBaseRecSim/PadFlags.h"
#include "TPCBase/Sector.h"
#include "Rtypes.h"
 
#include <fmt/format.h>
class TCanvas;
 
namespace o2::tpc
{
 
class IDCGroupHelperSector;
struct IDCZero;
struct IDCOne;
struct FourierCoeff;
template <typename DataT>
struct IDCDelta;
enum class PadFlags : unsigned short;
 
template <class T>
class CalDet;
 
/*
 Usage
 o2::tpc::IDCCCDBHelper<unsigned short> helper;
 // setting the IDC members manually
 helper.setIDCDelta(IDCDelta<DataT>* idcDelta);
 helper.setIDCZero(IDCZero* idcZero);
 helper.setIDCOne(IDCOne* idcOne);
 helper.setGroupingParameter(IDCGroupHelperSector* helperSector);
 // draw or access the IDCs
 const unsigned int sector = 10;
 const unsigned int integrationInterval = 0;
 helper.drawIDCZeroSide(o2::tpc::Side::A);
 helper.drawIDCDeltaSector(sector, integrationInterval);
 helper.drawIDCDeltaSide(o2::tpc::Side::A, integrationInterval);
 helper.drawIDCSide(o2::tpc::Side::A, integrationInterval);
 TODO add drawing of 1D-distributions
*/
 
template <typename DataT = unsigned short>
class IDCCCDBHelper
{
 public:
  IDCCCDBHelper() = default;
 
  void setIDCDelta(IDCDelta<DataT>* idcDelta, const Side side = Side::A) { mIDCDelta[side] = idcDelta; }
 
  void setIDCZero(IDCZero* idcZero, const Side side = Side::A) { mIDCZero[side] = idcZero; }
 
  void setIDCOne(IDCOne* idcOne, const Side side = Side::A) { mIDCOne[side] = idcOne; }
 
  void setFourierCoeffs(FourierCoeff* fourier, const Side side = Side::A) { mFourierCoeff[side] = fourier; }
 
  void setIDCZeroScale(const bool rejectOutlier = true);
 
  void setGroupingParameter(IDCGroupHelperSector* helperSector, const Side side = Side::A) { mHelperSector[side] = helperSector; }
 
  unsigned int getNIntegrationIntervalsIDCDelta(const o2::tpc::Side side) const;
 
  unsigned int getNIntegrationIntervalsIDCOne(const o2::tpc::Side side) const;
 
  float getIDCZeroVal(const unsigned int sector, const unsigned int region, unsigned int urow, unsigned int upad) const;
 
  float getIDCDeltaVal(const unsigned int sector, const unsigned int region, unsigned int urow, unsigned int upad, unsigned int integrationInterval) const;
 
  float getIDCOneVal(const o2::tpc::Side side, const unsigned int integrationInterval) const;
 
  void createOutlierMap();
 
  float getIDCVal(const unsigned int sector, const unsigned int region, unsigned int urow, unsigned int upad, unsigned int integrationInterval) const;
 
  void drawIDCZeroSide(const o2::tpc::Side side, const std::string filename = "IDCZeroSide.pdf", const float minZ = 0, const float maxZ = -1) const { drawIDCZeroHelper(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), filename, minZ, maxZ); }
 
  void drawIDCDeltaSide(const o2::tpc::Side side, const unsigned int integrationInterval, const std::string filename = "IDCDeltaSide.pdf", const float minZ = 0, const float maxZ = -1) const { drawIDCDeltaHelper(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), integrationInterval, filename, minZ, maxZ); }
 
  void drawIDCSide(const o2::tpc::Side side, const unsigned int integrationInterval, const std::string filename = "IDCSide.pdf", const float minZ = 0, const float maxZ = -1) const { drawIDCHelper(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), integrationInterval, filename, minZ, maxZ); }
 
  void drawIDCZeroSector(const unsigned int sector, const std::string filename = "IDCZeroSector.pdf", const float minZ = 0, const float maxZ = -1) const { drawIDCZeroHelper(false, Sector(sector), filename, minZ, maxZ); }
 
  void drawIDCDeltaSector(const unsigned int sector, const unsigned int integrationInterval, const std::string filename = "IDCDeltaSector.pdf", const float minZ = 0, const float maxZ = -1) const { drawIDCDeltaHelper(false, Sector(sector), integrationInterval, filename, minZ, maxZ); }
 
  void drawIDCSector(const unsigned int sector, const unsigned int integrationInterval, const std::string filename = "IDCSector.pdf", const float minZ = 0, const float maxZ = -1) const { drawIDCHelper(false, Sector(sector), integrationInterval, filename, minZ, maxZ); }
 
  void drawPadStatusFlagsMapSector(const unsigned int sector, const PadFlags flag, const std::string filename = "PadStatusFlags_Sector.pdf") const { drawPadFlagMap(false, Sector(sector), filename, flag); }
 
  void drawPadStatusFlagsMapSide(const o2::tpc::Side side, const PadFlags flag, const std::string filename = "PadStatusFlags_Side.pdf") const { drawPadFlagMap(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), filename, flag); }
 
  TCanvas* drawIDCZeroCanvas(TCanvas* outputCanvas, std::string_view type, int nbins1D, float xMin1D, float xMax1D, int integrationInterval = -1) const;
 
  TCanvas* drawIDCZeroScale(TCanvas* outputCanvas, const bool rejectOutlier = true) const;
 
  TCanvas* drawIDCZeroRadialProfile(TCanvas* outputCanvas, int nbinsY, float yMin, float yMax) const;
 
  TCanvas* drawIDCZeroStackCanvas(TCanvas* outputCanvas, Side side, std::string_view type, int nbins1D, float xMin1D, float xMax1D, int integrationInterval = -1) const;
 
  TCanvas* drawIDCOneCanvas(TCanvas* outputCanvas, int nbins1D, float xMin1D, float xMax1D, int integrationIntervals = -1) const;
 
  TCanvas* drawFourierCoeff(TCanvas* outputCanvas, Side side, int nbins1D, float xMin1D, float xMax1D) const;
 
  void dumpToTree(const Side side, const char* outFileName = "IDCCCDBTree.root") const;
 
  void dumpToFourierCoeffToTree(const char* outFileName = "FourierCCDBTree.root") const;
 
  void dumpToTreeIDCDelta(const Side side, const char* outFileName = "IDCCCDBTreeDeltaIDC.root") const;
 
  CalDet<float> getIDCZeroCalDet() const;
 
  std::vector<CalDet<float>> getIDCDeltaCalDet() const;
 
  CalDet<PadFlags>* getPadStatusMap() const { return mPadFlagsMap.get(); }
 
  void setPadStatusMap(const CalDet<PadFlags>& outliermap) { mPadFlagsMap = std::make_unique<CalDet<PadFlags>>(outliermap); }
 
  void scaleIDC0(const float factor, const Side side);
 
  static float getMeanIDC0(const Side side, const IDCZero& idcZero, const CalDet<PadFlags>* outlierMap);
 
  std::pair<int, int> getNOutliers() const;
 
  static float getStackMedian(const IDCZero& idczero, const Sector sector, const GEMstack stack);
 
  static std::array<float, o2::tpc::GEMSTACKSPERSECTOR * o2::tpc::SECTORSPERSIDE> getStackMedian(const IDCZero& idczero, const Side side);
 
 private:
  float mScaleIDC0Aside = 1.0;
  float mScaleIDC0Cside = 1.0;
 
  std::array<IDCZero*, SIDES> mIDCZero = {nullptr, nullptr};                   
  std::array<IDCDelta<DataT>*, SIDES> mIDCDelta = {nullptr, nullptr};          
  std::array<IDCOne*, SIDES> mIDCOne = {nullptr, nullptr};                     
  std::array<IDCGroupHelperSector*, SIDES> mHelperSector = {nullptr, nullptr}; 
  std::array<FourierCoeff*, SIDES> mFourierCoeff = {nullptr, nullptr};         
  std::unique_ptr<CalDet<PadFlags>> mPadFlagsMap;                              
 
  void drawIDCZeroHelper(const bool type, const Sector sector, const std::string filename, const float minZ, const float maxZ) const;
 
  void drawIDCDeltaHelper(const bool type, const Sector sector, const unsigned int integrationInterval, const std::string filename, const float minZ, const float maxZ) const;
 
  void drawIDCHelper(const bool type, const Sector sector, const unsigned int integrationInterval, const std::string filename, const float minZ, const float maxZ) const;
 
  void drawPadFlagMap(const bool type, const Sector sector, const std::string filename, const PadFlags flag) const;
 
  static unsigned int getUngroupedIndexGlobal(const unsigned int sector, const unsigned int region, unsigned int urow, unsigned int upad, unsigned int integrationInterval);
 
  ClassDefNV(IDCCCDBHelper, 3)
};
 
} // namespace o2::tpc
 
#endif