ParamBase.h

// 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.

///
/// \file   ParamBase.h
/// \author Nicolò Jacazio <nicolo.jacazio@cern.ch>
/// \since 07/08/2020
/// \brief Set of utilities to handle the parametrization of the PID response for each detector
///        These are the basic storage elements to be kept in the CCDB
///

#ifndef COMMON_CORE_PID_PARAMBASE_H_
#define COMMON_CORE_PID_PARAMBASE_H_

#include <algorithm> // std::copy
#include <map>       // std::map
#include <string>    // std::string
#include <vector>    // std::vector

// ROOT includes
#include "TNamed.h"
#include "TFile.h"

#include "Framework/Logger.h"

namespace o2::pid
{
/// Variable to use for the pid input/output i.e. float, double et cetera
using pidvar_t = float;

/// \brief Class to handle the parameters of a given detector response
class Parameters : public TNamed
{
 public:
  /// Default constructor
  Parameters() = default;

  /// Parametric constructor
  /// \param size Number of parameters in the container
  explicit Parameters(unsigned int size) : mPar(std::vector<pidvar_t>(size)) {}

  /// Parametric constructor
  /// \param size Number of parameters in the container
  Parameters(const TString name, unsigned int size) : TNamed(name, name), mPar(std::vector<pidvar_t>(size)) {}

  /// Parametric constructor
  /// \param params Parameters to initialize the container
  Parameters(const TString name, const std::vector<pidvar_t> params) : TNamed(name, name), mPar{} { SetParameters(params); }

  /// Default destructor
  ~Parameters() override = default;

  /// Setter for the parameter at position iparam
  /// \param iparam index in the array of the parameters
  /// \param value value of the parameter at position iparam
  void SetParameter(const unsigned int iparam, const pidvar_t value) { mPar[iparam] = value; }

  /// Setter for the parameter, using an array
  /// \param param array with parameters
  void SetParameters(const pidvar_t* params) { std::copy(params, params + mPar.size(), mPar.begin()); }

  /// Setter for the parameter, using a vector
  /// \param params vector with parameters
  void SetParameters(const std::vector<pidvar_t> params);

  /// Setter for the parameter, using a parameter object
  /// \param params parameter object with parameters
  void SetParameters(const Parameters params) { SetParameters(params.mPar); }

  /// Setter for the parameter, using a parameter pointer
  /// \param params pointer to parameter object with parameters
  void SetParameters(const Parameters* params) { SetParameters(params->mPar); }

  /// Printer of the parameter values
  void Print(Option_t* option = "") const override;

  /// Loader from file
  /// \param FileName name of the input file
  /// \param ParamName name of the input object
  void LoadParamFromFile(const TString FileName, const TString ParamName);

  /// Getter for the parameters
  /// \return returns an array of parameters
  const pidvar_t* GetParameters() const { return mPar.data(); }

  /// Getter for the size of the parameter
  /// \return returns the size of the parameter array
  unsigned int size() const { return mPar.size(); }

  /// Getter of the parameter at position i
  /// \param i index of the parameter to get
  /// \return returns the parameter value at position i
  pidvar_t operator[](const unsigned int i) const { return mPar[i]; }

 private:
  /// Vector of the parameter
  std::vector<pidvar_t> mPar;

  ClassDefOverride(Parameters, 1); // Container for parameter of parametrizations
};

/// \brief Class to handle the parameters of a given detector response
template <int nPar>
class PidParameters : public TNamed
{
 public:
  /// Default constructor
  explicit PidParameters(TString name = "DefaultParameters") : TNamed(name, name), mPar{} {};

  /// Default destructor
  ~PidParameters() override = default;

  /// Setter for the parameter at position iparam
  /// \param iparam index in the array of the parameters
  /// \param value value of the parameter at position iparam
  void SetParameter(const unsigned int iparam, const pidvar_t value) { mPar[iparam] = value; }

  /// Setter for the parameter, using an array
  /// \param param array with parameters
  void SetParameters(const pidvar_t* params) { std::copy(params, params + mPar.size(), mPar.begin()); }

  /// Setter for the parameter, using a vector
  /// \param params vector with parameters
  void SetParameters(const std::array<pidvar_t, nPar> params)
  {
    for (int i = 0; i < nPar; i++) {
      mPar[i] = params[i];
    }
  }

  /// Setter for the parameter, using a parameter object
  /// \param params parameter object with parameters
  void SetParameters(const PidParameters<nPar> params) { SetParameters(params.mPar); }

  /// Setter for the parameter, using a parameter pointer
  /// \param params pointer to parameter object with parameters
  void SetParameters(const PidParameters<nPar>* params) { SetParameters(params->mPar); }

  /// Printer of the parameter values
  void Print(Option_t* /*option = ""*/) const override
  {
    LOG(info) << "PidParameters '" << fName << "'";
    for (int i = 0; i < nPar; i++) {
      LOG(info) << "Parameter " << i << "/" << nPar - 1 << " is " << mPar[i];
    }
  }

  /// Adds the parameters to the metadata
  void AddToMetadata(std::map<std::string, std::string>& metadata) const
  {
    for (int i = 0; i < nPar; i++) {
      metadata[Form("p%i", i)] = Form("%f", mPar[i]);
    }
  }

  /// Loader from file
  /// \param FileName name of the input file
  /// \param ParamName name of the input object
  void LoadParamFromFile(const TString FileName, const TString ParamName)
  {
    TFile f(FileName, "READ");
    if (!f.Get(ParamName)) {
      LOG(fatal) << "Did not find parameters " << ParamName << " in file " << FileName;
    }
    LOG(info) << "Loading parameters " << ParamName << " from TFile " << FileName;
    PidParameters<nPar>* p;
    f.GetObject(ParamName, p);
    if (!p) {
      LOG(fatal) << "Could not get parameters " << ParamName << " from file";
      f.ls();
    }
    f.Close();
    SetParameters(p);
    Print();
  }

  /// Getter for the parameters
  /// \return returns an array of parameters
  const pidvar_t* GetParameters() const { return mPar.to_array(); }

  /// Getter for the parameters
  /// \return returns an array of parameters
  pidvar_t GetParameter(int i) const { return mPar[i]; }

  /// Getter for the size of the parameter
  /// \return returns the size of the parameter array
  static int size() { return nPar; }

  /// Getter of the parameter at position i
  /// \param i index of the parameter to get
  /// \return returns the parameter value at position i
  pidvar_t operator[](const unsigned int i) const { return mPar[i]; }

 private:
  /// Array of the parameter
  std::array<pidvar_t, nPar> mPar;

  ClassDefOverride(PidParameters, 1); // Container for parameter of parametrizations
};

class Parametrization : public TNamed
{
 public:
  /// Default constructor
  Parametrization() : TNamed("DefaultParametrization", "DefaultParametrization"), mParameters{0} {};

  /// Parametric constructor
  /// \param name Name (and title) of the parametrization
  /// \param size Number of parameters of the parametrization
  Parametrization(TString name, unsigned int size) : TNamed(name, name), mParameters(name + "Parameters", size) {}

  /// Parametric constructor
  /// \param name Name (and title) of the parametrization
  /// \param params Parameters of the parametrization
  Parametrization(TString name, const std::vector<pidvar_t> params) : TNamed(name, name), mParameters{name + "Parameters", params} {}

  /// Default destructor
  ~Parametrization() override = default;

  /// Getter for parametrization values, to be reimplemented in the custom parametrization of the user
  /// \param x array of variables to use in order to compute the return value
  virtual pidvar_t operator()(const pidvar_t* x) const;

  /// Printer for the parametrization
  void Print(Option_t* option = "") const override;

  /// Loader from file
  /// \param FileName name of the input file
  /// \param ParamName name of the input object
  void LoadParamFromFile(const TString FileName, const TString ParamName);

  /// Setter for the parameter at position iparam
  /// \param iparam index in the array of the parameters
  /// \param value value of the parameter at position iparam
  void SetParameter(const unsigned int iparam, const pidvar_t value) { mParameters.SetParameter(iparam, value); }

  /// Setter for the parameter, using a vector, a parameter object or a pointer to a parameter object
  /// \param params vector, parameter object, pointer to parameter object with parameters
  template <typename T>
  void SetParameters(const T params)
  {
    mParameters.SetParameters(params);
  }

  /// Getter for the parameters
  Parameters GetParameters() const { return mParameters; }

  /// Getter for the parameters
  void GetParameters(Parameters*& parameters) { parameters = &mParameters; }

 protected:
  /// Parameters of the parametrization
  Parameters mParameters;

  ClassDefOverride(Parametrization, 1); // Container for the parametrization of the response function
};

} // namespace o2::pid

#endif // COMMON_CORE_PID_PARAMBASE_H_