ParameterContainers.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 O2_TOF_PARAMCONTAINER_H
#define O2_TOF_PARAMCONTAINER_H
 
#include "TNamed.h"
#include "TFile.h"
#include "Framework/Logger.h"
#include "map"
 
namespace o2
{
namespace tof
{
using paramvar_t = float;
 
template <int nPar>
class Parameters
{
 public:
  Parameters(std::array<std::string, nPar> parNames, std::string name) : mName{name}, mPar{}, mParNames{parNames} {};
 
  virtual ~Parameters() = default; // Ensure proper cleanup in derived classes
 
  void setParameter(const unsigned int iparam, const paramvar_t value) { mPar[iparam] = value; }
 
  void setParameters(const paramvar_t* params) { std::copy(params, params + mPar.size(), mPar.begin()); }
 
  void setParameters(const std::array<paramvar_t, nPar> params)
  {
    for (int i = 0; i < nPar; i++) {
      mPar[i] = params[i];
    }
  }
 
  void setParameters(const Parameters<nPar> params) { setParameters(params.mPar); };
 
  void setParameters(const Parameters<nPar>* params) { setParameters(params->mPar); };
 
  void print() const
  {
    LOG(info) << "Parameters '" << mName << "'";
    for (int i = 0; i < nPar; i++) {
      LOG(info) << "Parameter " << i << "/" << nPar - 1 << " " << mParNames[i] << " is " << mPar[i];
    }
  }
 
  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]);
    }
  }
 
  void loadParamFromFile(const TString FileName, const TString ParamName)
  {
    TFile f(FileName, "READ");
    if (!f.IsOpen()) {
      LOG(fatal) << "Could not open file " << FileName;
    }
    if (!f.Get(ParamName)) {
      f.ls();
      LOG(fatal) << "Did not find parameters " << ParamName << " in file " << FileName;
    }
    LOG(info) << "Loading parameters " << ParamName << " from TFile " << FileName;
    Parameters<nPar>* p;
    f.GetObject(ParamName, p);
    if (!p) {
      LOG(fatal) << "Could not get parameters " << ParamName << " from file";
      f.ls();
    }
    f.Close();
    setParameters(p);
    print();
  }
 
  const paramvar_t* getParameters() const { return mPar.to_array(); }
 
  const paramvar_t getParameter(int i) const { return mPar[i]; }
 
  const std::string getParameterName(int i) const { return mParNames[i]; }
 
  const std::string getName() const { return mName; }
 
  static int size() { return nPar; }
 
  paramvar_t operator[](const unsigned int i) const { return mPar[i]; }
 
 private:
  std::array<paramvar_t, nPar> mPar;
  const std::array<std::string, nPar> mParNames;
  std::string mName;
};
 
class ParameterCollection : public TNamed
{
 public:
  ParameterCollection(TString name = "DefaultParameters") : TNamed(name, name), mParameters{} {};
 
  ~ParameterCollection() override = default;
 
  bool hasKey(const std::string& key) const { return (mParameters.find(key) != mParameters.end()); }
 
  template <typename ParType>
  bool retrieveParameters(ParType& p, const std::string& key) const
  {
    if (!hasKey(key)) { // Can't find the required key. Can't load parameters to the object
      return false;
    }
 
    const auto& toGet = mParameters.at(key);
    for (int i = 0; i < p.size(); i++) {
      const auto& name = p.getParameterName(i);
      if (toGet.find(name) == toGet.end()) {
        LOG(debug) << "Did not find parameter '" << name << "' in collection, keeping preexisting";
        continue;
      }
      LOG(debug) << "Found parameter '" << name << "' in collection, updating from " << p[i] << " to " << toGet.at(name);
      p.setParameter(i, toGet.at(name));
    }
    return true;
  }
 
  bool addParameter(const std::string& pass, const std::string& parName, float value)
  {
    const bool alreadyPresent = hasKey(pass);
    if (alreadyPresent) {
      LOG(debug) << "Changing parametrization corresponding to key " << pass << " from size " << mParameters[pass].size() << " to " << parName;
    } else {
      mParameters[pass] = std::unordered_map<std::string, paramvar_t>{};
      LOG(debug) << "Adding new parametrization corresponding to key " << pass << ": " << parName;
    }
    mParameters[pass][parName] = value;
    return true;
  }
 
  int getSize(const std::string& pass) const
  {
    if (!hasKey(pass)) {
      return -1;
    }
    return mParameters.at(pass).size();
  }
 
  template <typename ParType>
  bool storeParameters(const ParType& p, const std::string& key)
  {
    const bool alreadyPresent = hasKey(key);
    if (alreadyPresent) {
      LOG(debug) << "Changing parametrization corresponding to key " << key << " from size " << mParameters[key].size() << " to " << p.getName() << " of size " << p.size();
    } else {
      mParameters[key] = std::unordered_map<std::string, paramvar_t>{};
      LOG(debug) << "Adding new parametrization corresponding to key " << key << ": " << p.getName() << " of size " << p.size();
    }
    for (int i = 0; i < p.size(); i++) {
      mParameters[key][p.getParameterName(i)] = p[i];
    }
    return alreadyPresent;
  }
 
  const auto& getPars(const std::string& pass) const { return mParameters.at(pass); }
 
  void print(const std::string& pass) const
  {
    const auto& size = getSize(pass);
    if (size < 0) {
      LOG(info) << "empty pass: " << pass;
      return;
    }
    LOG(info) << "Pass \"" << pass << "\" with size " << size;
    for (const auto& [par, value] : mParameters.at(pass)) {
      LOG(info) << "par name = " << par << ", value = " << value;
    }
  }
 
  void print() const
  {
    for (const auto& [pass, pars] : mParameters) {
      print(pass);
    }
  }
 
  const auto& getFullMap() { return mParameters; }
 
  void loadParamFromFile(const TString FileName, const TString ParamName)
  {
    TFile f(FileName, "READ");
    if (!f.IsOpen()) {
      LOG(fatal) << "Could not open file " << FileName;
    }
    if (!f.Get(ParamName)) {
      f.ls();
      LOG(fatal) << "Did not find parameters " << ParamName << " in file " << FileName;
    }
    LOG(info) << "Loading parameters " << ParamName << " from TFile " << FileName;
    ParameterCollection* p;
    f.GetObject(ParamName, p);
    if (!p) {
      LOG(fatal) << "Could not get parameters " << ParamName << " from file";
      f.ls();
    }
    f.Close();
 
    for (const auto& pass : p->mParameters) {
      for (const auto& par : pass.second) {
        addParameter(pass.first, par.first, par.second);
      }
    }
    print();
  }
 
 private:
  std::unordered_map<std::string, std::unordered_map<std::string, paramvar_t>> mParameters;
 
  ClassDefOverride(ParameterCollection, 1); // Container for containers of parameter of parametrizations. To be used as a manager, in help of CCDB
};
 
} // namespace tof
} // namespace o2
 
#endif // O2_TOF_PARAMCONTAINER_H