IDCFactorization.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_IDCFACTORIZATION_H_
#define ALICEO2_IDCFACTORIZATION_H_
 
#include <vector>
#include "Rtypes.h"
#include "TPCBase/Mapper.h"
#include "TPCCalibration/IDCContainer.h"
#include "TPCCalibration/IDCGroupHelperSector.h"
#include "DataFormatsTPC/Defs.h"
#include <boost/property_tree/ptree.hpp>
 
namespace o2::tpc
{
 
template <class T>
class CalDet;
 
struct IDCFactorizeSplit {
  std::array<std::vector<float>, CRU::MaxCRU> idcs{};
  int relTF{};
  ClassDefNV(IDCFactorizeSplit, 1)
};
 
class IDCFactorization : public IDCGroupHelperSector
{
 public:
  IDCFactorization(const std::array<unsigned char, Mapper::NREGIONS>& groupPads, const std::array<unsigned char, Mapper::NREGIONS>& groupRows, const std::array<unsigned char, Mapper::NREGIONS>& groupLastRowsThreshold, const std::array<unsigned char, Mapper::NREGIONS>& groupLastPadsThreshold, const unsigned int groupNotnPadsSectorEdges, const unsigned int timeFrames, const unsigned int timeframesDeltaIDC, const std::vector<uint32_t>& crus);
 
  IDCFactorization(const unsigned int timeFrames, const unsigned int timeframesDeltaIDC, const std::vector<uint32_t>& crus) : IDCFactorization(std::array<unsigned char, Mapper::NREGIONS>{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, std::array<unsigned char, Mapper::NREGIONS>{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, std::array<unsigned char, Mapper::NREGIONS>{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, std::array<unsigned char, Mapper::NREGIONS>{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, 0, timeFrames, timeframesDeltaIDC, crus){};
 
  IDCFactorization() = default;
 
  ~IDCFactorization();
 
  IDCFactorization(IDCFactorization&&) = default;
 
  static std::vector<o2::tpc::Side> getSides(const std::vector<uint32_t>& crus);
 
  void factorizeIDCs(const bool norm, const bool calcDeltas);
 
  void calcIDCZero(const bool norm);
 
  void fillIDCZeroDeadPads();
 
  void createStatusMapOutlier(const bool debug = false);
 
  void createStatusMap();
 
  void checkFECs(const float maxOutliersPerFEC = 0.7);
 
  void checkNeighbourOutliers(const int maxIter = 10, const int nOutliersNeighbours = 8);
 
  void calcIDCOne();
 
  void calcIDCDelta();
 
  template <typename DataVec>
  static void calcIDCOne(const DataVec& idcsData, const int idcsPerCRU, const int integrationIntervalOffset, const unsigned int indexOffset, const CRU cru, std::vector<std::vector<float>>& idcOneTmp, const IDCZero* idcZero, const CalDet<PadFlags>* flagMap = nullptr, const bool usePadStatusMap = false);
 
  float getIDCValGrouped(const unsigned int sector, const unsigned int region, const unsigned int grow, unsigned int gpad, unsigned int integrationInterval) const { return mIDCs[sector * Mapper::NREGIONS + region][integrationInterval][mOffsRow[region][grow] + gpad]; }
 
  float getIDCValUngrouped(const unsigned int sector, const unsigned int region, unsigned int urow, unsigned int upad, unsigned int integrationInterval) const;
 
  float getIDCZeroVal(const unsigned int sector, const unsigned int region, unsigned int urow, unsigned int upad) const { return mIDCZero[mSideIndex[Sector(sector).side()]].getValueIDCZero(getIndexUngrouped(sector, region, urow, upad, 0)); }
 
  float getIDCDeltaVal(const unsigned int sector, const unsigned int region, unsigned int urow, unsigned int upad, unsigned int chunk, unsigned int localintegrationInterval) const { return mIDCDelta[mSideIndex[Sector(sector).side()]][chunk].getValue(getIndexUngrouped(sector, region, urow, upad, localintegrationInterval)); }
 
  void getLocalIntegrationInterval(const unsigned int integrationInterval, unsigned int& chunk, unsigned int& localintegrationInterval) const;
 
  unsigned int getNTimeframes() const { return mTimeFrames; }
 
  unsigned long getNIntegrationIntervalsInChunk(const unsigned int chunk) const;
 
  unsigned long getNIntegrationIntervalsToChunk(const unsigned int chunk) const;
 
  unsigned long getNIntegrationIntervals(const int cru) const;
 
  unsigned long getNIntegrationIntervals() const;
 
  const std::vector<float>& getIDCZeroVec(const o2::tpc::Side side) const { return mIDCZero[mSideIndex[side]].mIDCZero; }
 
  const IDCZero& getIDCZero(const o2::tpc::Side side) const& { return mIDCZero[mSideIndex[side]]; }
 
  auto getIDCZero(const o2::tpc::Side side) && { return mIDCZero[mSideIndex[side]]; }
 
  const std::vector<float>& getIDCOneVec(const o2::tpc::Side side) const { return mIDCOne[mSideIndex[side]].mIDCOne; }
 
  const IDCOne& getIDCOne(const o2::tpc::Side side) const { return mIDCOne[mSideIndex[side]]; }
 
  const std::vector<float>& getIDCDeltaValuesUncompressed(const unsigned int chunk, const o2::tpc::Side side) const { return mIDCDelta[mSideIndex[side]][chunk].getIDCDelta(); }
 
  const auto& getIDCDeltaUncompressed(const unsigned int chunk, const Side side) const& { return mIDCDelta[mSideIndex[side]][chunk]; }
 
  auto getIDCDeltaUncompressed(const unsigned int chunk, const Side side) && { return std::move(mIDCDelta[mSideIndex[side]][chunk]); }
 
  auto getIDCDeltaMediumCompressed(const unsigned int chunk, const Side side) const { return IDCDeltaCompressionHelper<unsigned short>::getCompressedIDCs(mIDCDelta[mSideIndex[side]][chunk]); }
 
  auto getIDCDeltaHighCompressed(const unsigned int chunk, const Side side) const { return IDCDeltaCompressionHelper<unsigned char>::getCompressedIDCs(mIDCDelta[mSideIndex[side]][chunk]); }
 
  unsigned int getNChunks(const Side side) const { return mIDCDelta[mSideIndex[side]].size(); }
 
  const auto& getIDCZero() const { return mIDCZero; }
 
  const auto& getIDCOne() const& { return mIDCOne; }
 
  auto getIDCOne() && { return std::move(mIDCOne); }
 
  const auto& getIDCs() const { return mIDCs; }
 
  auto getCRUs() const { return mCRUs; }
 
  void setTimeStamp(const long timeStamp) { mTimeStamp = timeStamp; }
 
  long getTimeStamp() const { return mTimeStamp; }
 
  void setRun(const int run) { mRun = run; }
 
  int getRun() const { return mRun; }
 
  // get number of TFs in which the DeltaIDCs are split/stored
  unsigned int getTimeFramesDeltaIDC() const { return mTimeFramesDeltaIDC; }
 
  static int getNThreads() { return sNThreads; }
 
  void setIDCs(std::vector<float>&& idcs, const unsigned int cru, const unsigned int timeframe) { mIDCs[cru][timeframe] = std::move(idcs); }
 
  static void setNThreads(const int nThreads) { sNThreads = nThreads; }
 
  static void setMinCompressedIDCDelta(const float minIDCDeltaValue) { o2::conf::ConfigurableParam::setValue<float>("TPCIDCCompressionParam", "minIDCDeltaValue", minIDCDeltaValue); }
 
  static void setMaxCompressedIDCDelta(const float maxIDCDeltaValue) { o2::conf::ConfigurableParam::setValue<float>("TPCIDCCompressionParam", "maxIDCDeltaValue", maxIDCDeltaValue); }
 
  void drawIDCsSector(const unsigned int sector, const unsigned int integrationInterval, const float minZ = 0, const float maxZ = -1, const std::string filename = "IDCsSector.pdf") const { drawIDCHelper(false, Sector(sector), integrationInterval, filename, minZ, maxZ); }
 
  void drawIDCZeroSector(const unsigned int sector, const float minZ = 0, const float maxZ = -1, const std::string filename = "IDCZeroSector.pdf") const { drawIDCZeroHelper(false, Sector(sector), filename, minZ, maxZ); }
 
  void drawIDCDeltaSector(const unsigned int sector, const unsigned int integrationInterval, const float minZ = 0, const float maxZ = -1, const IDCDeltaCompression compression = IDCDeltaCompression::NO, const std::string filename = "IDCDeltaSector.pdf") const { drawIDCDeltaHelper(false, Sector(sector), integrationInterval, compression, filename, minZ, maxZ); }
 
  void drawIDCsSide(const o2::tpc::Side side, const unsigned int integrationInterval, const float minZ = 0, const float maxZ = -1, const std::string filename = "IDCsSide.pdf") const { drawIDCHelper(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), integrationInterval, filename, minZ, maxZ); }
 
  void drawIDCsSideGIF(const unsigned int integrationIntervals = 0, const float minZ = 0, const float maxZ = -1, const int run = -1, const std::string filename = "IDCsSideGIF") const { drawIDCHelper(true, Sector(0), integrationIntervals, filename, minZ, maxZ, true, run); }
 
  void drawIDCZeroSide(const o2::tpc::Side side, const float minZ = 0, const float maxZ = -1, const std::string filename = "IDCZeroSide.pdf") 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 float minZ = 0, const float maxZ = -1, const IDCDeltaCompression compression = IDCDeltaCompression::NO, const std::string filename = "IDCDeltaSide.pdf") const { drawIDCDeltaHelper(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), integrationInterval, compression, filename, minZ, maxZ); }
 
  void drawPadStatusFlagsMapSector(const unsigned int sector, const PadFlags flag = PadFlags::flagSkip, const std::string filename = "PadStatusFlags_Sector.pdf") const { drawPadFlagMap(false, Sector(sector), filename, flag); }
 
  void drawPadStatusFlagsMapSide(const o2::tpc::Side side, const PadFlags flag = PadFlags::flagSkip, const std::string filename = "PadStatusFlags_Side.pdf") const { drawPadFlagMap(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), filename, flag); }
 
  void dumpToFile(const char* outFileName = "IDCFactorized.root", const char* outName = "IDCFactorized") const;
 
  void dumpLargeObjectToFile(const char* outFileName = "IDCFactorized.root", const char* outName = "IDCFactorized") const;
 
  static std::unique_ptr<IDCFactorization> getLargeObjectFromFile(const char* inpFileName = "IDCFactorized.root", const char* inName = "IDCFactorized");
 
  void dumpIDCZeroToFile(const Side side, const char* outFileName = "IDCZero.root", const char* outName = "IDC0") const;
 
  void dumpIDCOneToFile(const Side side, const char* outFileName = "IDCOne.root", const char* outName = "IDC1") const;
 
  void dumpToTree(const Side side, const char* outFileName = "IDCTree.root");
 
  void dumpToTreeIDC1(const float integrationTimeOrbits = 12, const char* outFileName = "IDC1Tree.root") const;
 
  void dumpIDCDeltaToTree(const Side side, const int chunk = 0, const char* outFileName = "IDCDeltaTree.root");
 
  std::vector<unsigned int> getIntegrationIntervalsPerTF(const int cru = -1) const;
 
  std::vector<unsigned int> getAllIntegrationIntervalsPerTF() const;
 
  void reset();
 
  void setGainMap(const char* inpFile, const char* mapName);
 
  void setGainMap(const CalDet<float>& gainmap);
 
  void setPadFlagMap(const char* inpFile, const char* mapName);
 
  void setPadFlagMap(const CalDet<PadFlags>& flagmap);
 
  void setUsePadStatusMap(const bool usePadStatusMap) { mUsePadStatusMap = usePadStatusMap; }
 
  bool getUsePadStatusMap() const { return mUsePadStatusMap; }
 
  void dumpPadFlagMap(const char* outFile, const char* mapName);
 
  CalDet<PadFlags>* getPadStatusMapPtr() const { return mPadFlagsMap.get(); }
 
  std::unique_ptr<CalDet<PadFlags>> getPadStatusMap() { return std::move(mPadFlagsMap); }
 
  const std::vector<Side>& getSides() const { return mSides; }
 
  void setIDCZero(const Side side, const IDCZero& idcZero) { mIDCZero[mSideIndex[side]] = idcZero; }
 
  void setIDCOne(const Side side, const IDCOne& idcOne) { mIDCOne[mSideIndex[side]] = idcOne; }
 
  void setIDCDelta(const Side side, const IDCDelta<float>& idcDelta, const int index = 0) { mIDCDelta[mSideIndex[side]][index] = idcDelta; }
 
  float getMeanZ(const Side side) const;
 
  void normIDCZeroGain() { normIDCZero(0); }
 
  void normIDCZeroStackMedian() { normIDCZero(1); }
 
  std::array<float, o2::tpc::GEMSTACKS> getStackMedian() const;
 
 private:
  const unsigned int mTimeFrames{};                                 
  const unsigned int mTimeFramesDeltaIDC{};                         
  std::array<std::vector<std::vector<float>>, CRU::MaxCRU> mIDCs{}; 
  std::vector<IDCZero> mIDCZero{};                                  
  std::vector<IDCOne> mIDCOne{};                                    
  std::vector<std::vector<IDCDelta<float>>> mIDCDelta{};            
  inline static int sNThreads{1};                                   
  std::unique_ptr<CalDet<float>> mGainMap;                          
  std::unique_ptr<CalDet<PadFlags>> mPadFlagsMap;                   
  bool mInputGrouped{false};                                        
  bool mUsePadStatusMap{true};                                      
  const std::vector<uint32_t> mCRUs{};                              
  std::array<unsigned int, SIDES> mSideIndex{0, 1};                 
  std::vector<Side> mSides{};                                       
  std::vector<unsigned int> mIntegrationIntervalsPerTF{};           
  long mTimeStamp{0};                                               
  int mRun{0};                                                      
 
  void drawIDCDeltaHelper(const bool type, const Sector sector, const unsigned int integrationInterval, const IDCDeltaCompression compression, 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 bool drawGIF = false, const int run = 0) const;
 
  void drawIDCZeroHelper(const bool type, const Sector sector, const std::string filename, const float minZ, const float maxZ) const;
 
  void getTF(unsigned int integrationInterval, unsigned int& timeFrame, unsigned int& interval) const;
 
  unsigned int getChunk(const unsigned int timeframe) const;
 
  unsigned int getNTFsPerChunk(const unsigned int chunk) const;
 
  void drawPadFlagMap(const bool type, const Sector sector, const std::string filename, const PadFlags flag) const;
 
  void normIDCZero(const int type);
 
  bool checkReceivedIDCs();
 
  ClassDefNV(IDCFactorization, 2)
};
 
} // namespace o2::tpc
 
#endif