testOfflineUtils_ROOT.cc

Go to the documentation of this file.

#include <tst/Verify.h>
#include <cppunit/extensions/HelperMacros.h>

#include <io/TimeDistribution_ROOT.h>
#include <utl/TimeDistribution.h>

#include <io/Trace_ROOT.h>
#include <io/MultiTrace_ROOT.h>
#include <utl/Trace.h>
#include <utl/MultiTrace.h>
#include <utl/System.h>

#include <utl/TabulatedFunctionErrors.h>
#include <utl/TabulatedFunction.h>
#include <io/TabulatedFunctionErrors_ROOT.h>
#include <io/TabulatedFunction_ROOT.h>

#include <io/MultiTabulatedFunction_ROOT.h>
#include <io/MultiTabulatedFunctionErrors_ROOT.h>
#include <utl/MultiTabulatedFunction.h>
#include <utl/MultiTabulatedFunctionErrors.h>

#include <utl/Ignore.h>

#include <TFile.h>
#include <TROOT.h>

#include <iostream>

#include <boost/tuple/tuple_io.hpp>

using namespace std;
using namespace utl;
using namespace tst;
using namespace io;


class TestOfflineUtils_ROOT_io : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(TestOfflineUtils_ROOT_io);
  CPPUNIT_TEST(testTimeDistributionD);
  CPPUNIT_TEST(testTimeDistributionI);
  CPPUNIT_TEST(testTraceD);
  CPPUNIT_TEST(testTraceI);
  CPPUNIT_TEST(testVector);
  CPPUNIT_TEST(testPoint);
  CPPUNIT_TEST(testTabulatedFunction);
  CPPUNIT_TEST(testPhoton);
  CPPUNIT_TEST(testMultiTabulatedFunction);
  CPPUNIT_TEST(testMultiTrace);
  CPPUNIT_TEST_SUITE_END();

private:
  template<typename T>
  bool IsEqual(const MultiTrace<T>& traces1, const MultiTrace<T>& traces2);

  template<typename T>
  bool IsEqual(const TimeDistribution<T>& timeDistribution1,
               const TimeDistribution<T>& timeDistribution2);

  bool IsEqual(const TabulatedFunctionErrors& function1,
               const TabulatedFunctionErrors& function2);

  bool IsEqual(const TabulatedFunction& function1,
               const TabulatedFunction& function2);

  bool IsEqual(const MultiTabulatedFunction& functions1,
               const MultiTabulatedFunction& functions2);

  template<typename T>
  bool IsEqual(const Trace<T>& trace1, const Trace<T>& trace2);

public:
  void setUp()
  {
    fFile1 = 0;
    fFile2 = 0;
    fFilename = "basura.root";
  }

  void tearDown() { }

  void testPhoton() { }

  void testVector() { }

  void testPoint() { }

  void
  testMultiTrace()
  {
    fFile1 = new TFile(fFilename.c_str(), "RECREATE");
    CPPUNIT_ASSERT(fFile1);

    const int bins = 5;
    double array[bins] = { 10, 5.1, 3, 2, 1 };
    double binsize = 3;
    double array2[bins] = { 10, 5.1, 3, 2, 1 };
    double binsize2 = 3;

    Trace<double> trace(bins, array, binsize);
    trace.SetStart(6);
    trace.SetStop(16);
    Trace<double> trace2(bins, array2, binsize2);
    trace2.SetStart(5);
    trace2.SetStop(15);

    MultiTraceD multiTrace;
    multiTrace.AddTrace(trace, 0);
    multiTrace.AddTrace(trace2, 1);
    MultiTraceD_ROOT stream(multiTrace);
    fFile1->WriteObject(&stream, stream.Class_Name()); // <-- stream.Write();

    fFile1->Close();

    fFile2 = new TFile(fFilename.c_str());
    CPPUNIT_ASSERT(fFile2);

    MultiTraceD_ROOT* const stream2 =
      (MultiTraceD_ROOT*)gROOT->FindObject("io::MultiTrace_ROOT<double>");
    CPPUNIT_ASSERT(stream2);

    MultiTraceD multiTrace2;
    *stream2 >> multiTrace2;

    CPPUNIT_ASSERT(IsEqual(multiTrace, multiTrace2));

    fFile2->Close();

    delete fFile1;
    delete fFile2;
    fFile1 = nullptr;
    fFile2 = nullptr;

    string msg = "rm ";
    msg.append(fFilename);
    System(msg);
  }

  void
  testTabulatedFunction()
  {
    fFile1 = new TFile(fFilename.c_str(), "RECREATE");
    CPPUNIT_ASSERT(fFile1);

    TabulatedFunction tabulatedFunction;
    for (int i = 0; i < 10; ++i)
      tabulatedFunction.PushBack(i*0.5, 10.0-i);

    TabulatedFunction_ROOT tabulatedFunction_ROOT(tabulatedFunction);
    fFile1->WriteObject(&tabulatedFunction_ROOT, tabulatedFunction_ROOT.Class_Name());

    TabulatedFunctionErrors tabulatedFunctionErrors;
    for (int i = 0; i < 10; ++i)
      tabulatedFunctionErrors.PushBack(i*0.5, 10.0-i, 0.01*i, 0.05*i);

    TabulatedFunctionErrors_ROOT tabulatedFunctionErrors_ROOT(tabulatedFunctionErrors);
    fFile1->WriteObject(&tabulatedFunctionErrors_ROOT, tabulatedFunctionErrors_ROOT.Class_Name());

    fFile1->Close();

    fFile2 = new TFile(fFilename.c_str());
    CPPUNIT_ASSERT(fFile2);

    TabulatedFunctionErrors_ROOT* const tabulatedFunctionErrors_ROOT2 =
      (TabulatedFunctionErrors_ROOT*)gROOT->FindObject("io::TabulatedFunctionErrors_ROOT");
    CPPUNIT_ASSERT(tabulatedFunctionErrors_ROOT2);
    TabulatedFunctionErrors tabulatedFunctionErrors2;
    *tabulatedFunctionErrors_ROOT2 >> tabulatedFunctionErrors2;
    CPPUNIT_ASSERT(IsEqual(tabulatedFunctionErrors, tabulatedFunctionErrors2));

    TabulatedFunction_ROOT* const tabulatedFunction_ROOT2 =
      (TabulatedFunction_ROOT*)gROOT->FindObject("io::TabulatedFunction_ROOT");
    CPPUNIT_ASSERT(tabulatedFunction_ROOT2);
    TabulatedFunction tabulatedFunction2;
    *tabulatedFunction_ROOT2 >> tabulatedFunction2;
    CPPUNIT_ASSERT(IsEqual(tabulatedFunction, tabulatedFunction2));

    fFile2->Close();

    delete fFile1;
    delete fFile2;
    fFile1 = nullptr;
    fFile2 = nullptr;

    string msg = "rm ";
    msg.append(fFilename);
    System(msg);
  }

  void
  testMultiTabulatedFunction()
  {
    fFile1 = new TFile(fFilename.c_str(), "RECREATE");
    CPPUNIT_ASSERT(fFile1);
    TabulatedFunction tabulatedFunction1;
    for (int i = 0; i < 10; ++i)
      tabulatedFunction1.PushBack(i*0.5, 10.0-i);

    TabulatedFunction tabulatedFunction2;
    for (int i = 10; i < 20; ++i)
      tabulatedFunction2.PushBack(i*0.5, 10.0-i);

    TabulatedFunction tabulatedFunction3;
    for (int i = 20; i < 30; ++i)
      tabulatedFunction3.PushBack(i*0.5, 10.0-i);

    MultiTabulatedFunction multiTabulatedFunction;
    multiTabulatedFunction.AddTabulatedFunction(tabulatedFunction1, 1);
    multiTabulatedFunction.AddTabulatedFunction(tabulatedFunction2, 2);
    multiTabulatedFunction.AddTabulatedFunction(tabulatedFunction3, 4);

    MultiTabulatedFunction_ROOT multiTabulatedFunction_ROOT(multiTabulatedFunction);
    fFile1->WriteObject(&multiTabulatedFunction_ROOT, multiTabulatedFunction_ROOT.Class_Name());

    fFile1->Close();

    fFile2 = new TFile(fFilename.c_str());
    CPPUNIT_ASSERT(fFile2);

    MultiTabulatedFunction_ROOT* const multiTabulatedFunction_ROOT2 =
      (MultiTabulatedFunction_ROOT*)gROOT->FindObject("io::MultiTabulatedFunction_ROOT");
    CPPUNIT_ASSERT(multiTabulatedFunction_ROOT2);

    MultiTabulatedFunction multiTabulatedFunction2;
    *multiTabulatedFunction_ROOT2 >> multiTabulatedFunction2;

    CPPUNIT_ASSERT(IsEqual(multiTabulatedFunction2, multiTabulatedFunction));

    fFile2->Close();

    delete fFile1;
    delete fFile2;
    fFile1 = nullptr;
    fFile2 = nullptr;

    string msg = "rm ";
    msg.append(fFilename);
    System(msg);
  }

  void
  testTraceD()
  {
    fFile1 = new TFile(fFilename.c_str(), "RECREATE");
    CPPUNIT_ASSERT(fFile1);

    const int bins = 5;
    const double array[bins] = { 10.0, 5.1, 3, 2, 1 };
    const double binsize = 3.0;

    TraceD trace(bins, array, binsize);
    trace.SetStart(6);

    TraceD_ROOT stream(trace);
    fFile1->WriteObject(&stream, stream.Class_Name());

    fFile1->Close();

    fFile2 = new TFile(fFilename.c_str());
    CPPUNIT_ASSERT(fFile2);

    TraceD_ROOT* const stream2 =
      (TraceD_ROOT*)gROOT->FindObject("io::Trace_ROOT<double>");
    CPPUNIT_ASSERT(stream2);

    TraceD trace2;
    *stream2 >> trace2;

    CPPUNIT_ASSERT(IsEqual(trace, trace2));

    fFile2->Close();

    delete fFile1;
    delete fFile2;
    fFile1 = nullptr;
    fFile2 = nullptr;

    string msg = "rm ";
    msg.append(fFilename);
    System(msg);
  }

  void
  testTraceI()
  {
    fFile1 = new TFile(fFilename.c_str(), "RECREATE");
    CPPUNIT_ASSERT(fFile1);

    const int bins = 5;
    const int array[bins] = { 10, 5, 3, 2, 1 };
    const double binsize = 3.0; // the bin size is a double ???

    TraceI trace(bins, array, binsize);
    trace.SetStart(6);

    TraceI_ROOT stream(trace);
    fFile1->WriteObject(&stream, stream.Class_Name());

    fFile1->Close();

    fFile2 = new TFile(fFilename.c_str());
    CPPUNIT_ASSERT(fFile2);

    TraceI_ROOT* const stream2 =
      (TraceI_ROOT*)gROOT->FindObject("io::Trace_ROOT<int>");
    CPPUNIT_ASSERT(stream2);

    TraceI trace2;
    *stream2 >> trace2;

    CPPUNIT_ASSERT(IsEqual(trace, trace2));

    fFile2->Close();

    delete fFile1;
    delete fFile2;
    fFile1 = nullptr;
    fFile2 = nullptr;

    string msg = "rm ";
    msg.append(fFilename);
    System(msg);
  }

  void
  testTimeDistributionI()
  {
    fFile1 = new TFile(fFilename.c_str(), "RECREATE");
    CPPUNIT_ASSERT(fFile1);

    fFile1->Close();

    fFile2 = new TFile(fFilename.c_str());
    CPPUNIT_ASSERT(fFile2);

    fFile2->Close();

    delete fFile1;
    delete fFile2;
    fFile1 = nullptr;
    fFile2 = nullptr;

    string msg = "rm ";
    msg.append(fFilename);
    System(msg);
  }

  void
  testTimeDistributionD()
  {
    const double binning = 2;
    TimeDistributionD* const timeDistribution = new TimeDistributionD(binning);

    timeDistribution->AddTime(11, 5);
    timeDistribution->AddTime(5, 3);

    TFile* const eventFile = new TFile("basura.root", "RECREATE");
    CPPUNIT_ASSERT(eventFile);
    TimeDistributionD_ROOT* const streamed = new TimeDistributionD_ROOT(*timeDistribution);
    CPPUNIT_ASSERT(streamed);

    eventFile->WriteObject(streamed, streamed->Class_Name());
    eventFile->Close();
    delete eventFile;

    TFile* const eventFile2 = new TFile("basura.root");
    CPPUNIT_ASSERT(eventFile2);
    TimeDistributionD_ROOT* const streamed2 =
      (TimeDistributionD_ROOT*)gROOT->FindObject("io::TimeDistribution_ROOT<double>");
    CPPUNIT_ASSERT(streamed2);

    TimeDistributionD* const timeDistribution2 = new TimeDistributionD(2);

    *streamed2 >> *timeDistribution2;

    CPPUNIT_ASSERT(IsEqual(*timeDistribution, *timeDistribution2));

    System("rm basura.root");
  }

private:
  string fFilename;
  TFile* fFile1;
  TFile* fFile2;

};


bool
TestOfflineUtils_ROOT_io::IsEqual(const TabulatedFunction& function1,
                                  const TabulatedFunction& function2)
{
  for (ConstTabulatedFunctionIterator it = function2.Begin();
       it != function2.End(); ++it)
    if (function1.FindX(it->X())->Y() != it->Y())
      return false;
  return true;
}


bool
TestOfflineUtils_ROOT_io::IsEqual(const TabulatedFunctionErrors& function1,
                                  const TabulatedFunctionErrors& function2)
{
  for (ConstTabulatedFunctionErrIterator it = function2.Begin();
       it != function2.End(); ++it)
    if (function1.FindX(it->X())->Y() != it->Y())
      return false;
  return true;
}


bool
TestOfflineUtils_ROOT_io::IsEqual(const MultiTabulatedFunction& functions1,
                                  const MultiTabulatedFunction& functions2)
{
  CPPUNIT_ASSERT(Verify<Equal>(functions1.GetNLabels(), functions2.GetNLabels()));

  for (MultiTabulatedFunction::ConstIterator it = functions1.TabulatedFunctionsBegin();
       it != functions1.TabulatedFunctionsEnd(); ++it)
    if (!IsEqual(it->GetTabulatedFunction(), functions2.GetTabulatedFunction(it->GetLabel())))
      return false;

  return true;
}


template<typename T>
bool
TestOfflineUtils_ROOT_io::IsEqual(const TimeDistribution<T>& timeDistribution1,
                                  const TimeDistribution<T>& timeDistribution2)
{
  for (typename TimeDistribution<T>::SparseIterator it = timeDistribution2.SparseBegin();
       it != timeDistribution2.SparseEnd(); ++it)
    if (timeDistribution1.At(it->template get<0>()) != it->template get<1>())
      return false;

  for (typename TimeDistribution<T>::SparseIterator it = timeDistribution1.SparseBegin();
       it != timeDistribution1.SparseEnd(); ++it)
    if (timeDistribution2[it->template get<0>()] != it->template get<1>())
      return false;

  return true;
}


template<typename T>
bool
TestOfflineUtils_ROOT_io::IsEqual(const Trace<T>& trace1,
                                  const Trace<T>& trace2)
{
  if (trace1.GetBinning() != trace2.GetBinning() ||
      trace1.GetStart() != trace2.GetStart() ||
      trace1.GetStop() != trace2.GetStop() ||
      trace1.GetSize() != trace2.GetSize())
    return false;

  for (int i = 0; i < int(trace1.GetSize()); ++i)
    if (trace1[i] != trace2[i])
      return false;

  return true;
}


template<typename T>
bool
TestOfflineUtils_ROOT_io::IsEqual(const MultiTrace<T>& traces1,
                                  const MultiTrace<T>& traces2)
{
  CPPUNIT_ASSERT(Verify<Equal>(traces1.GetNLabels(), traces2.GetNLabels()));

  for (typename MultiTrace<T>::ConstIterator it = traces1.Begin();
       it != traces1.End(); ++it)
    if (!IsEqual(it->GetTrace(), traces2.GetTrace(it->GetLabel())))
      return false;

  return true;
}


CPPUNIT_TEST_SUITE_REGISTRATION(TestOfflineUtils_ROOT_io);