Belle II Software  release-08-01-10
test_Weightfile.cc
1 /**************************************************************************
2  * basf2 (Belle II Analysis Software Framework) *
3  * Author: The Belle II Collaboration *
4  * *
5  * See git log for contributors and copyright holders. *
6  * This file is licensed under LGPL-3.0, see LICENSE.md. *
7  **************************************************************************/
8 
9 #include <mva/interface/Weightfile.h>
10 #include <mva/interface/Options.h>
11 #include <framework/utilities/TestHelpers.h>
12 
13 #include <framework/database/Configuration.h>
14 #include <framework/database/Database.h>
15 
16 #include <TFile.h>
17 
18 #include <filesystem>
19 #include <fstream>
20 
21 #include <gtest/gtest.h>
22 
23 using namespace Belle2;
24 
25 namespace {
26 
27  class TestOptions : public MVA::Options {
28 
29  public:
30  TestOptions(const std::string& _x, const std::string& _y) : x(_x), y(_y) { }
31  void load(const boost::property_tree::ptree& pt) override { y = pt.get<std::string>(x); }
32  void save(boost::property_tree::ptree& pt) const override { pt.put(x, y); }
33  po::options_description getDescription() override
34  {
35  po::options_description description("General options");
36  description.add_options()
37  ("help", "print this message");
38  return description;
39  }
40 
41  std::string x;
42  std::string y;
43  };
44 
45  TEST(WeightfileTest, Options)
46  {
47  TestOptions options1("Test1", "a");
48  TestOptions options2("Test2", "b");
49  MVA::Weightfile weightfile;
50  weightfile.addOptions(options1);
51  weightfile.addOptions(options2);
52 
53  EXPECT_EQ(weightfile.getElement<std::string>("Test1"), "a");
54  EXPECT_EQ(weightfile.getElement<std::string>("Test2"), "b");
55 
56  TestOptions options3("Test2", "c");
57  weightfile.getOptions(options3);
58  EXPECT_EQ(options3.y, "b");
59  }
60 
61  TEST(WeightfileTest, FeatureImportance)
62  {
63  std::map<std::string, float> importance;
64  importance["a"] = 1.0;
65  importance["b"] = 2.0;
66  importance["c"] = 3.0;
67  MVA::Weightfile weightfile;
68  weightfile.addFeatureImportance(importance);
69 
70  EXPECT_EQ(weightfile.getElement<unsigned int>("number_of_importance_vars"), 3);
71  EXPECT_EQ(weightfile.getElement<std::string>("importance_key0"), "a");
72  EXPECT_EQ(weightfile.getElement<float>("importance_value0"), 1.0);
73 
74  auto importance2 = weightfile.getFeatureImportance();
75 
76  EXPECT_EQ(importance2.size(), 3);
77  EXPECT_EQ(importance2["a"], 1.0);
78  EXPECT_EQ(importance2["b"], 2.0);
79  EXPECT_EQ(importance2["c"], 3.0);
80 
81  }
82 
83  TEST(WeightfileTest, SignalFraction)
84  {
85 
86  MVA::Weightfile weightfile;
87  weightfile.addSignalFraction(0.7);
88  EXPECT_FLOAT_EQ(weightfile.getSignalFraction(), 0.7);
89 
90  }
91 
92  TEST(WeightfileTest, Element)
93  {
94 
95  MVA::Weightfile weightfile;
96  weightfile.addElement("Test", 1);
97  EXPECT_EQ(weightfile.getElement<int>("Test"), 1);
98 
99  }
100 
101  TEST(WeightfileTest, Stream)
102  {
103 
104  MVA::Weightfile weightfile;
105  std::stringstream sstream("MyStream");
106  weightfile.addStream("Test", sstream);
107  EXPECT_EQ(weightfile.getStream("Test"), "MyStream");
108 
109  }
110 
111  TEST(WeightfileTest, File)
112  {
113 
114  TestHelpers::TempDirCreator tmp_dir;
115  std::ofstream ofile("file.txt");
116  ofile << "MyFile";
117  ofile.close();
118 
119  MVA::Weightfile weightfile;
120  weightfile.addFile("Test", "file.txt");
121 
122  weightfile.getFile("Test", "file2.txt");
123  std::string content;
124  std::ifstream ifile("file2.txt");
125  ifile >> content;
126  ifile.close();
127 
128  EXPECT_EQ(content, "MyFile");
129 
130  }
131 
132  TEST(WeightfileTest, StaticSaveLoadDatabase)
133  {
134 
135  TestHelpers::TempDirCreator tmp_dir;
136 
137  auto& conf = Conditions::Configuration::getInstance();
138  conf.overrideGlobalTags();
139  conf.prependTestingPayloadLocation("localdb/database.txt");
140 
141  MVA::Weightfile weightfile;
142  weightfile.addElement("Test", "a");
143 
144  MVA::Weightfile::save(weightfile, "MVAInterfaceTest");
145  auto loaded = MVA::Weightfile::loadFromDatabase("MVAInterfaceTest");
146  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
147 
148  EXPECT_THROW(MVA::Weightfile::loadFromFile("MVAInterfaceTest"), std::runtime_error);
149 
150  loaded = MVA::Weightfile::load("MVAInterfaceTest");
151  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
152 
153  EXPECT_THROW(MVA::Weightfile::loadFromDatabase("DOES_NOT_EXIST"), std::runtime_error);
154 
155  std::filesystem::remove_all("testPayloads");
156  Database::reset();
157 
158  }
159 
160  TEST(WeightfileTest, StaticSaveLoadXML)
161  {
162 
163  TestHelpers::TempDirCreator tmp_dir;
164 
165  MVA::Weightfile weightfile;
166  weightfile.addElement("Test", "a");
167 
168  MVA::Weightfile::save(weightfile, "MVAInterfaceTest.xml");
169  auto loaded = MVA::Weightfile::loadFromXMLFile("MVAInterfaceTest.xml");
170  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
171 
172  loaded = MVA::Weightfile::loadFromFile("MVAInterfaceTest.xml");
173  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
174 
175  loaded = MVA::Weightfile::load("MVAInterfaceTest.xml");
176  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
177 
178  EXPECT_THROW(MVA::Weightfile::loadFromXMLFile("DOES_NOT_EXIST.xml"), std::runtime_error);
179 
180  }
181 
182  TEST(WeightfileTest, StaticSaveLoadROOT)
183  {
184 
185  TestHelpers::TempDirCreator tmp_dir;
186 
187  MVA::Weightfile weightfile;
188  weightfile.addElement("Test", "a");
189 
190  MVA::Weightfile::save(weightfile, "MVAInterfaceTest.root");
191  auto loaded = MVA::Weightfile::loadFromROOTFile("MVAInterfaceTest.root");
192  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
193 
194  loaded = MVA::Weightfile::loadFromFile("MVAInterfaceTest.root");
195  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
196 
197  loaded = MVA::Weightfile::load("MVAInterfaceTest.root");
198  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
199 
200  EXPECT_THROW(MVA::Weightfile::loadFromROOTFile("DOES_NOT_EXIST.root"), std::runtime_error);
201 
202  {
203  std::fstream file("INVALID.root");
204  }
205  EXPECT_THROW(MVA::Weightfile::loadFromROOTFile("INVALID.root"), std::runtime_error);
206 
207  }
208 
209  TEST(WeightfileTest, StaticDatabase)
210  {
211 
212  TestHelpers::TempDirCreator tmp_dir;
213  auto& conf = Conditions::Configuration::getInstance();
214  conf.overrideGlobalTags();
215  conf.prependTestingPayloadLocation("localdb/database.txt");
216 
217  MVA::Weightfile weightfile;
218  weightfile.addElement("Test", "a");
219 
220  MVA::Weightfile::saveToDatabase(weightfile, "MVAInterfaceTest");
221 
222  auto loaded = MVA::Weightfile::loadFromDatabase("MVAInterfaceTest");
223 
224  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
225 
226  std::filesystem::remove_all("testPayloads");
227  Database::reset();
228 
229  }
230 
231  TEST(WeightfileTest, StaticDatabaseBadSymbols)
232  {
233 
234  TestHelpers::TempDirCreator tmp_dir;
235  auto& conf = Conditions::Configuration::getInstance();
236  conf.overrideGlobalTags();
237  conf.prependTestingPayloadLocation("localdb/database.txt");
238 
239  MVA::Weightfile weightfile;
240  weightfile.addElement("Test", "a");
241 
242  std::string evilIdentifier = "==> *+:";
243  MVA::Weightfile::saveToDatabase(weightfile, evilIdentifier);
244 
245  auto loaded = MVA::Weightfile::loadFromDatabase(evilIdentifier);
246 
247  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
248 
249  std::filesystem::remove_all("testPayloads");
250  Database::reset();
251 
252  }
253 
254  TEST(WeightfileTest, StaticXMLFile)
255  {
256 
257  TestHelpers::TempDirCreator tmp_dir;
258  MVA::Weightfile weightfile;
259  weightfile.addElement("Test", "a");
260 
261  MVA::Weightfile::saveToXMLFile(weightfile, "MVAInterfaceTest.xml");
262 
263  auto loaded = MVA::Weightfile::loadFromXMLFile("MVAInterfaceTest.xml");
264 
265  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
266 
267  }
268 
269  TEST(WeightfileTest, StaticROOTFile)
270  {
271 
272  TestHelpers::TempDirCreator tmp_dir;
273  MVA::Weightfile weightfile;
274  weightfile.addElement("Test", "a");
275 
276  MVA::Weightfile::saveToROOTFile(weightfile, "MVAInterfaceTest.root");
277 
278  auto loaded = MVA::Weightfile::loadFromROOTFile("MVAInterfaceTest.root");
279 
280  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
281 
282  TFile file("invalid_weightfile.root", "RECREATE");
283  file.Close();
284  EXPECT_THROW(MVA::Weightfile::loadFromROOTFile("invalid_weightfile.root"), std::runtime_error);
285 
286  }
287 
288  TEST(WeightfileTest, StaticStream)
289  {
290 
291  TestHelpers::TempDirCreator tmp_dir;
292  MVA::Weightfile weightfile;
293  weightfile.addElement("Test", "a");
294 
295  std::ofstream ofile("file.txt");
296  MVA::Weightfile::saveToStream(weightfile, ofile);
297  ofile.close();
298 
299  std::ifstream ifile("file.txt");
300  auto loaded = MVA::Weightfile::loadFromStream(ifile);
301  EXPECT_EQ(loaded.getElement<std::string>("Test"), "a");
302 
303  }
304 
305  TEST(WeightfileTest, GetFileName)
306  {
307 
308  MVA::Weightfile weightfile;
309  std::string filename = weightfile.generateFileName(".xml");
310  unsigned int length = filename.size();
311  EXPECT_TRUE(filename.substr(length - 4, length) == ".xml");
312 
313  {
314  MVA::Weightfile weightfile2;
315  weightfile2.setRemoveTemporaryDirectories(true);
316  filename = weightfile2.generateFileName(".xml");
317  {
318  std::ofstream a(filename);
319  }
320  EXPECT_TRUE(std::filesystem::exists(filename));
321  }
322  EXPECT_FALSE(std::filesystem::exists(filename));
323 
324  {
325  MVA::Weightfile weightfile2;
326  weightfile2.setRemoveTemporaryDirectories(false);
327  filename = weightfile2.generateFileName(".xml");
328  {
329  std::ofstream a(filename);
330  }
331  EXPECT_TRUE(std::filesystem::exists(filename));
332  }
333  EXPECT_TRUE(std::filesystem::exists(filename));
334  std::filesystem::remove_all(std::filesystem::path(filename).parent_path());
335  EXPECT_FALSE(std::filesystem::exists(std::filesystem::path(filename).parent_path()));
336 
337  char* directory_template = strdup((std::filesystem::temp_directory_path() / "Basf2Sub.XXXXXX").c_str());
338  auto tempdir = std::string(mkdtemp(directory_template));
339  setenv("TMPDIR", tempdir.c_str(), 1);
340  {
341  MVA::Weightfile weightfile2;
342  filename = weightfile2.generateFileName(".xml");
343  EXPECT_EQ(filename.substr(0, tempdir.size()), tempdir);
344  }
345  free(directory_template);
346  std::filesystem::remove_all(tempdir);
347  EXPECT_FALSE(std::filesystem::exists(tempdir));
348  setenv("TMPDIR", "/tmp", 1);
349  }
350 
351 }
Belle2::Conditions::Configuration::getInstance
static Configuration & getInstance()
Get a reference to the instance which will be used when the Database is initialized.
Belle2::MVA::Options
Abstract base class of all Options given to the MVA interface.
Definition: Options.h:34
Belle2::MVA::Weightfile
The Weightfile class serializes all information about a training into an xml tree.
Definition: Weightfile.h:38
Belle2::MVA::Weightfile::addStream
void addStream(const std::string &identifier, std::istream &in)
Add a stream to our weightfile.
Definition: Weightfile.cc:123
Belle2::MVA::Weightfile::addElement
void addElement(const std::string &identifier, const T &element)
Add an element to the xml tree.
Definition: Weightfile.h:114
Belle2::MVA::Weightfile::getElement
T getElement(const std::string &identifier) const
Returns a stored element from the xml tree.
Definition: Weightfile.h:151
Belle2::MVA::Weightfile::addFile
void addFile(const std::string &identifier, const std::string &custom_weightfile)
Add a file (mostly a weightfile from a MVA library) to our Weightfile.
Definition: Weightfile.cc:115
Belle2::MVA::Weightfile::getFeatureImportance
std::map< std::string, float > getFeatureImportance() const
Get feature importance.
Definition: Weightfile.cc:83
Belle2::MVA::Weightfile::loadFromXMLFile
static Weightfile loadFromXMLFile(const std::string &filename)
Static function which loads a Weightfile from a XML file.
Definition: Weightfile.cc:240
Belle2::MVA::Weightfile::save
static void save(Weightfile &weightfile, const std::string &filename, const Belle2::IntervalOfValidity &iov=Belle2::IntervalOfValidity(0, 0, -1, -1))
Static function which saves a Weightfile to a file.
Definition: Weightfile.cc:154
Belle2::MVA::Weightfile::setRemoveTemporaryDirectories
void setRemoveTemporaryDirectories(bool remove_temporary_directories)
Set the deletion behaviour of the weightfile object for temporary directories For debugging it can be...
Definition: Weightfile.h:282
Belle2::MVA::Weightfile::saveToXMLFile
static void saveToXMLFile(Weightfile &weightfile, const std::string &filename)
Static function which saves a Weightfile to a XML file.
Definition: Weightfile.cc:175
Belle2::MVA::Weightfile::loadFromStream
static Weightfile loadFromStream(std::istream &stream)
Static function which deserializes a Weightfile from a stream.
Definition: Weightfile.cc:251
Belle2::MVA::Weightfile::addOptions
void addOptions(const Options &options)
Add an Option object to the xml tree.
Definition: Weightfile.cc:62
Belle2::MVA::Weightfile::loadFromROOTFile
static Weightfile loadFromROOTFile(const std::string &filename)
Static function which loads a Weightfile from a ROOT file.
Definition: Weightfile.cc:217
Belle2::MVA::Weightfile::getOptions
void getOptions(Options &options) const
Fills an Option object from the xml tree.
Definition: Weightfile.cc:67
Belle2::MVA::Weightfile::load
static Weightfile load(const std::string &filename, const Belle2::EventMetaData &emd=Belle2::EventMetaData(0, 0, 0))
Static function which loads a Weightfile from a file or from the database.
Definition: Weightfile.cc:195
Belle2::MVA::Weightfile::loadFromDatabase
static Weightfile loadFromDatabase(const std::string &identifier, const Belle2::EventMetaData &emd=Belle2::EventMetaData(0, 0, 0))
Static function which loads a Weightfile from the basf2 condition database.
Definition: Weightfile.cc:281
Belle2::MVA::Weightfile::saveToStream
static void saveToStream(Weightfile &weightfile, std::ostream &stream)
Static function which serializes a Weightfile to a stream.
Definition: Weightfile.cc:185
Belle2::MVA::Weightfile::loadFromFile
static Weightfile loadFromFile(const std::string &filename)
Static function which loads a Weightfile from a file.
Definition: Weightfile.cc:206
Belle2::MVA::Weightfile::addSignalFraction
void addSignalFraction(float signal_fraction)
Saves the signal fraction in the xml tree.
Definition: Weightfile.cc:95
Belle2::MVA::Weightfile::addFeatureImportance
void addFeatureImportance(const std::map< std::string, float > &importance)
Add variable importance.
Definition: Weightfile.cc:72
Belle2::MVA::Weightfile::saveToROOTFile
static void saveToROOTFile(Weightfile &weightfile, const std::string &filename)
Static function which saves a Weightfile to a ROOT file.
Definition: Weightfile.cc:165
Belle2::MVA::Weightfile::getSignalFraction
float getSignalFraction() const
Loads the signal fraction frm the xml tree.
Definition: Weightfile.cc:100
Belle2::MVA::Weightfile::generateFileName
std::string generateFileName(const std::string &suffix="")
Returns a temporary filename with the given suffix.
Definition: Weightfile.cc:105
Belle2::MVA::Weightfile::getStream
std::string getStream(const std::string &identifier) const
Returns the content of a stored stream as string.
Definition: Weightfile.cc:144
Belle2::MVA::Weightfile::saveToDatabase
static void saveToDatabase(Weightfile &weightfile, const std::string &identifier, const Belle2::IntervalOfValidity &iov=Belle2::IntervalOfValidity(0, 0, -1, -1))
Static function which saves a Weightfile in the basf2 condition database.
Definition: Weightfile.cc:258
Belle2::MVA::Weightfile::getFile
void getFile(const std::string &identifier, const std::string &custom_weightfile)
Creates a file from our weightfile (mostly this will be a weightfile of an MVA library)
Definition: Weightfile.cc:138
Belle2::TestHelpers::TempDirCreator
changes working directory into a newly created directory, and removes it (and contents) on destructio...
Definition: TestHelpers.h:66
Belle2::TEST
TEST(TestgetDetectorRegion, TestgetDetectorRegion)
Test Constructors.
Definition: utilityFunctions.cc:25
Belle2::Database::reset
static void reset(bool keepConfig=false)
Reset the database instance.
Definition: Database.cc:50
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17