IDCAverageGroupHelper.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_IDCAVERAGEGROUPHELPER_H_
#define ALICEO2_IDCAVERAGEGROUPHELPER_H_
 
#include <vector>
#include "TPCBase/Mapper.h"
#include "TPCCalibration/IDCGroupHelperRegion.h"
#include "TPCCalibration/IDCGroupHelperSector.h"
#include "TPCCalibration/IDCGroup.h"
 
// forward declaration
class TH2Poly;
 
namespace o2::tpc
{
 
// forward declaration of some classes
class RobustAverage;
class IDCAverageGroupDraw;
class IDCAverageGroupCRU;
class IDCAverageGroupTPC;
class PadRegionInfo;
 
template <typename DataT>
struct IDCDelta;
 
template <class Type>
class IDCAverageGroupHelper;
 
template <>
class IDCAverageGroupHelper<IDCAverageGroupCRU>
{
 public:
  IDCAverageGroupHelper(IDCGroup& idcsGrouped, const std::vector<float>& weightsPad, const std::vector<float>& weightsRow, const std::vector<float>& idcsUngrouped, std::vector<RobustAverage>& robustAverage, const unsigned int cru) : mIDCsGrouped{idcsGrouped}, mWeightsPad{weightsPad}, mWeightsRow{weightsRow}, mIDCsUngrouped{idcsUngrouped}, mRobustAverage{robustAverage}, mCRU{cru} {};
 
  unsigned int getRegion() const { return mIDCsGrouped.getRegion(); }
 
  auto getCRU() const { return mCRU; }
 
  int getGroupRows() const { return static_cast<int>(mIDCsGrouped.getGroupRows()); }
 
  int getGroupPads() const { return static_cast<int>(mIDCsGrouped.getGroupPads()); }
 
  int getOffsetForEdgePad(const unsigned int upad, const unsigned int ulrow) const { return mIDCsGrouped.getOffsetForEdgePad(upad, ulrow); }
 
  unsigned int getTotalGroupPadsSectorEdges() const { return mIDCsGrouped.getTotalGroupPadsSectorEdges(); }
 
  int getLastRow() const { return static_cast<int>(mIDCsGrouped.getLastRow()); }
 
  unsigned int getPadsPerRow(const unsigned int glrow) const { return mIDCsGrouped.getPadsPerRow(glrow); }
 
  unsigned int getLastPad(const unsigned int ulrow) const { return mIDCsGrouped.getLastPad(ulrow); }
 
  float getWeightPad(const unsigned int relPosPad) const { return mWeightsPad[relPosPad]; }
 
  float getWeightRow(const unsigned int relPosRow) const { return mWeightsRow[relPosRow]; }
 
  float getWeight(const unsigned int relPosRow, const unsigned int relPosPad) const { return (relPosRow > relPosPad) ? getWeightRow(relPosRow) : getWeightPad(relPosPad); }
 
  float getUngroupedIDCVal(const unsigned int padInRegion) const { return mIDCsUngrouped[mOffsetUngrouped + padInRegion]; }
 
  float getGroupedIDCValGlobal(unsigned int ugrow, unsigned int upad) const { return mIDCsGrouped.getValUngroupedGlobal(ugrow, upad, mIntegrationInterval); }
 
  void addValue(const unsigned int padInRegion, const float weight);
 
  void addValue(const unsigned int padInRegion);
 
  void setGroupedIDC(const unsigned int rowGrouped, const unsigned int padGrouped, const bool withweights) { mIDCsGrouped(rowGrouped, padGrouped, mIntegrationInterval) = getGroupedIDC(withweights); }
 
  float getGroupedIDC(const bool withweights) const;
 
  void set(const unsigned int threadNum, const unsigned int integrationInterval);
 
  unsigned int getIntegrationInterval() const { return mIntegrationInterval; }
 
  void clearRobustAverage();
 
  void setSectorEdgeIDC(const unsigned int ulrow, const unsigned int upad) { mIDCsGrouped.setValUngrouped(ulrow, upad, mIntegrationInterval, getGroupedIDC(false)); }
 
  EdgePadGroupingMethod getEdgePadGroupingType() const { return mIDCsGrouped.getEdgePadGroupingType(); }
 
  unsigned int getGroupedPadsSectorEdges() const { return mIDCsGrouped.getGroupedPadsSectorEdges(); }
 
  unsigned int getPadsInGroupSectorEdges(const unsigned indexGroup) const { return mIDCsGrouped.getPadsInGroupSectorEdges(indexGroup); }
 
 private:
  IDCGroup& mIDCsGrouped;                     
  const std::vector<float>& mWeightsPad{};    
  const std::vector<float>& mWeightsRow{};    
  const std::vector<float>& mIDCsUngrouped{}; 
  std::vector<RobustAverage>& mRobustAverage; 
  const unsigned int mCRU{};                  
  unsigned int mThreadNum{};                  
  unsigned int mIntegrationInterval{};        
  unsigned int mOffsetUngrouped{};            
};
 
template <>
class IDCAverageGroupHelper<IDCAverageGroupTPC>
{
 public:
  IDCAverageGroupHelper(IDCDelta<float>& idcsGrouped, const std::array<std::vector<float>, Mapper::NREGIONS>& weightsPad, const std::array<std::vector<float>, Mapper::NREGIONS>& weightsRow, const IDCDelta<float>& idcsUngrouped, std::vector<RobustAverage>& robustAverage, const IDCGroupHelperSector& idcGroupHelperSector) : mIDCsGrouped{idcsGrouped}, mWeightsPad{weightsPad}, mWeightsRow{weightsRow}, mIDCsUngrouped{idcsUngrouped}, mRobustAverage{robustAverage}, mIDCGroupHelperSector{idcGroupHelperSector} {};
 
  unsigned int getRegion() const { return mCRU.region(); }
 
  auto getCRU() const { return mCRU; }
 
  Sector getSector() const { return mCRU.sector(); }
 
  Side getSide() const { return mCRU.side(); }
 
  int getGroupRows() const { return static_cast<int>(mIDCGroupHelperSector.getGroupingParameter().getGroupRows(getRegion())); }
 
  int getGroupPads() const { return static_cast<int>(mIDCGroupHelperSector.getGroupingParameter().getGroupPads(getRegion())); }
 
  int getOffsetForEdgePad(const unsigned int upad, const unsigned int ulrow) const { return mIDCGroupHelperSector.getOffsetForEdgePad(upad, ulrow, getRegion()); }
 
  unsigned int getTotalGroupPadsSectorEdges() const { return mIDCGroupHelperSector.getGroupingParameter().getTotalGroupPadsSectorEdges(); }
 
  int getLastRow() const { return static_cast<int>(mIDCGroupHelperSector.getLastRow(getRegion())); }
 
  unsigned int getPadsPerRow(const unsigned int glrow) const { return mIDCGroupHelperSector.getPadsPerRow(getRegion(), glrow); }
 
  unsigned int getLastPad(const unsigned int ulrow) const { return mIDCGroupHelperSector.getLastPad(getRegion(), ulrow); }
 
  float getWeightPad(const unsigned int relPosPad) const { return mWeightsPad[getRegion()][relPosPad]; }
 
  float getWeightRow(const unsigned int relPosRow) const { return mWeightsRow[getRegion()][relPosRow]; }
 
  float getWeight(const unsigned int relPosRow, const unsigned int relPosPad) const { return (relPosRow > relPosPad) ? getWeightRow(relPosRow) : getWeightPad(relPosPad); }
 
  float getGroupedIDCValGlobal(unsigned int urow, unsigned int upad) const;
 
  float getUngroupedIDCVal(const unsigned int padInRegion) const;
 
  unsigned int getIntegrationInterval() const { return mIntegrationInterval; }
 
  void addValue(const unsigned int padInRegion, const float weight);
 
  void addValue(const unsigned int padInRegion);
 
  void setGroupedIDC(const unsigned int rowGrouped, const unsigned int padGrouped, const bool withweights) { setGroupedIDC(rowGrouped, padGrouped, getGroupedIDC(withweights)); }
 
  float getGroupedIDC(const bool withweights) const;
 
  void setThreadNum(const unsigned int threadNum) { mThreadNum = threadNum; }
 
  void setIntegrationInterval(const unsigned int integrationInterval);
 
  void setCRU(const CRU cru) { mCRU = cru; }
 
  void clearRobustAverage();
 
  void setSectorEdgeIDC(const unsigned int ulrow, const unsigned int upad);
 
  EdgePadGroupingMethod getEdgePadGroupingType() const { return mIDCGroupHelperSector.getGroupingParameter().getEdgePadGroupingType(); }
 
  unsigned int getGroupedPadsSectorEdges() const { return mIDCGroupHelperSector.getGroupingParameter().getGroupedPadsSectorEdges(); }
 
  unsigned int getPadsInGroupSectorEdges(const unsigned indexGroup) const { return mIDCGroupHelperSector.getGroupingParameter().getPadsInGroupSectorEdges(indexGroup); }
 
 private:
  IDCDelta<float>& mIDCsGrouped;                                         
  const std::array<std::vector<float>, Mapper::NREGIONS>& mWeightsPad{}; 
  const std::array<std::vector<float>, Mapper::NREGIONS>& mWeightsRow{}; 
  const IDCDelta<float>& mIDCsUngrouped;                                 
  std::vector<RobustAverage>& mRobustAverage;                            
  const IDCGroupHelperSector& mIDCGroupHelperSector;                     
  CRU mCRU{};                                                            
  unsigned int mThreadNum{};                                             
  unsigned int mIntegrationInterval{};                                   
  unsigned int mOffsetUngrouped{};                                       
  unsigned int mOffsetGrouped{};                                         
 
  void setGroupedIDC(const unsigned int glrow, const unsigned int padGrouped, const float val);
};
 
template <>
class IDCAverageGroupHelper<IDCAverageGroupDraw> : public IDCGroupHelperRegion
{
 public:
  IDCAverageGroupHelper(const unsigned char groupPads, const unsigned char groupRows, const unsigned char groupLastRowsThreshold, const unsigned char groupLastPadsThreshold, const unsigned int groupNotnPadsSectorEdges, const unsigned int region, const unsigned int nPads, const PadRegionInfo& padInf, TH2Poly& poly)
    : IDCGroupHelperRegion{groupPads, groupRows, groupLastRowsThreshold, groupLastPadsThreshold, groupNotnPadsSectorEdges, region}, mCountDraw(nPads), mPadInf{padInf}, mPoly{poly} {};
 
  std::vector<int> mCountDraw;                  
  const PadRegionInfo& mPadInf;                 
  TH2Poly& mPoly;                               
  int mGroupCounter = 0;                        
  int mCol = 0;                                 
  const std::array<int, 4> mColors{1, 2, 3, 4}; 
};
 
} // namespace o2::tpc
 
#endif