KrBoxClusterFinder.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_KrBoxClusterFinder_H_
#define ALICEO2_TPC_KrBoxClusterFinder_H_
 
#include "DataFormatsTPC/Digit.h"
#include "DataFormatsTPC/KrCluster.h"
#include "TPCReconstruction/KrBoxClusterFinderParam.h"
 
#include "TPCBase/Mapper.h"
 
#include "TPCBase/CalDet.h"
 
#include <tuple>
#include <vector>
#include <array>
#include <deque>
#include <gsl/span>
 
namespace o2
{
namespace tpc
{
 
 
class KrBoxClusterFinder
{
 private:
  static constexpr size_t MaxPads = 138; 
  static constexpr size_t MaxRows = 152; 
  size_t mMaxTimes = 114048;             
 
 public:
  explicit KrBoxClusterFinder() = default;
 
  explicit KrBoxClusterFinder(int sector) : mSector(sector){};
 
  void loadGainMapFromFile(const std::string_view calDetFileName, const std::string_view gainMapName = "GainMap");
 
  std::vector<std::tuple<int, int, int>> findLocalMaxima(bool directFilling = true, const int timeOffset = 0);
 
  KrCluster buildCluster(int clusterCenterPad, int clusterCenterRow, int clusterCenterTime, bool directFilling = false, const int timeOffset = 0);
 
  void resetClusters() { mClusters.clear(); }
 
  std::vector<KrCluster>& getClusters() { return mClusters; }
  const std::vector<KrCluster>& getClusters() const { return mClusters; }
 
  void setSector(int sector) { mSector = sector; }
 
  int getSector() const { return mSector; }
 
  void init();
 
  void setMinNumberOfNeighbours(int minNumberOfNeighbours) { mMinNumberOfNeighbours = minNumberOfNeighbours; }
 
  void setMinQTreshold(int minQThreshold) { mQThresholdMax = minQThreshold; }
 
  void setMaxTimes(int maxTimes) { mMaxTimes = maxTimes; }
 
  void setMaxClusterSize(int maxClusterSizeRowIROC, int maxClusterSizeRowOROC1, int maxClusterSizeRowOROC2, int maxClusterSizeRowOROC3,
                         int maxClusterSizePadIROC, int maxClusterSizePadOROC1, int maxClusterSizePadOROC2, int maxClusterSizePadOROC3,
                         int maxClusterSizeTime)
  {
    mMaxClusterSizeRowIROC = maxClusterSizeRowIROC;
    mMaxClusterSizeRowOROC1 = maxClusterSizeRowOROC1;
    mMaxClusterSizeRowOROC2 = maxClusterSizeRowOROC2;
    mMaxClusterSizeRowOROC3 = maxClusterSizeRowOROC3;
 
    mMaxClusterSizePadIROC = maxClusterSizePadIROC;
    mMaxClusterSizePadOROC1 = maxClusterSizePadOROC1;
    mMaxClusterSizePadOROC2 = maxClusterSizePadOROC2;
    mMaxClusterSizePadOROC3 = maxClusterSizePadOROC3;
 
    mMaxClusterSizeTime = maxClusterSizeTime;
  }
 
  void loopOverSector(const gsl::span<const Digit> eventSector, const int sector);
 
  void loopOverSector(const std::vector<Digit>& eventSector, const int sector)
  {
    loopOverSector(gsl::span(eventSector.data(), eventSector.size()), sector);
  }
 
 private:
  // These variables can be varied
  // They were choses such that the box in each readout chamber is approx. the same size
  // NOTE: They will be overwritten by the values in KrBoxClusterFinderParam in case the init() function is called
  int mMaxClusterSizeTime = 3; 
  int mMaxClusterSizeRow;      
  int mMaxClusterSizePad;      
 
  int mMaxClusterSizeRowIROC = 3;  
  int mMaxClusterSizeRowOROC1 = 2; 
  int mMaxClusterSizeRowOROC2 = 2; 
  int mMaxClusterSizeRowOROC3 = 1; 
 
  int mMaxClusterSizePadIROC = 5;  
  int mMaxClusterSizePadOROC1 = 3; 
  int mMaxClusterSizePadOROC2 = 3; 
  int mMaxClusterSizePadOROC3 = 3; 
 
  float mQThresholdMax = 30.0;    
  float mQThreshold = 1.0;        
  int mMinNumberOfNeighbours = 2; 
 
  float mCutMinSigmaTime{0};      
  float mCutMaxSigmaTime{1000};   
  float mCutMinSigmaPad{0};       
  float mCutMaxSigmaPad{1000};    
  float mCutMinSigmaRow{0};       
  float mCutMaxSigmaRow{1000};    
  float mCutMaxQtot{1e10};        
  float mCutQtot0{1e10};          
  float mCutQtotSizeSlope{0};     
  unsigned char mCutMaxSize{255}; 
  bool mApplyCuts{false};         
 
  int mSector = -1;                 
  std::unique_ptr<CalPad> mGainMap; 
 
  static constexpr size_t MaxRowsIROC = 63;  
  static constexpr size_t MaxRowsOROC1 = 34; 
  static constexpr size_t MaxRowsOROC2 = 30; 
  static constexpr size_t MaxRowsOROC3 = 25; 
 
  std::vector<o2::tpc::KrCluster> mClusters;
 
  const Mapper& mMapperInstance = o2::tpc::Mapper::instance();
 
  KrCluster mTempCluster; 
 
  using TimeSliceSector = std::array<std::array<float, MaxPads>, MaxRows>;
 
  // TimeSliceSector mTempTimeSlice;
 
  size_t mFirstDigit = 0;
 
  std::deque<TimeSliceSector> mSetOfTimeSlices{};
 
  struct ThresholdInfo {
    bool digitAboveThreshold{};
    std::array<bool, MaxRows> rowAboveThreshold{};
  };
 
  std::deque<ThresholdInfo> mThresholdInfo{};
 
  void createInitialMap(const gsl::span<const Digit> eventSector);
  void popFirstTimeSliceFromMap()
  {
    mSetOfTimeSlices.pop_front();
    mThresholdInfo.pop_front();
  }
  void fillADCValueInLastSlice(int cru, int rowInSector, int padInRow, float adcValue);
  void addTimeSlice(const gsl::span<const Digit> eventSector, const int timeSlice);
 
  void setMaxClusterSize(int row);
 
  void updateTempCluster(float tempCharge, int tempPad, int tempRow, int tempTime);
  void updateTempClusterFinal(const int timeOffset = 0);
 
  int signnum(int val) { return (0 < val) - (val < 0); }
 
  bool acceptCluster(const KrCluster& cl);
 
  ClassDefNV(KrBoxClusterFinder, 0);
};
 
} // namespace tpc
} // namespace o2
 
#endif