HwClusterer.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_HWClusterer_H_
#define ALICEO2_TPC_HWClusterer_H_
 
#include <Vc/Vc>
 
#include "TPCReconstruction/Clusterer.h"
#include "DataFormatsTPC/Helpers.h"
 
#include "SimulationDataFormat/ConstMCTruthContainer.h"
#include "SimulationDataFormat/MCCompLabel.h"
 
#include <vector>
#include <utility>
#include <memory>
 
namespace o2
{
namespace tpc
{
 
class Digit;
class ClusterHardware;
 
class HwClusterer : public Clusterer
{
 private:
  using MCLabelContainer = o2::dataformats::MCLabelContainer;
  using ConstMCLabelContainerView = o2::dataformats::ConstMCLabelContainerView;
  HwClusterer(
    std::vector<ClusterHardwareContainer8kb>* clusterOutputContainer,
    MCLabelContainer* labelOutput);
 
 public:
  HwClusterer(
    std::vector<ClusterHardwareContainer8kb>* clusterOutput,
    int sectorid,
    MCLabelContainer* labelOutput = nullptr);
 
  ~HwClusterer() override = default;
 
  HwClusterer(HwClusterer const& other) = default;
 
  void init();
 
  void process(gsl::span<o2::tpc::Digit const> const& digits, ConstMCLabelContainerView const& mcDigitTruth) override;
  void process(gsl::span<o2::tpc::Digit const> const& digits, ConstMCLabelContainerView const& mcDigitTruth, bool clearContainerFirst);
 
  void finishProcess(gsl::span<o2::tpc::Digit const> const& digits, ConstMCLabelContainerView const& mcDigitTruth) override;
  void finishProcess(gsl::span<o2::tpc::Digit const> const& digits, ConstMCLabelContainerView const& mcDigitTruth, bool clearContainerFirst);
 
  void setContinuousReadout(bool isContinuous);
 
  void setPeakChargeThreshold(unsigned charge);
 
  void setContributionChargeThreshold(unsigned charge);
 
  void setRejectSinglePadClusters(bool doReject);
 
  void setRejectSingleTimeClusters(bool doReject);
 
  void setRejectLaterTimebin(bool doReject);
 
  void setSplittingMode(short mode);
 
 private:
  /*
   * Helper functions
   */
 
  void hwClusterProcessor(Vc::uint_m peakMask, unsigned qMaxIndex, short centerPad, int centerTime, unsigned short row);
 
  void hwPeakFinder(unsigned qMaxIndex, short centerPad, int mappedCenterTime, unsigned short row);
 
  void updateCluster(const Vc::uint_m selectionMask, int row, short centerPad, int centerTime, short dp, short dt, Vc::uint_v& qTot, Vc::int_v& pad, Vc::int_v& time, Vc::int_v& sigmaPad2, Vc::int_v& sigmaTime2, std::vector<std::unique_ptr<std::vector<std::pair<MCCompLabel, unsigned>>>>& mcLabels, Vc::uint_m splitMask = Vc::Mask<uint>(false));
 
  void writeOutputWithTimeOffset(int timeOffset);
 
  void computeClusterForTime(int timebin);
 
  void findPeaksForTime(int timebin);
 
  void finishFrame(bool clear = false);
 
  void clearBuffer(int timebin);
 
  short getFirstSetBitOfField();
 
  int mapTimeInRange(int time);
 
  Vc::uint_v getFpOfADC(const Vc::uint_v value);
 
  /*
   * class members
   */
  static const int mTimebinsInBuffer = 6;
 
  unsigned short mNumRows;               
  unsigned short mNumRowSets;            
  short mCurrentMcContainerInBuffer;     
  short mSplittingMode;                  
  int mClusterSector;                    
  int mPreviousTimebin;                  
  int mFirstTimebin;                     
  int mLastTimebin;                      
  unsigned mLastHB;                      
  unsigned mPeakChargeThreshold;         
  unsigned mContributionChargeThreshold; 
  unsigned mClusterCounter;              
  bool mIsContinuousReadout;             
  bool mRejectSinglePadClusters;         
  bool mRejectSingleTimeClusters;        
  bool mRejectLaterTimebin;              
 
  std::vector<unsigned short> mPadsPerRow;                       
  std::vector<unsigned short> mPadsPerRowSet;                    
  std::vector<unsigned short> mGlobalRowToRegion;                
  std::vector<unsigned short> mGlobalRowToLocalRow;              
  std::vector<unsigned short> mGlobalRowToVcIndex;               
  std::vector<unsigned short> mGlobalRowToRowSet;                
  std::vector<std::vector<Vc::uint_v>> mDataBuffer;              
  std::vector<std::vector<Vc::int_v>> mIndexBuffer;              
  std::vector<std::shared_ptr<MCLabelContainer const>> mMCtruth; 
 
  std::vector<std::unique_ptr<std::vector<ClusterHardware>>> mTmpClusterArray;                             
  std::vector<std::unique_ptr<std::vector<std::vector<std::pair<MCCompLabel, unsigned>>>>> mTmpLabelArray; 
 
  std::vector<ClusterHardwareContainer8kb>* mClusterArray; 
  MCLabelContainer* mClusterMcLabelArray;                  
};
 
inline void HwClusterer::process(gsl::span<o2::tpc::Digit const> const& digits, ConstMCLabelContainerView const& mcDigitTruth)
{
  process(digits, mcDigitTruth, true);
}
 
inline void HwClusterer::finishProcess(gsl::span<o2::tpc::Digit const> const& digits, ConstMCLabelContainerView const& mcDigitTruth)
{
  finishProcess(digits, mcDigitTruth, true);
}
 
inline void HwClusterer::setContinuousReadout(bool isContinuous)
{
  mIsContinuousReadout = isContinuous;
}
 
inline void HwClusterer::setPeakChargeThreshold(unsigned charge)
{
  mPeakChargeThreshold = charge;
}
 
inline void HwClusterer::setContributionChargeThreshold(unsigned charge)
{
  mContributionChargeThreshold = charge;
}
 
inline void HwClusterer::setRejectSinglePadClusters(bool doReject)
{
  mRejectSinglePadClusters = doReject;
}
 
inline void HwClusterer::setRejectSingleTimeClusters(bool doReject)
{
  mRejectSingleTimeClusters = doReject;
}
 
inline void HwClusterer::setRejectLaterTimebin(bool doReject)
{
  mRejectLaterTimebin = doReject;
}
 
inline void HwClusterer::setSplittingMode(short mode)
{
  mSplittingMode = mode;
}
 
inline int HwClusterer::mapTimeInRange(int time)
{
  return (mTimebinsInBuffer + (time % mTimebinsInBuffer)) % mTimebinsInBuffer;
}
 
inline Vc::uint_v HwClusterer::getFpOfADC(const Vc::uint_v value)
{
  return value & 0x3FFF;
}
 
inline short HwClusterer::getFirstSetBitOfField()
{
  for (short i = 0; i < mTimebinsInBuffer; ++i) {
    if ((mCurrentMcContainerInBuffer >> i) & 0x1) {
      return i;
    }
  }
  return -1;
}
 
} // namespace tpc
} // namespace o2
 
#endif