CalibdEdxTrackTopologySpline.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 CalibdEdxTrackTopologySpline_H
#define CalibdEdxTrackTopologySpline_H
 
#include "GPUCommonDef.h"
 
#include "FlatObject.h"
#include "Spline.h"
#include "GPUCommonRtypes.h"
#include "DataFormatsTPC/Defs.h"
 
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
#include <fmt/format.h>
#endif
 
namespace o2::tpc
{
 
 
class CalibdEdxTrackTopologySpline : public o2::gpu::FlatObject
{
 public:
  typedef o2::gpu::Spline<float, 3, 1> SplineType;
 
 
#if !defined(GPUCA_GPUCODE)
  CalibdEdxTrackTopologySpline() = default;
 
  CalibdEdxTrackTopologySpline(const char* dEdxSplinesFile, const char* name = "CalibdEdxTrackTopologySpline");
 
  CalibdEdxTrackTopologySpline(const CalibdEdxTrackTopologySpline&);
 
  CalibdEdxTrackTopologySpline& operator=(const CalibdEdxTrackTopologySpline&);
 
  void recreate(const int32_t nKnots[]);
#else
 
  CalibdEdxTrackTopologySpline() = delete;
  CalibdEdxTrackTopologySpline(const CalibdEdxTrackTopologySpline&) = delete;
  CalibdEdxTrackTopologySpline& operator=(const CalibdEdxTrackTopologySpline&) = delete;
#endif
 
  ~CalibdEdxTrackTopologySpline() = default;
 
 
  using FlatObject::getBufferAlignmentBytes;
  using FlatObject::getClassAlignmentBytes;
 
#if !defined(GPUCA_GPUCODE)
  void cloneFromObject(const CalibdEdxTrackTopologySpline& obj, char* newFlatBufferPtr);
  void moveBufferTo(char* newBufferPtr);
#endif
 
  using FlatObject::releaseInternalBuffer;
 
  void destroy();
  void setActualBufferAddress(char* actualFlatBufferPtr);
  void setFutureBufferAddress(char* futureFlatBufferPtr);
 
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
  void setSplinesFromFile(TFile& inpf);
 
  void setRangesFromFile(TFile& inpf);
 
  void setDefaultSplines();
 
  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 setMaxTanTheta(const float maxTanTheta) { mMaxTanTheta = maxTanTheta; };
 
  void setMaxSinPhi(const float maxSinPhi) { mMaxSinPhi = maxSinPhi; };
#endif
 
  GPUd() uint32_t getFSplines() const { return FSplines; };
 
  GPUd() float getMaxTanTheta() const { return mMaxTanTheta; };
 
  GPUd() float getMaxSinPhi() const { return mMaxSinPhi; };
 
  GPUd() float getScalingFactorqTot(const int32_t region) const { return mScalingFactorsqTot[region]; };
 
  GPUd() float getScalingFactorqMax(const int32_t region) const { return mScalingFactorsqMax[region]; };
 
  GPUd() float interpolateqMax(const int32_t region, const float tanTheta, const float sinPhi, const float z) const
  {
    const float x[FDimX] = {z, tanTheta, sinPhi};
    return mScalingFactorsqMax[region] * mCalibSplinesqMax[region].interpolate(x);
  };
 
  GPUd() float interpolateqTot(const int32_t region, const float tanTheta, const float sinPhi, const float z) const
  {
    const float x[FDimX] = {z, tanTheta, sinPhi};
    return mScalingFactorsqTot[region] * mCalibSplinesqTot[region].interpolate(x);
  };
 
  GPUd() float getCorrection(const int32_t region, const ChargeType charge, const float tanTheta, const float sinPhi, const float z) const { return (charge == ChargeType::Max) ? interpolateqMax(region, tanTheta, sinPhi, z) : interpolateqTot(region, tanTheta, sinPhi, z); }
 
  GPUd() float getCorrection(const int32_t region, const ChargeType charge, const float x[/*inpXdim*/]) const { return (charge == ChargeType::Tot) ? mCalibSplinesqTot[region].interpolate(x) : mCalibSplinesqMax[region].interpolate(x); }
 
  GPUd() SplineType& getSplineqMax(const int32_t region) { return mCalibSplinesqMax[region]; };
 
  GPUd() SplineType& getSplineqTot(const int32_t region) { return mCalibSplinesqTot[region]; };
 
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
  int32_t writeToFile(TFile& outf, const char* name = "CalibdEdxTrackTopologySpline");
 
  void setFromFile(TFile& inpf, const char* name);
 
  static CalibdEdxTrackTopologySpline* readFromFile(TFile& inpf, const char* name);
 
  static std::string getSplineName(const int32_t region, const ChargeType charge);
#endif
 
 private:
  GPUglobalconstexpr() static uint32_t FSplines = 10;                
  GPUglobalconstexpr() static int32_t FDimX = 3;                     
  SplineType mCalibSplinesqMax[FSplines];                            
  SplineType mCalibSplinesqTot[FSplines];                            
  float mMaxTanTheta{2.f};                                           
  float mMaxSinPhi{0.99f};                                           
  float mScalingFactorsqTot[FSplines]{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 
  float mScalingFactorsqMax[FSplines]{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 
 
  ClassDefNV(CalibdEdxTrackTopologySpline, 1);
};
 
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 
inline void CalibdEdxTrackTopologySpline::setSplinesFromFile(TFile& inpf)
{
  FlatObject::startConstruction();
 
  int32_t buffSize = 0;
  int32_t offsets1[FSplines];
  int32_t offsets2[FSplines];
 
  for (uint32_t ireg = 0; ireg < FSplines; ++ireg) {
    std::string splinename = getSplineName(ireg, ChargeType::Max);
    SplineType* splineTmpqMax = SplineType::readFromFile(inpf, splinename.data());
    mCalibSplinesqMax[ireg] = *splineTmpqMax;
    buffSize = alignSize(buffSize, mCalibSplinesqMax[ireg].getBufferAlignmentBytes());
    offsets1[ireg] = buffSize;
    buffSize += mCalibSplinesqMax[ireg].getFlatBufferSize();
    delete splineTmpqMax;
  }
 
  for (uint32_t ireg = 0; ireg < FSplines; ++ireg) {
    std::string splinename = getSplineName(ireg, ChargeType::Tot);
    SplineType* splineTmpqTot = SplineType::readFromFile(inpf, splinename.data());
    mCalibSplinesqTot[ireg] = *splineTmpqTot;
    buffSize = alignSize(buffSize, mCalibSplinesqTot[ireg].getBufferAlignmentBytes());
    offsets2[ireg] = buffSize;
    buffSize += mCalibSplinesqTot[ireg].getFlatBufferSize();
    delete splineTmpqTot;
  }
 
  FlatObject::finishConstruction(buffSize);
 
  for (uint32_t i = 0; i < FSplines; i++) {
    mCalibSplinesqMax[i].moveBufferTo(mFlatBufferPtr + offsets1[i]);
  }
  for (uint32_t i = 0; i < FSplines; i++) {
    mCalibSplinesqTot[i].moveBufferTo(mFlatBufferPtr + offsets2[i]);
  }
}
 
#endif
 
} // namespace o2::tpc
 
#endif