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 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; }
 
      void setTemporaryDirectory(const std::string& temporary_directory) { m_temporary_directory = temporary_directory; }
 
      const boost::property_tree::ptree& getXMLTree() const { return m_pt; };
 
    private:
      boost::property_tree::ptree m_pt; 
      std::vector<std::string> m_filenames; 
      bool m_remove_temporary_directories = true; 
      std::string m_temporary_directory = "/tmp"; 
    };
 
  }
}
#endif