Spline1DHelperOld.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_Spline1DHelperOld_H
#define ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_Spline1DHelperOld_H
 
#include <cmath>
#include <vector>
 
#include "GPUCommonDef.h"
#include "GPUCommonRtypes.h"
#include "Spline1D.h"
#include <functional>
#include <string>
 
namespace o2
{
namespace gpu
{
template <typename DataT>
class Spline1DHelperOld
{
 public:
  struct DataPoint {
    double u;    
    double cS0;  
    double cZ0;  
    double cS1;  
    double cZ1;  
    int32_t iKnot; 
    bool isKnot; 
  };
 
 
  Spline1DHelperOld();
 
  Spline1DHelperOld(const Spline1DHelperOld&) = default;
 
  Spline1DHelperOld& operator=(const Spline1DHelperOld&) = default;
 
  ~Spline1DHelperOld() = default;
 
 
  void bandGauss(double A[], double b[], int32_t n);
 
  void approximateDataPoints(Spline1DContainer<DataT>& spline,
                             double xMin, double xMax,
                             double x[], double f[], 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 approximateFunctionGradually(Spline1DContainer<DataT>& spline,
                                    double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
                                    int32_t nAuxiliaryDataPoints = 4);
 
  void approximateFunctionClassic(Spline1DContainer<DataT>& spline,
                                  double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F);
 
 
  int32_t setSpline(const Spline1DContainer<DataT>& spline, int32_t nFdimensions, int32_t nAuxiliaryDataPoints);
 
  int32_t setSpline(const Spline1DContainer<DataT>& spline, int32_t nFdimensions, double xMin, double xMax, double vx[], int32_t nDataPoints);
 
  void approximateFunction(DataT* Fparameters, double xMin, double xMax, std::function<void(double x, double f[])> F) const;
 
  void approximateFunctionGradually(DataT* Fparameters, double xMin, double xMax, std::function<void(double x, double f[])> F) const;
 
  int32_t getNumberOfDataPoints() const { return mDataPoints.size(); }
 
  void approximateFunction(DataT* Fparameters, const double DataPointF[/*getNumberOfDataPoints() x nFdim*/]) const;
 
  void approximateFunctionGradually(DataT* Fparameters, const double DataPointF[/*getNumberOfDataPoints() x nFdim */]) const;
 
  void copySfromDataPoints(DataT* Fparameters, const double DataPointF[/*getNumberOfDataPoints() x nFdim*/]) const;
 
  void approximateDerivatives(DataT* Fparameters, const double DataPointF[/*getNumberOfDataPoints() x nFdim*/]) const;
 
 
  const Spline1D<double>& getSpline() const { return mSpline; }
 
  int32_t getKnotDataPoint(int32_t iknot) const { return mKnotDataPoints[iknot]; }
 
  const DataPoint& getDataPoint(int32_t ip) const { return mDataPoints[ip]; }
 
  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 = ""; 
 
 
  Spline1D<double> mSpline;           
  int32_t mFdimensions;               
  std::vector<DataPoint> mDataPoints; 
  std::vector<int32_t> mKnotDataPoints; 
  std::vector<double> mLSMmatrixFull; 
  std::vector<double> mLSMmatrixSderivatives;
  std::vector<double> mLSMmatrixSvalues;
 
  ClassDefNV(Spline1DHelperOld, 0);
};
 
} // namespace gpu
} // namespace o2
 
#endif