Weightfile.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
#ifndef INCLUDE_GUARD_BELLE2_MVA_WEIGHTFILE_HEADER
#define INCLUDE_GUARD_BELLE2_MVA_WEIGHTFILE_HEADER
 
#include <mva/interface/Options.h>
 
#include <framework/database/IntervalOfValidity.h>
#include <framework/dataobjects/EventMetaData.h>
 
#include <boost/property_tree/ptree.hpp>
 
#include <vector>
#include <string>
#include <fstream>
 
namespace Belle2 {
 
  namespace MVA {
 
    std::string makeSaveForDatabase(std::string str);

    class Weightfile {
 
    public:
      Weightfile() {};

      ~Weightfile();

      void addFeatureImportance(const std::map<std::string, float>& importance);

      std::map<std::string, float> getFeatureImportance() const;

      void addOptions(const Options& options);

      void getOptions(Options& options) const;

      void addSignalFraction(float signal_fraction);

      float getSignalFraction() const;

      std::string generateFileName(const std::string& suffix = "");

      void addFile(const std::string& identifier, const std::string& custom_weightfile);

      void addStream(const std::string& identifier, std::istream& in);

      template<class T>
      void addElement(const std::string& identifier, const T& element)
      {
        m_pt.put(identifier, element);
      }

      template<class T>
      void addVector(const std::string& identifier, const std::vector<T>& vector)
      {
        m_pt.put(identifier + "_size", vector.size());
        for (unsigned int i = 0; i < vector.size(); ++i) {
          m_pt.put(identifier + std::to_string(i), vector[i]);
        }
      }

      void addContractVersion(int version)
      {
        addElement(c_contractVersion, version);
      }

      bool hasContractVersion() const
      {
        return containsElement(c_contractVersion);
      }

      int getContractVersion(int default_value = -1) const
      {
        auto version = m_pt.get_optional<int>(c_contractVersion);
        return version ? *version : default_value;
      }

      void getFile(const std::string& identifier, const std::string& custom_weightfile);

      std::string getStream(const std::string& identifier) const;

      template<class T>
      T getElement(const std::string& identifier) const
      {
        return m_pt.get<T>(identifier);
      }

      bool containsElement(const std::string& identifier) const
      {
        return m_pt.count(identifier) > 0;
      }

      template<class T>
      T getElement(const std::string& identifier, const T& default_value) const
      {
        return m_pt.get<T>(identifier, default_value);
      }

      template<class T>
      std::vector<T> getVector(const std::string& identifier) const
      {
        std::vector<T> vector;
        vector.resize(m_pt.get<size_t>(identifier + "_size"));
        for (unsigned int i = 0; i < vector.size(); ++i) {
          vector[i] = m_pt.get<T>(identifier + std::to_string(i));
        }
        return vector;
      }

      static void save(Weightfile& weightfile, const std::string& filename,
                       const Belle2::IntervalOfValidity& iov = Belle2::IntervalOfValidity(0, 0, -1, -1));

      static void saveToROOTFile(Weightfile& weightfile, const std::string& filename);

      static void saveToXMLFile(Weightfile& weightfile, const std::string& filename);

      static void saveToStream(Weightfile& weightfile, std::ostream& stream);

      static Weightfile load(const std::string& filename, const Belle2::EventMetaData& emd = Belle2::EventMetaData(0, 0, 0));

      static Weightfile loadFromFile(const std::string& filename);

      static Weightfile loadFromROOTFile(const std::string& filename);

      static Weightfile loadFromXMLFile(const std::string& filename);

      static Weightfile loadFromStream(std::istream& stream);

      static void saveToDatabase(Weightfile& weightfile, const std::string& identifier,
                                 const Belle2::IntervalOfValidity& iov = Belle2::IntervalOfValidity(0, 0, -1, -1));

      static void saveArrayToDatabase(const std::vector<Weightfile>& weightfiles, const std::string& identifier,
                                      const Belle2::IntervalOfValidity& iov = Belle2::IntervalOfValidity(0, 0, -1, -1));

      static Weightfile loadFromDatabase(const std::string& identifier, const Belle2::EventMetaData& emd = Belle2::EventMetaData(0, 0,
                                         0));

      void setRemoveTemporaryDirectories(bool remove_temporary_directories) { m_remove_temporary_directories = remove_temporary_directories; }

      const boost::property_tree::ptree& getXMLTree() const { return m_pt; };
 
    private:
      static constexpr const char* c_contractVersion = "contract_version";
 
      boost::property_tree::ptree m_pt; 
      std::vector<std::string> m_filenames; 
      bool m_remove_temporary_directories = true; 
    };
 
  }
}
#endif