IDCAverageGroupBase.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_IDCAVERAGEGROUPBASE_H_
#define ALICEO2_IDCAVERAGEGROUPBASE_H_
 
#include <vector>
#include "TPCCalibration/IDCGroup.h"
#include "TPCCalibration/RobustAverage.h"
#include "TPCCalibration/IDCGroupHelperSector.h"
#include "TPCCalibration/IDCContainer.h"
#include "TPCBase/Mapper.h"
#include "TPCBase/Sector.h"
 
namespace o2::tpc
{
 
template <class Type>
class IDCAverageGroupBase;
 
class IDCAverageGroupCRU;
class IDCAverageGroupTPC;
class IDCAverageGroupDraw;
 
template <>
class IDCAverageGroupBase<IDCAverageGroupCRU>
{
 public:
  IDCAverageGroupBase(const unsigned char groupPads, const unsigned char groupRows, const unsigned char groupLastRowsThreshold, const unsigned char groupLastPadsThreshold, const unsigned int groupNotnPadsSectorEdges, const unsigned short cru, const int nThreads)
    : mIDCsGrouped{groupPads, groupRows, groupLastRowsThreshold, groupLastPadsThreshold, groupNotnPadsSectorEdges, cru}, mRobustAverage(nThreads), mSector{CRU(cru).sector()} {};
 
  unsigned int getNIntegrationIntervals() const { return mIDCsUngrouped.size() / Mapper::PADSPERREGION[getRegion()]; }
 
  unsigned int getRegion() const { return mIDCsGrouped.getRegion(); }
 
  unsigned int getCRU() const { return getRegion() + mSector * Mapper::NREGIONS; }
 
  Sector getSector() const { return mSector; }
 
  void setIDCs(const std::vector<float>& idcs);
 
  void setIDCs(std::vector<float>&& idcs);
 
  auto getIDCGroupData() && { return std::move(mIDCsGrouped).getData(); }
 
  const auto& getIDCGroup() const { return mIDCsGrouped; }
 
  float getUngroupedIDCValGlobal(const unsigned int ugrow, const unsigned int upad, const unsigned int integrationInterval) const { return mIDCsUngrouped[getUngroupedIndexGlobal(ugrow, upad, integrationInterval)]; }
 
  float getUngroupedIDCValLocal(const unsigned int ulrow, const unsigned int upad, const unsigned int integrationInterval) const { return mIDCsUngrouped[getUngroupedIndex(ulrow, upad, integrationInterval)]; }
 
  float getUngroupedNormedIDCValLocal(const unsigned int ulrow, const unsigned int upad, const unsigned int integrationInterval) const { return mIDCsUngrouped[getUngroupedIndex(ulrow, upad, integrationInterval)] * Mapper::INVPADAREA[getRegion()]; }
 
  unsigned int getUngroupedIndex(const unsigned int ulrow, const unsigned int upad, const unsigned int integrationInterval) const { return integrationInterval * Mapper::PADSPERREGION[getRegion()] + Mapper::OFFSETCRULOCAL[getRegion()][ulrow] + upad; }
 
  unsigned int getUngroupedIndexGlobal(const unsigned int ugrow, const unsigned int upad, const unsigned int integrationInterval) const { return integrationInterval * Mapper::PADSPERREGION[getRegion()] + Mapper::OFFSETCRUGLOBAL[ugrow] + upad; }
 
  void drawUngroupedIDCs(const unsigned int integrationInterval = 0, const std::string filename = "IDCsUngrouped.pdf") const;
 
  void drawGroupedIDCs(const unsigned int integrationInterval = 0, const std::string filename = "IDCsGrouped.pdf") const { mIDCsGrouped.draw(integrationInterval, filename); }
 
 protected:
  IDCGroup mIDCsGrouped{};                   
  std::vector<RobustAverage> mRobustAverage; 
  std::vector<float> mWeightsPad{};          
  std::vector<float> mWeightsRow{};          
  std::vector<float> mIDCsUngrouped{};       
  const Sector mSector{};                    
};
 
template <>
class IDCAverageGroupBase<IDCAverageGroupTPC>
{
 public:
  IDCAverageGroupBase(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 int nThreads)
    : mIDCGroupHelperSector(groupPads, groupRows, groupLastRowsThreshold, groupLastPadsThreshold, groupNotnPadsSectorEdges), mRobustAverage(nThreads){};
 
  unsigned int getNIntegrationIntervals() const { return mIDCsUngrouped.getIDCDelta().size() / Mapper::getNumberOfPadsPerSide(); }
 
  const auto& getIDCGroupData() const& { return mIDCsGrouped; }
 
  auto getIDCGroupData() && { return std::move(mIDCsGrouped); }
 
  const auto& getIDCUngroupData() const& { return mIDCsUngrouped; }
 
  auto& getIDCGroupHelperSector() const { return mIDCGroupHelperSector; }
 
  unsigned int getUngroupedIndexGlobal(const unsigned int sector, const unsigned int region, unsigned int urow, unsigned int upad, unsigned int integrationInterval) const { return IDCGroupHelperSector::getUngroupedIndexGlobal(sector, region, urow, upad, integrationInterval); }
 
  float getGroupedIDCDeltaVal(const unsigned int sector, const unsigned int region, unsigned int urow, unsigned int upad, unsigned int integrationInterval) const { return mIDCsGrouped.getValue(mIDCGroupHelperSector.getIndexUngrouped(sector, region, urow, upad, integrationInterval)); }
 
  float getUngroupedIDCDeltaVal(const unsigned int sector, const unsigned int region, unsigned int urow, unsigned int upad, unsigned int integrationInterval) const { return mIDCsUngrouped.getValue(getUngroupedIndexGlobal(sector, region, urow, upad, integrationInterval)); }
 
  void drawGroupedIDCsSector(const unsigned int sector, const unsigned int integrationInterval, const std::string filename = "IDCDeltaGroupedSector.pdf") const { drawIDCDeltaHelper(false, Sector(sector), integrationInterval, true, filename); }
 
  void drawUngroupedIDCsSector(const unsigned int sector, const unsigned int integrationInterval, const std::string filename = "IDCDeltaUngroupedSector.pdf") const { drawIDCDeltaHelper(false, Sector(sector), integrationInterval, false, filename); }
 
  void drawGroupedIDCsSide(const unsigned int integrationInterval, const std::string filename = "IDCDeltaGroupedSide.pdf") const { drawIDCDeltaHelper(true, (mSide == Side::A) ? Sector(0) : Sector(Sector::MAXSECTOR - 1), integrationInterval, true, filename); }
 
  void drawUngroupedIDCsSide(const unsigned int integrationInterval, const std::string filename = "IDCDeltaUngroupedSide.pdf") const { drawIDCDeltaHelper(true, (mSide == Side::A) ? Sector(0) : Sector(Sector::MAXSECTOR - 1), integrationInterval, false, filename); }
 
  void setIDCs(const IDCDelta<float>& idcs, const Side side);
 
  void setIDCs(IDCDelta<float>&& idcs, const Side side);
 
  Side getSide() const { return mSide; }
 
  void resetGroupedIDCs();
 
 protected:
  IDCDelta<float> mIDCsGrouped{};                                 
  IDCGroupHelperSector mIDCGroupHelperSector;                     
  std::vector<RobustAverage> mRobustAverage;                      
  std::array<std::vector<float>, Mapper::NREGIONS> mWeightsPad{}; 
  std::array<std::vector<float>, Mapper::NREGIONS> mWeightsRow{}; 
  IDCDelta<float> mIDCsUngrouped{};                               
  Side mSide{};                                                   
 
  void resizeGroupedIDCs();
 
  void drawIDCDeltaHelper(const bool type, const Sector sector, const unsigned int integrationInterval, const bool grouped, const std::string filename) const;
};
 
} // namespace o2::tpc
 
#endif