CalibdEdxTrackTopologyPol.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_CALIBDEDXTRACKTOPOLOGYPOL_H_
#define ALICEO2_TPC_CALIBDEDXTRACKTOPOLOGYPOL_H_
 
#include "GPUCommonRtypes.h"
#include "NDPiecewisePolynomials.h"
#include "GPUCommonDef.h"
#include "FlatObject.h"
#include "DataFormatsTPC/Defs.h"
#ifndef GPUCA_ALIGPUCODE
#include <string_view>
#endif
 
namespace o2::tpc
{
 
#if !defined(GPUCA_GPUCODE)
struct CalibdEdxTrackTopologyPolContainer {
 
  CalibdEdxTrackTopologyPolContainer() = default;
 
  std::vector<gpu::NDPiecewisePolynomialContainer> mCalibPols{}; 
  std::vector<float> mScalingFactorsqTot{};                      
  std::vector<float> mScalingFactorsqMax{};                      
 
  ClassDefNV(CalibdEdxTrackTopologyPolContainer, 2);
};
#endif
 
class CalibdEdxTrackTopologyPol : public o2::gpu::FlatObject
{
 public:
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
  CalibdEdxTrackTopologyPol(std::string_view fileName, std::string_view name = "CalibdEdxTrackTopologyPol") { loadFromFile(fileName.data(), name.data()); };
  CalibdEdxTrackTopologyPol() = default;
 
  ~CalibdEdxTrackTopologyPol() = default;
#endif
 
  GPUd() float getCorrection(const int32_t region, const ChargeType charge, float x[/*inpXdim*/]) const { return (charge == ChargeType::Tot) ? mCalibPolsqTot[region].eval(x) : mCalibPolsqMax[region].eval(x); }
 
  GPUd() float getCorrection(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
  {
    const float corr = (chargeT == ChargeType::Tot) ? getCorrectionqTot(region, tanTheta, sinPhi, z, threshold, charge) : getCorrectionqMax(region, tanTheta, sinPhi, z, relPad, relTime);
    return corr;
  }
 
  GPUd() float getCorrectionqTot(const int32_t region, const float tanTheta, const float sinPhi, const float z, const float threshold, const float charge) const
  {
    float x[]{z, tanTheta, sinPhi, threshold, charge};
    const float corr = mScalingFactorsqTot[region] * mCalibPolsqTot[region].eval(x);
    return corr;
  }
 
  GPUd() float getCorrectionqMax(const int32_t region, const float tanTheta, const float sinPhi, const float z, const float relPad, const float relTime) const
  {
    float x[]{z, tanTheta, sinPhi, relPad, relTime};
    const float corr = mScalingFactorsqMax[region] * mCalibPolsqMax[region].eval(x);
    return corr;
  }
 
  GPUd() float getMinThreshold(const int32_t region = 0) const { return mCalibPolsqTot[region].getXMin(3); };
 
  GPUd() float getMaxThreshold(const int32_t region = 0) const { return mCalibPolsqTot[region].getXMax(3); };
 
  GPUd() float getScalingFactorqTot(const int32_t region) const { return mScalingFactorsqTot[region]; };
 
  GPUd() float getScalingFactorqMax(const int32_t region) const { return mScalingFactorsqMax[region]; };
 
#if !defined(GPUCA_GPUCODE)
  const auto& getPolyqTot(const int32_t region) const { return mCalibPolsqTot[region]; }
 
  const auto& getPolyqMax(const int32_t region) const { return mCalibPolsqMax[region]; }
 
#ifndef GPUCA_STANDALONE
  void setScalingFactorqTot(const float factor, const int32_t region) { mScalingFactorsqTot[region] = factor; };
 
  void setScalingFactorqMax(const float factor, const int32_t region) { mScalingFactorsqMax[region] = factor; };
 
  void writeToFile(TFile& outf, const char* name = "CalibdEdxTrackTopologyPol") const;
 
  void setFromContainer(const CalibdEdxTrackTopologyPolContainer& container);
 
  void loadFromFile(const char* fileName, const char* name);
 
  void dumpToTree(const uint32_t nSamplingPoints[/* Dim */], const char* outName = "track_topology_corr_debug.root") const;
 
  void setPolynomialsFromFile(TFile& inpf);
 
  void setDefaultPolynomials();
#endif
 
  static std::string getPolyName(const int32_t region, const ChargeType charge);
#endif
 
#if !defined(GPUCA_GPUCODE)
  void cloneFromObject(const CalibdEdxTrackTopologyPol& obj, char* newFlatBufferPtr);
 
  void moveBufferTo(char* newBufferPtr);
#endif
 
  void destroy();
 
  void setActualBufferAddress(char* actualFlatBufferPtr);
 
  void setFutureBufferAddress(char* futureFlatBufferPtr);
 
 private:
  constexpr static int32_t FFits{10};                                          
  constexpr static int32_t FDim{5};                                            
  constexpr static int32_t FDegree{3};                                         
  o2::gpu::NDPiecewisePolynomials<FDim, FDegree, false> mCalibPolsqTot[FFits]; 
  o2::gpu::NDPiecewisePolynomials<FDim, FDegree, false> mCalibPolsqMax[FFits]; 
  float mScalingFactorsqTot[FFits]{1, 1, 1, 1, 1, 1, 1, 1, 1, 1};              
  float mScalingFactorsqMax[FFits]{1, 1, 1, 1, 1, 1, 1, 1, 1, 1};              
 
#if !defined(GPUCA_GPUCODE)
  void construct();
#endif
 
  ClassDefNV(CalibdEdxTrackTopologyPol, 1);
};
 
} // namespace o2::tpc
 
#endif