NtupleManagerTest.cxx File Reference

Test the operation of Framework processing. More...

#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_vector.hpp>
#include "Framework/NtupleManager.h"
#include "TFile.h"
#include "TTreeReader.h"
#include "TTreeReaderArray.h"
#include "TTreeReaderValue.h"

Go to the source code of this file.

Functions
template<typename T >
std::vector< T >	fromTTreeReaderArray (const TTreeReaderArray< T > &reader_val)
	TTreeReaderValue<std::vector<T>> fails when attempting to register in this test so we use TTreeReaderArray<T> instead.
	TEST_CASE ("Ntuple Manager Functions", "[Framework][functionality]")
	Test for NtupleManager.

Detailed Description

Test the operation of Framework processing.

Author

Tom Eichlersmith, University of Minnesota

Definition in file NtupleManagerTest.cxx.

Function Documentation

fromTTreeReaderArray()

template<typename T >

std::vector< T > fromTTreeReaderArray

(

const TTreeReaderArray< T > &

reader_val

)

TTreeReaderValue<std::vector<T>> fails when attempting to register in this test so we use TTreeReaderArray<T> instead.

This then functions properly but we then have to convert it back to a std::vector so that Catch2 can compare it to our correct answer.

Definition at line 24 of file NtupleManagerTest.cxx.

                                                                         {
  std::vector<T> v;
  for (const auto& val : reader_val) {
    v.push_back(val);
  }
  return v;
}

Referenced by TEST_CASE().

TEST_CASE()

TEST_CASE	(	"Ntuple Manager Functions"	,
		""	[Framework][functionality] )

Test for NtupleManager.

We check that the NtupleManager can fill a TTree with three entries of the following types.

• bool, short, int, long, float, double
• vectors of the above types

Definition at line 40 of file NtupleManagerTest.cxx.

                                                                    {
  const char* ntuple_file = "/tmp/test_ntuplemanager.root";
 
  TFile f(ntuple_file, "recreate");
  framework::NtupleManager& n{framework::NtupleManager::getInstance()};
  REQUIRE_NOTHROW(n.create("test"));
  CHECK_THROWS(n.create("test"));
 
  REQUIRE_NOTHROW(n.addVar<bool>("test", "bool"));
  REQUIRE_NOTHROW(n.addVar<short>("test", "short"));
  REQUIRE_NOTHROW(n.addVar<int>("test", "int"));
  REQUIRE_NOTHROW(n.addVar<long>("test", "long"));
  REQUIRE_NOTHROW(n.addVar<float>("test", "float"));
  REQUIRE_NOTHROW(n.addVar<double>("test", "double"));
  REQUIRE_NOTHROW(n.addVar<std::vector<bool>>("test", "vector_bool"));
  REQUIRE_NOTHROW(n.addVar<std::vector<short>>("test", "vector_short"));
  REQUIRE_NOTHROW(n.addVar<std::vector<int>>("test", "vector_int"));
  REQUIRE_NOTHROW(n.addVar<std::vector<long>>("test", "vector_long"));
  REQUIRE_NOTHROW(n.addVar<std::vector<float>>("test", "vector_float"));
  REQUIRE_NOTHROW(n.addVar<std::vector<double>>("test", "vector_double"));
 
  CHECK_THROWS(n.addVar<float>("test", "float"));
 
  std::vector<bool> bools = {true, false, true};
  std::vector<short> shorts = {2, 3, 4};
  std::vector<int> ints = {2, 3, 4};
  std::vector<long> longs = {2, 3, 4};
  std::vector<float> floats = {0.2, 0.3, 0.4};
  std::vector<double> doubles = {0.2, 0.3, 0.4};
 
  std::vector<std::vector<bool>> vector_bools = {
      {true, true, true}, {false, false, false}, {true, false, false}};
  std::vector<std::vector<short>> vector_shorts = {
      {1, 2, 3}, {5, 7, 9}, {3, 4, 5}};
  std::vector<std::vector<int>> vector_ints = {{1, 2, 3}, {5, 7, 9}, {3, 4, 5}};
  std::vector<std::vector<long>> vector_longs = {
      {1, 2, 3}, {5, 7, 9}, {3, 4, 5}};
  std::vector<std::vector<float>> vector_floats = {
      {0.1, 0.01, 0.001}, {2e4, 3e5, 4e6}, {0.9, 0.99, 0.999}};
  std::vector<std::vector<double>> vector_doubles = {
      {0.1, 0.01, 0.001}, {2e4, 3e5, 4e6}, {0.9, 0.99, 0.999}};
 
  for (size_t i = 0; i < 3; i++) {
    // to save space, a std::vector<bool>
    //  compresses each bool into a one-bit
    //  type that can be converted back to the
    //  8-bit bool type.
    REQUIRE_NOTHROW(n.setVar("bool", bool(bools.at(i))));
    REQUIRE_NOTHROW(n.setVar("short", shorts.at(i)));
    REQUIRE_NOTHROW(n.setVar("int", ints.at(i)));
    REQUIRE_NOTHROW(n.setVar("long", longs.at(i)));
    REQUIRE_NOTHROW(n.setVar("float", floats.at(i)));
    REQUIRE_NOTHROW(n.setVar("double", doubles.at(i)));
    REQUIRE_NOTHROW(n.setVar("vector_bool", vector_bools.at(i)));
    REQUIRE_NOTHROW(n.setVar("vector_short", vector_shorts.at(i)));
    REQUIRE_NOTHROW(n.setVar("vector_int", vector_ints.at(i)));
    REQUIRE_NOTHROW(n.setVar("vector_long", vector_longs.at(i)));
    REQUIRE_NOTHROW(n.setVar("vector_float", vector_floats.at(i)));
    REQUIRE_NOTHROW(n.setVar("vector_double", vector_doubles.at(i)));
    CHECK_THROWS(n.setVar("bool", shorts.at(i)));
    CHECK_THROWS(n.setVar("bool", vector_bools.at(i)));
    n.fill();
    n.clear();
  }
 
  f.Write();
  f.Close();
 
  TTreeReader r("test", TFile::Open(ntuple_file));
  r.Restart();
  TTreeReaderValue<bool> root_bool(r, "bool");
  TTreeReaderValue<short> root_short(r, "short");
  TTreeReaderValue<int> root_int(r, "int");
  // root serializes 'long' (which on some systems is 64-bit)
  //  depending on the number of bits, so we need to read
  //  it in with 'long long' (which is at least 64-bit)
  //  to make sure we don't fail
  TTreeReaderValue<long long> root_long(r, "long");
  TTreeReaderValue<float> root_float(r, "float");
  TTreeReaderValue<double> root_double(r, "double");
  TTreeReaderArray<bool> root_vector_bool(r, "vector_bool");
  TTreeReaderArray<short> root_vector_short(r, "vector_short");
  TTreeReaderArray<int> root_vector_int(r, "vector_int");
  TTreeReaderArray<long> root_vector_long(r, "vector_long");
  TTreeReaderArray<float> root_vector_float(r, "vector_float");
  TTreeReaderArray<double> root_vector_double(r, "vector_double");
 
  for (size_t i = 0; i < 3; i++) {
    REQUIRE(r.Next());
    CHECK(*root_bool == bools.at(i));
    CHECK(*root_short == shorts.at(i));
    CHECK(*root_int == ints.at(i));
    CHECK(*root_long == longs.at(i));
    CHECK(*root_float == floats.at(i));
    CHECK(*root_double == doubles.at(i));
    // root takes the liberty to permut vectors when serializing
    //  in order to try to save space
    // This means we need to use unordered equals.
    // Not too much loss in efficiency becuase we keep our vectors short.
    CHECK_THAT(fromTTreeReaderArray(root_vector_bool),
               Catch::Matchers::UnorderedEquals(vector_bools.at(i)));
    CHECK_THAT(fromTTreeReaderArray(root_vector_short),
               Catch::Matchers::UnorderedEquals(vector_shorts.at(i)));
    CHECK_THAT(fromTTreeReaderArray(root_vector_int),
               Catch::Matchers::UnorderedEquals(vector_ints.at(i)));
    CHECK_THAT(fromTTreeReaderArray(root_vector_long),
               Catch::Matchers::UnorderedEquals(vector_longs.at(i)));
    CHECK_THAT(fromTTreeReaderArray(root_vector_float),
               Catch::Matchers::UnorderedEquals(vector_floats.at(i)));
    CHECK_THAT(fromTTreeReaderArray(root_vector_double),
               Catch::Matchers::UnorderedEquals(vector_doubles.at(i)));
  }
 
}  // process test

References fromTTreeReaderArray(), and framework::NtupleManager::getInstance().