CalibdEdxContainer.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_CALIBDEDXCONTAINER_H_
#define ALICEO2_TPC_CALIBDEDXCONTAINER_H_
 
#include "GPUCommonRtypes.h"
#include "GPUCommonDef.h"
#include "GPUCommonMath.h"
#include "DataFormatsTPC/CalibdEdxCorrection.h"
#include "CalibdEdxTrackTopologyPol.h"
#include "CalibdEdxTrackTopologySpline.h"
#include "FlatObject.h"
#include "TPCPadGainCalib.h"
#include "TPCPadBitMap.h"
 
#ifndef GPUCA_GPUCODE_DEVICE
#include <string_view>
#endif
 
namespace o2::tpc
{
 
enum class CalibsdEdx : uint16_t {
  CalTopologySpline = 1 << 0,  
  CalTopologyPol = 1 << 1,     
  CalThresholdMap = 1 << 2,    
  CalGainMap = 1 << 3,         
  CalResidualGainMap = 1 << 4, 
  CalTimeGain = 1 << 5,        
};
 
inline CalibsdEdx operator|(CalibsdEdx a, CalibsdEdx b) { return static_cast<CalibsdEdx>(static_cast<int32_t>(a) | static_cast<int32_t>(b)); }
 
inline CalibsdEdx operator&(CalibsdEdx a, CalibsdEdx b) { return static_cast<CalibsdEdx>(static_cast<int32_t>(a) & static_cast<int32_t>(b)); }
 
inline CalibsdEdx operator~(CalibsdEdx a) { return static_cast<CalibsdEdx>(~static_cast<int32_t>(a)); }
 
class CalibdEdxContainer : public o2::gpu::FlatObject
{
 public:
#ifndef GPUCA_GPUCODE
  CalibdEdxContainer() = default;
#endif
 
  CalibdEdxContainer(const CalibdEdxContainer&) = delete;
 
  CalibdEdxContainer& operator=(const CalibdEdxContainer&) = delete;
 
  ~CalibdEdxContainer() = default;
 
  GPUd() float getTopologyCorrection(const int32_t region, const ChargeType chargeT, const float tanTheta, const float sinPhi, const float z, const float relPad, const float relTime, const float threshold, const float charge) const
  {
    return mCalibTrackTopologyPol ? mCalibTrackTopologyPol->getCorrection(region, chargeT, tanTheta, sinPhi, z, relPad, relTime, threshold, charge) : (mCalibTrackTopologySpline ? mCalibTrackTopologySpline->getCorrection(region, chargeT, tanTheta, sinPhi, z) : getDefaultTopologyCorrection(tanTheta, sinPhi));
  }
 
  GPUd() float getTopologyCorrection(const int32_t region, const ChargeType chargeT, float x[]) const
  {
    return mCalibTrackTopologyPol ? mCalibTrackTopologyPol->getCorrection(region, chargeT, x) : (mCalibTrackTopologySpline ? mCalibTrackTopologySpline->getCorrection(region, chargeT, x) : getDefaultTopologyCorrection(x[0], x[1]));
  }
 
  GPUd() float getDefaultTopologyCorrection(const float tanTheta, const float sinPhi) const { return gpu::CAMath::Sqrt(tanTheta * tanTheta + 1 / (1 - sinPhi * sinPhi)); }
 
#if !defined(GPUCA_GPUCODE)
  float getMinZeroSupresssionThreshold() const;
 
  float getMaxZeroSupresssionThreshold() const;
#endif
 
  GPUd() float getZeroSupressionThreshold(const int32_t sector, const gpu::tpccf::Row row, const gpu::tpccf::Pad pad) const { return mThresholdMap.getGainCorrection(sector, row, pad); }
 
  GPUd() float getGain(const int32_t sector, const gpu::tpccf::Row row, const gpu::tpccf::Pad pad) const { return mGainMap.getGainCorrection(sector, row, pad); }
 
  GPUd() float getResidualGain(const int32_t sector, const gpu::tpccf::Row row, const gpu::tpccf::Pad pad) const { return mGainMapResidual.getGainCorrection(sector, row, pad); }
 
  GPUd() bool isDead(const int32_t sector, const gpu::tpccf::Row row, const gpu::tpccf::Pad pad) const { return mDeadChannelMap.isSet(sector, row, pad); }
 
  GPUd() float getResidualCorrection(const StackID& stack, const ChargeType charge, const float tgl = 0, const float snp = 0) const { return mCalibResidualdEdx.getCorrection(stack, charge, tgl, snp); }
 
  GPUd() bool isUsageOfFullGainMap() const { return mApplyFullGainMap; }
 
#if !defined(GPUCA_GPUCODE)
  void cloneFromObject(const CalibdEdxContainer& obj, char* newFlatBufferPtr);
 
  void moveBufferTo(char* newBufferPtr);
#endif
 
  void destroy();
 
  void setActualBufferAddress(char* actualFlatBufferPtr);
 
  void setFutureBufferAddress(char* futureFlatBufferPtr);
 
#if !defined(GPUCA_GPUCODE)
  // loading the polynomial track topology correction from a file
  void loadPolTopologyCorrectionFromFile(std::string_view fileName);
 
  // loading the spline track topology correction from a file
  void loadSplineTopologyCorrectionFromFile(std::string_view fileName);
 
  void setPolTopologyCorrection(const CalibdEdxTrackTopologyPol& calibTrackTopology);
 
  void setDefaultPolTopologyCorrection();
 
  void setSplineTopologyCorrection(const CalibdEdxTrackTopologySpline& calibTrackTopology);
 
  // loading the residual dE/dx correction from a file
  void loadResidualCorrectionFromFile(std::string_view fileName) { mCalibResidualdEdx.loadFromFile(fileName); }
 
  void setResidualCorrection(const CalibdEdxCorrection& residualCorr) { mCalibResidualdEdx = residualCorr; }
 
  // loading the zero supression threshold map from a file
  void loadZeroSupresssionThresholdFromFile(std::string_view fileName, std::string_view objName, const float minCorrectionFactor, const float maxCorrectionFactor);
 
  void setZeroSupresssionThreshold(const CalDet<float>& thresholdMap) { setZeroSupresssionThreshold(thresholdMap, getMinZeroSupresssionThreshold(), getMaxZeroSupresssionThreshold()); }
 
  void setZeroSupresssionThreshold(const CalDet<float>& thresholdMap, const float minCorrectionFactor, const float maxCorrectionFactor);
 
  void setDeadChannelMap(const CalDet<bool>& deadMap);
 
  void setGainMap(const CalDet<float>& gainMap, const float minGain, const float maxGain);
 
  void setGainMapResidual(const CalDet<float>& gainMapResidual, const float minResidualGain = 0.7f, const float maxResidualGain = 1.3f);
 
  void setDefaultZeroSupresssionThreshold();
 
  bool isTopologyCorrectionSplinesSet() const { return mCalibTrackTopologySpline ? true : false; }
 
  bool isTopologyCorrectionPolynomialsSet() const { return mCalibTrackTopologyPol ? true : false; }
 
  void setCorrectionCCDB(const CalibsdEdx calib) { mCalibsLoad = calib | mCalibsLoad; }
 
  void disableCorrectionCCDB(const CalibsdEdx calib) { mCalibsLoad = ~calib & mCalibsLoad; }
 
  bool isCorrectionCCDB(const CalibsdEdx calib) const { return ((mCalibsLoad & calib) == calib) ? true : false; }
 
  void setUsageOfFullGainMap(const bool applyFullGainMap) { mApplyFullGainMap = applyFullGainMap; }
#endif // !GPUCA_GPUCODE
 
 private:
  CalibdEdxTrackTopologySpline* mCalibTrackTopologySpline{nullptr}; 
  CalibdEdxTrackTopologyPol* mCalibTrackTopologyPol{nullptr};       
  o2::gpu::TPCPadGainCalib mThresholdMap{};                         
  o2::gpu::TPCPadGainCalib mGainMap{};                              
  o2::gpu::TPCPadGainCalib mGainMapResidual{};                      
  o2::gpu::TPCPadBitMap mDeadChannelMap{};                          
  CalibdEdxCorrection mCalibResidualdEdx{};                         
  bool mApplyFullGainMap{false};                                    
 
  CalibsdEdx mCalibsLoad{CalibsdEdx::CalTopologyPol | CalibsdEdx::CalThresholdMap | CalibsdEdx::CalGainMap |
                         CalibsdEdx::CalResidualGainMap | CalibsdEdx::CalTimeGain}; 
 
#if !defined(GPUCA_GPUCODE)
  template <class Type>
  std::size_t sizeOfCalibdEdxTrackTopologyObj() const
  {
    return alignSize(sizeof(Type), FlatObject::getClassAlignmentBytes());
  }
 
  template <class Type>
  void loadTopologyCorrectionFromFile(std::string_view fileName, Type*& obj);
 
  template <class Type>
  void setTopologyCorrection(const Type& calibTrackTopologyTmp, Type*& obj);
#endif
 
  template <class Type>
  void setActualBufferAddress(Type*& obj);
 
  template <class Type>
  void setFutureBufferAddress(Type*& obj, char* futureFlatBufferPtr);
 
#if !defined(GPUCA_GPUCODE)
  template <class Type>
  void subobjectCloneFromObject(Type*& obj, const Type* objOld);
 
  CalDet<float> processThresholdMap(const CalDet<float>& thresholdMap, const float maxThreshold, const int32_t nPadsInRowCl = 2, const int32_t nPadsInPadCl = 2) const;
#endif
 
  ClassDefNV(CalibdEdxContainer, 2);
};
 
} // namespace o2::tpc
 
#endif