CalculatedEdx.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_CalculatedEdx_H
#define AliceO2_TPC_CalculatedEdx_H
 
// o2 includes
#include "DataFormatsTPC/TrackTPC.h"
#include "DataFormatsTPC/dEdxInfo.h"
#include "GPUO2InterfaceRefit.h"
#include "CalibdEdxContainer.h"
#include "CommonUtils/TreeStreamRedirector.h"
#include "TPCCalibration/CorrectdEdxDistortions.h"
#include "TPCFastTransformPOD.h"
#include <vector>
 
namespace o2::tpc
{
 
 
enum class CorrectionFlags : unsigned short {
  None = 0,
  TopologySimple = 1 << 0, 
  TopologyPol = 1 << 1,    
  GainFull = 1 << 2,       
  GainResidual = 1 << 3,   
  dEdxResidual = 1 << 4,   
  dEdxSC = 1 << 5,         
};
 
enum class ClusterFlags : unsigned short {
  None = 0,
  ExcludeSingleCl = 1 << 0,         
  ExcludeSplitCl = 1 << 1,          
  ExcludeEdgeCl = 1 << 2,           
  ExcludeSubthresholdCl = 1 << 3,   
  ExcludeSectorBoundaries = 1 << 4, 
  ExcludeSharedCl = 1 << 5,         
};
 
inline CorrectionFlags operator&(CorrectionFlags a, CorrectionFlags b) { return static_cast<CorrectionFlags>(static_cast<unsigned short>(a) & static_cast<unsigned short>(b)); }
inline CorrectionFlags operator~(CorrectionFlags a) { return static_cast<CorrectionFlags>(~static_cast<unsigned short>(a)); }
inline CorrectionFlags operator|(CorrectionFlags a, CorrectionFlags b) { return static_cast<CorrectionFlags>(static_cast<unsigned short>(a) | static_cast<unsigned short>(b)); }
 
inline ClusterFlags operator&(ClusterFlags a, ClusterFlags b) { return static_cast<ClusterFlags>(static_cast<unsigned short>(a) & static_cast<unsigned short>(b)); }
inline ClusterFlags operator~(ClusterFlags a) { return static_cast<ClusterFlags>(~static_cast<unsigned short>(a)); }
inline ClusterFlags operator|(ClusterFlags a, ClusterFlags b) { return static_cast<ClusterFlags>(static_cast<unsigned short>(a) | static_cast<unsigned short>(b)); }
 
class CalculatedEdx
{
 public:
  CalculatedEdx();
 
  ~CalculatedEdx() = default;
 
  void setMembers(std::vector<o2::tpc::TPCClRefElem>* tpcTrackClIdxVecInput, const o2::tpc::ClusterNativeAccess& clIndex, std::vector<o2::tpc::TrackTPC>* vTPCTracksArrayInp);
 
  void setRefit(const unsigned int nHbfPerTf = 32);
 
  void setPropagateTrack(const bool propagate) { mPropagateTrack = propagate; }
 
  void setDebug(const bool debug) { mDebug = debug; }
 
  void setFieldNominalGPUBz(const float field) { mFieldNominalGPUBz = field; }
 
  void setMaxMissingCl(int maxMissingCl) { mMaxMissingCl = maxMissingCl; }
 
  void setMinChargeTotThreshold(float minChargeTotThreshold) { mMinChargeTotThreshold = minChargeTotThreshold; }
 
  void setMinChargeMaxThreshold(float minChargeMaxThreshold) { mMinChargeMaxThreshold = minChargeMaxThreshold; }
 
  void setStreamer(const char* debugRootFile) { mStreamer = std::make_unique<o2::utils::TreeStreamRedirector>(debugRootFile, "recreate"); };
 
  void setSCStreamer(const char* debugRootFile = "debug_sc_corrections.root") { mSCdEdxCorrection.setStreamer(debugRootFile); }
 
  float getFieldNominalGPUBz() { return mFieldNominalGPUBz; }
 
  int getMaxMissingCl() { return mMaxMissingCl; }
 
  float getMinChargeTotThreshold() { return mMinChargeTotThreshold; }
 
  float getMinChargeMaxThreshold() { return mMinChargeMaxThreshold; }
 
  void fillMissingClusters(int missingClusters[4], float minChargeTot, float minChargeMax, int method, std::array<std::vector<float>, 5>& chargeTotROC, std::array<std::vector<float>, 5>& chargeMaxROC);
 
  void calculatedEdx(TrackTPC& track, dEdxInfo& output, float low = 0.015f, float high = 0.6f, CorrectionFlags correctionMask = CorrectionFlags::TopologyPol | CorrectionFlags::dEdxResidual, ClusterFlags clusterMask = ClusterFlags::None, int subthresholdMethod = 0, const char* debugRootFile = "dEdxDebug.root");
 
  float getTruncMean(std::vector<float>& charge, float low, float high) const;
 
  float getTrackTopologyCorrection(const o2::tpc::TrackTPC& track, const unsigned int region) const;
 
  float getTrackTopologyCorrectionPol(const o2::tpc::TrackTPC& track, const o2::tpc::ClusterNative& cl, const unsigned int region, const float charge, ChargeType chargeType, const float threshold) const;
 
  void loadCalibsFromCCDB(long runNumberOrTimeStamp, const bool isMC = false);
 
  void loadCalibsFromLocalCCDBFolder(const char* localCCDBFolder);
 
  void setTrackTopologyCorrectionFromFile(const char* folder, const char* file, const char* object);
 
  void setGainMapFromFile(const char* folder, const char* file, const char* object);
 
  void setGainMapResidualFromFile(const char* folder, const char* file, const char* object);
 
  void setResidualCorrectionFromFile(const char* folder, const char* file, const char* object);
 
  void setZeroSuppressionThresholdFromFile(const char* folder, const char* file, const char* object);
 
  void setMagneticFieldFromFile(const char* folder, const char* file, const char* object);
 
  void setPropagatorFromFile(const char* folder, const char* file, const char* object);
 
  void setLumi(const float lumi) { mSCdEdxCorrection.setLumi(lumi); }
 
  auto& getSCCorrection() { return mSCdEdxCorrection; }
 
  unsigned int getOccupancy(const o2::tpc::ClusterNative& cl) const;
 
 private:
  std::vector<TrackTPC>* mTracks{nullptr};                    
  std::vector<TPCClRefElem>* mTPCTrackClIdxVecInput{nullptr}; 
  const o2::tpc::ClusterNativeAccess* mClusterIndex{nullptr}; 
  const o2::gpu::TPCFastTransformPOD* mTPCCorrMap{nullptr};   
  o2::gpu::aligned_unique_buffer_ptr<o2::gpu::TPCFastTransformPOD> mTPCCorrMapBuffer;
  std::vector<unsigned char> mTPCRefitterShMap;                  
  std::vector<unsigned int> mTPCRefitterOccMap;                  
  std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mRefit{nullptr}; 
 
  int mMaxMissingCl{1};                                                
  float mMinChargeTotThreshold{50};                                    
  float mMinChargeMaxThreshold{50};                                    
  float mFieldNominalGPUBz{5};                                         
  bool mPropagateTrack{false};                                         
  bool mDebug{false};                                                  
  CalibdEdxContainer mCalibCont;                                       
  std::unique_ptr<o2::utils::TreeStreamRedirector> mStreamer{nullptr}; 
 
  CorrectdEdxDistortions mSCdEdxCorrection; 
};
 
} // namespace o2::tpc
 
#endif