CalibPadGainTracks.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_CalibPadGainTracks_H
#define AliceO2_TPC_CalibPadGainTracks_H
 
// o2 includes
#include "DataFormatsTPC/TrackTPC.h"
#include "TPCBase/CalDet.h"
#include "TPCCalibration/CalibPadGainTracksBase.h"
#include "CalibdEdxTrackTopologyPol.h"
#include "TPCFastTransform.h"
 
#include <vector>
#include <gsl/span>
#include <tuple>
 
class TCanvas;
 
namespace o2
{
 
namespace gpu
{
class GPUO2InterfaceRefit;
class CorrectionMapsHelper;
}
 
namespace tpc
{
 
class ClusterNativeAccess;
class ClusterNative;
class VDriftCorrFact;
 
 
class CalibPadGainTracks : public CalibPadGainTracksBase
{
 
 public:
  enum DEdxType : unsigned char {
    dedxTrack,    
    dedxTracking, 
    dedxBB        
  };
 
  enum DEdxRegion : unsigned char {
    chamber, 
    stack,   
    sector   
  };
 
  CalibPadGainTracks(const bool initCalPad = true) : CalibPadGainTracksBase(initCalPad) { reserveMemory(); }
 
  ~CalibPadGainTracks() = default;
 
  void processTracks(const int nMaxTracks = -1);
 
  void setMembers(gsl::span<const o2::tpc::TrackTPC>* vTPCTracksArrayInp, gsl::span<const o2::tpc::TPCClRefElem>* tpcTrackClIdxVecInput, const o2::tpc::ClusterNativeAccess& clIndex, gsl::span<const unsigned char> TPCRefitterShMap, gsl::span<const unsigned int> TPCRefitterOccMap);
 
  void setMode(DEdxType iMode) { mMode = iMode; }
 
  void setMomentumRange(const float momMin, const float momMax);
 
  void setMaxEta(const float eta) { mEtaMax = eta; }
 
  void setdEdxMin(const float mindedx) { mDedxMin = mindedx; }
 
  void setdEdxMax(const float maxdEdx) { mDedxMax = maxdEdx; }
 
  void doNotNomalize(const bool doNotNormCharge) { mDoNotNormCharge = doNotNormCharge; }
 
  void setMinNClusters(const int nCl) { mMinClusters = nCl; }
 
  void setPropagateTrack(const bool propagate) { mPropagateTrack = propagate; }
 
  void setFieldNominalGPUBz(const float field) { mFieldNominalGPUBz = field; }
 
  void setChargeType(const ChargeType chargeType) { mChargeType = chargeType; }
 
  void setRefGainMap(const char* inpFile, const char* mapName);
 
  void setRefGainMap(const CalPad& gainmap) { mGainMapRef = std::make_unique<CalPad>(gainmap); }
 
  void setdEdxRegion(const DEdxRegion dedx);
 
  float getMomMin() const { return mMomMin; }
 
  float getMomMax() const { return mMomMax; }
 
  float getEtaMax() const { return mEtaMax; }
 
  float getdEdxMin() const { return mDedxMin; }
 
  float getdEdxMax() const { return mDedxMax; }
 
  bool getdoNotNomalize() const { return mDoNotNormCharge; }
 
  float getMinNClusters() const { return mMinClusters; }
 
  bool getPropagateTrack() const { return mPropagateTrack; }
 
  float getFieldNominalGPUBz() const { return mFieldNominalGPUBz; };
 
  void dumpToFile(const char* outFileName = "calPadGainTracks.root", const char* outName = "calPadGain") const;
 
  void loadPolTopologyCorrectionFromFile(std::string_view fileName);
 
  void setPolTopologyCorrectionFromContainer(const CalibdEdxTrackTopologyPolContainer& polynomials);
 
  void drawReferenceGainMapSector(const int sector, const std::string filename = "GainMapSector.pdf", const float minZ = 0, const float maxZ = -1) const { drawRefGainMapHelper(false, sector, filename, minZ, maxZ); }
 
  void drawReferenceGainMapSide(const o2::tpc::Side side, const std::string filename = "GainMapSide.pdf", const float minZ = 0, const float maxZ = -1) const { drawRefGainMapHelper(true, side == Side::A ? Sector(0) : Sector(Sector::MAXSECTOR - 1), filename, minZ, maxZ); }
 
  void dumpReferenceExtractedGainMap(const char* outFileName = "GainMapRefExtracted.root", const char* outName = "GainMap") const;
 
  void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
 
  void setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph);
 
 private:
  gsl::span<const TrackTPC>* mTracks{nullptr};                                        
  gsl::span<const TPCClRefElem>* mTPCTrackClIdxVecInput{nullptr};                     
  const o2::tpc::ClusterNativeAccess* mClusterIndex{nullptr};                         
  gsl::span<const unsigned char> mTPCRefitterShMap;                                   
  gsl::span<const unsigned int> mTPCRefitterOccMap;                                   
  std::vector<unsigned char> mBufVec;                                                 
  DEdxType mMode = dedxTrack;                                                         
  DEdxRegion mDedxRegion = stack;                                                     
  float mFieldNominalGPUBz{-5};                                                       
  float mMomMin{0.1f};                                                                
  float mMomMax{5.f};                                                                 
  float mDedxMin{0.f};                                                                
  float mDedxMax{-1.f};                                                               
  float mEtaMax{1.f};                                                                 
  float mTPCVDriftRef = -1.;                                                          
  float mTPCVDriftCorrFact = 1.;                                                      
  float mTPCVDrift = -1.;                                                             
  float mTPCDriftTimeOffset = 0.;                                                     
  int mMinClusters{50};                                                               
  bool mPropagateTrack{false};                                                        
  bool mDoNotNormCharge{false};                                                       
  ChargeType mChargeType{ChargeType::Max};                                            
  o2::gpu::CorrectionMapsHelper* mTPCCorrMapsHelper = nullptr;                        
  std::vector<std::vector<float>> mDEdxBuffer{};                                      
  std::vector<std::tuple<unsigned char, unsigned char, unsigned char, float>> mClTrk; 
  std::vector<float> mDedxTmp{};                                                      
  std::unique_ptr<CalPad> mGainMapRef;                                                
  std::unique_ptr<CalibdEdxTrackTopologyPol> mCalibTrackTopologyPol;                  
 
  void processTrack(TrackTPC track, o2::gpu::GPUO2InterfaceRefit* refit);
 
  static int getIndex(o2::tpc::PadSubset padSub, int padSubsetNumber, const int row, const int pad);
 
  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) const;
 
  void getTruncMean(float low = 0.05f, float high = 0.6f);
 
  void drawRefGainMapHelper(const bool type, const Sector sector, const std::string filename, const float minZ, const float maxZ) const;
 
  void reserveMemory();
 
  void resizedEdxBuffer();
 
  int getdEdxBufferIndex(const int region) const;
 
  float getdEdxIROC(const dEdxInfo& dedx) const { return (mChargeType == ChargeType::Max) ? dedx.dEdxMaxIROC : dedx.dEdxTotIROC; }
  float getdEdxOROC1(const dEdxInfo& dedx) const { return (mChargeType == ChargeType::Max) ? dedx.dEdxMaxOROC1 : dedx.dEdxTotOROC1; }
  float getdEdxOROC2(const dEdxInfo& dedx) const { return (mChargeType == ChargeType::Max) ? dedx.dEdxMaxOROC2 : dedx.dEdxTotOROC2; }
  float getdEdxOROC3(const dEdxInfo& dedx) const { return (mChargeType == ChargeType::Max) ? dedx.dEdxMaxOROC3 : dedx.dEdxTotOROC3; }
  float getdEdxTPC(const dEdxInfo& dedx) const { return (mChargeType == ChargeType::Max) ? dedx.dEdxMaxTPC : dedx.dEdxTotTPC; }
};
 
} // namespace tpc
} // namespace o2
 
#endif