Spline1DHelper.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_GPUCOMMON_TPCFASTTRANSFORMATION_Spline1DHelper_H
#define ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_Spline1DHelper_H
 
#include "GPUCommonDef.h"
#include "GPUCommonRtypes.h"
#include "Spline1D.h"
 
#include <vector>
#include <string>
 
namespace o2
{
namespace gpu
{
template <typename DataT>
class Spline1DHelper
{
 public:
 
  Spline1DHelper();
 
  Spline1DHelper(const Spline1DHelper&) = default;
 
  Spline1DHelper& operator=(const Spline1DHelper&) = default;
 
  ~Spline1DHelper() = default;
 
 
  void approximateDataPoints(Spline1DContainer<DataT>& spline,
                             double xMin, double xMax,
                             const double vx[], const double vf[], int32_t nDataPoints);
 
  void approximateFunction(
    Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
    int32_t nAuxiliaryDataPoints = 4);
 
  void approximateDerivatives(Spline1DContainer<DataT>& spline,
                              const double vx[], const double vf[], int32_t nDataPoints);
 
  void approximateFunctionGradually(
    Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
    int32_t nAuxiliaryDataPoints);
 
  void approximateFunctionClassic(Spline1DContainer<DataT>& spline,
                                  double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F);
 
 
  const Spline1D<double>& getSpline() const { return mSpline; }
 
  static void getScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
                               double& cSl, double& cDl, double& cSr, double& cDr);
 
  static void getDScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
                                double& cSl, double& cDl, double& cSr, double& cDr);
 
  static void getDDScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
                                 double& cSl, double& cDl, double& cSr, double& cDr);
 
  static void getDDScoefficientsLeft(const typename Spline1D<double>::Knot& knotL,
                                     double& cSl, double& cDl, double& cSr, double& cDr);
 
  static void getDDScoefficientsRight(const typename Spline1D<double>::Knot& knotL,
                                      double& cSl, double& cDl, double& cSr, double& cDr);
  static void getDDDScoefficients(const typename Spline1D<double>::Knot& knotL,
                                  double& cSl, double& cDl, double& cSr, double& cDr);
 
  const char* getLastError() const { return mError.c_str(); }
 
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
  static int32_t test(const bool draw = 0, const bool drawDataPoints = 1);
#endif
 
 private:
  int32_t storeError(int32_t code, const char* msg);
 
  std::string mError = ""; 
 
  void setSpline(const Spline1DContainer<DataT>& spline);
 
  void makeDataPoints(Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
                      int32_t nAuxiliaryDataPoints, std::vector<double>& vx, std::vector<double>& vf);
 
 
  Spline1D<double> mSpline; 
 
  ClassDefNV(Spline1DHelper, 0);
};
 
} // namespace gpu
} // namespace o2
 
#endif