MultivariatePolynomial.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_MULTIVARIATEPOLYNOMIAL
#define ALICEO2_TPC_MULTIVARIATEPOLYNOMIAL
 
#include "GPUCommonDef.h"
#include "GPUCommonLogger.h"
#include "FlatObject.h"
#include "MultivariatePolynomialHelper.h"
 
#if !defined(GPUCA_GPUCODE)
#include <algorithm>
#include <type_traits>
#if !defined(GPUCA_STANDALONE)
#include <TFile.h>
#endif
#endif
 
namespace o2::gpu
{
 
template <uint32_t Dim, uint32_t Degree, bool InteractionOnly = false>
class MultivariatePolynomial : public FlatObject, public MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>
{
 public:
#if !defined(GPUCA_GPUCODE)
  template <bool IsEnabled = true, typename std::enable_if<(IsEnabled && (Dim == 0 && Degree == 0)), int32_t>::type = 0>
  MultivariatePolynomial(const uint32_t nDim, const uint32_t degree, const bool interactionOnly = false) : MultivariatePolynomialHelper<Dim, Degree, false>{nDim, degree, interactionOnly}, mNParams{this->getNParameters(degree, nDim, interactionOnly)}
  {
    construct();
  }
 
  template <bool IsEnabled = true, typename std::enable_if<(IsEnabled && (Dim != 0 && Degree != 0)), int32_t>::type = 0>
  MultivariatePolynomial() : mNParams{this->template getNParameters<Degree, Dim, InteractionOnly>()}
  {
    construct();
  }
#else
  MultivariatePolynomial() = default;
#endif
 
  ~MultivariatePolynomial() = default;
 
  MultivariatePolynomial(const MultivariatePolynomial& obj) { this->cloneFromObject(obj, nullptr); }
 
#if !defined(GPUCA_GPUCODE)
  void cloneFromObject(const MultivariatePolynomial& obj, char* newFlatBufferPtr);
 
  void moveBufferTo(char* newBufferPtr);
#endif
 
  void destroy();
 
  void setActualBufferAddress(char* actualFlatBufferPtr);
 
  void setFutureBufferAddress(char* futureFlatBufferPtr);
 
  GPUd() float eval(const float x[/*Dim*/]) const { return this->evalPol(mParams, x); }
 
#if !defined(GPUCA_GPUCODE)
  uint32_t getNParams() const { return mNParams; }
 
  void setParams(const float params[/*mNParams*/]) { std::copy(params, params + mNParams, mParams); }
 
  void setParam(const uint32_t param, const float val) { mParams[param] = val; };
 
  const float* getParams() const { return mParams; }
 
#ifndef GPUCA_STANDALONE
  void loadFromFile(TFile& inpf, const char* name);
 
  void writeToFile(TFile& outf, const char* name) const;
 
  template <bool IsEnabled = true, typename std::enable_if<(IsEnabled && (Dim == 0 && Degree == 0)), int32_t>::type = 0>
  void fit(std::vector<double>& x, std::vector<double>& y, std::vector<double>& error, const bool clearPoints)
  {
    const auto vec = MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::fit(x, y, error, clearPoints);
    if (vec.empty()) {
      return;
    }
    setParams(vec.data());
  }
#endif
 
  MultivariatePolynomialContainer getContainer() const { return MultivariatePolynomialContainer{this->getDim(), this->getDegree(), mNParams, mParams, this->isInteractionOnly()}; }
 
  void setFromContainer(const MultivariatePolynomialContainer& container);
#endif
 
 private:
  using DataTParams = float;     
  uint32_t mNParams{};           
  DataTParams* mParams{nullptr}; 
 
#if !defined(GPUCA_GPUCODE)
  std::size_t sizeOfParameters() const { return mNParams * sizeof(DataTParams); }
 
  // construct the object (flatbuffer)
  void construct();
#endif
 
  ClassDefNV(MultivariatePolynomial, 1);
};
 
//=================================================================================
//============================ inline implementations =============================
//=================================================================================
 
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
void MultivariatePolynomial<Dim, Degree, InteractionOnly>::loadFromFile(TFile& inpf, const char* name)
{
  MultivariatePolynomialContainer* polTmp = nullptr;
  inpf.GetObject(name, polTmp);
  if (polTmp) {
    setFromContainer(*polTmp);
    delete polTmp;
  } else {
    LOGP(info, "couldnt load object {} from input file", name);
  }
}
 
template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
void MultivariatePolynomial<Dim, Degree, InteractionOnly>::setFromContainer(const MultivariatePolynomialContainer& container)
{
  if constexpr (Dim > 0 && Degree > 0) {
    if (this->getDim() != container.mDim) {
      LOGP(info, "wrong number of dimensions! this {} container {}", this->getDim(), container.mDim);
      return;
    }
    if (this->getDegree() != container.mDegree) {
      LOGP(info, "wrong number of degrees! this {} container {}", this->getDegree(), container.mDegree);
      return;
    }
    if (this->isInteractionOnly() != container.mInteractionOnly) {
      LOGP(info, "InteractionOnly is set for this object to {}, but stored as {} in the container", this->isInteractionOnly(), container.mInteractionOnly);
      return;
    }
    setParams(container.mParams.data());
  } else {
    MultivariatePolynomial polTmp(container.mDim, container.mDegree);
    polTmp.setParams(container.mParams.data());
    this->cloneFromObject(polTmp, nullptr);
  }
}
 
template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
void MultivariatePolynomial<Dim, Degree, InteractionOnly>::writeToFile(TFile& outf, const char* name) const
{
  const MultivariatePolynomialContainer cont = getContainer();
  outf.WriteObject(&cont, name);
}
#endif
 
#ifndef GPUCA_GPUCODE
template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
void MultivariatePolynomial<Dim, Degree, InteractionOnly>::cloneFromObject(const MultivariatePolynomial<Dim, Degree, InteractionOnly>& obj, char* newFlatBufferPtr)
{
  const char* oldFlatBufferPtr = obj.mFlatBufferPtr;
  FlatObject::cloneFromObject(obj, newFlatBufferPtr);
  mNParams = obj.mNParams;
  if constexpr (Dim == 0 && Degree == 0) {
    this->mDim = obj.mDim;
    this->mDegree = obj.mDegree;
    this->mInteractionOnly = obj.mInteractionOnly;
  }
  if (obj.mParams) {
    mParams = FlatObject::relocatePointer(oldFlatBufferPtr, mFlatBufferPtr, obj.mParams);
  }
}
 
template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
void MultivariatePolynomial<Dim, Degree, InteractionOnly>::moveBufferTo(char* newFlatBufferPtr)
{
  char* oldFlatBufferPtr = mFlatBufferPtr;
  FlatObject::moveBufferTo(newFlatBufferPtr);
  char* currFlatBufferPtr = mFlatBufferPtr;
  mFlatBufferPtr = oldFlatBufferPtr;
  setActualBufferAddress(currFlatBufferPtr);
}
 
template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
void MultivariatePolynomial<Dim, Degree, InteractionOnly>::construct()
{
  FlatObject::startConstruction();
  const std::size_t flatbufferSize = sizeOfParameters();
  FlatObject::finishConstruction(flatbufferSize);
  mParams = reinterpret_cast<float*>(mFlatBufferPtr);
}
#endif
 
template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
void MultivariatePolynomial<Dim, Degree, InteractionOnly>::destroy()
{
  mParams = nullptr;
  FlatObject::destroy();
}
 
template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
void MultivariatePolynomial<Dim, Degree, InteractionOnly>::setActualBufferAddress(char* actualFlatBufferPtr)
{
  FlatObject::setActualBufferAddress(actualFlatBufferPtr);
  mParams = reinterpret_cast<float*>(mFlatBufferPtr);
}
 
template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
void MultivariatePolynomial<Dim, Degree, InteractionOnly>::setFutureBufferAddress(char* futureFlatBufferPtr)
{
  mParams = FlatObject::relocatePointer(mFlatBufferPtr, futureFlatBufferPtr, mParams);
  FlatObject::setFutureBufferAddress(futureFlatBufferPtr);
}
 
} // namespace o2::gpu
 
#endif