Implementation of the a test to check if two 2D histograms are the same. More...

#include <JTestIdentical_2D.hh>

Inheritance diagram for JTestIdentical_2D:

Public Member Functions
	JTestIdentical_2D ()
	Default constructor. More...

std::istream &	read (std::istream &in) override
	Read test parameters from input. More...

std::ostream &	write (std::ostream &out, std::string delimiter=" ", bool onlyFailures=false) const override
	Write test result to output. More...

void	test (TObject o1, TObject o2) override
	Tests compatibility between two TObjects. More...

virtual void	save (TFile *f, std::string path, bool onlyFailures=false) override
	Writes the test result to root file. More...

void	clear () override
	Clear results. More...

std::string	getName () override
	Get test name. More...

std::string	getParameter () override
	Get parameter name. More...

template<class T >
JTestResult	JIdenticalTest (T h1, T h2, double tolerance, std::string testName, std::string parameterName)
	Bin-by-Bin test of two histograms, that verifies whether the histograms are the same. More...

Public Attributes
std::vector< JTestResult >	results

Private Attributes
double	tolerance
	tolerance value to accept the difference as acceptable. More...

const std::string	name = "Identical_2D"
	test name. More...

const std::string	parameter = "Difference"
	parameter name. More...

Detailed Description

Implementation of the a test to check if two 2D histograms are the same.

Author: rgruiz
This class is derived from the abstract class JTest_t(). For a general description of the implementation of this and other tests derived from JTest_t(), see its documentation.
The input parameter tolerance(), is used to evaluate whether the test is passed or failed.
The test is run by the method JIdenticalTest().

Definition at line 19 of file JTestIdentical_2D.hh.

Constructor & Destructor Documentation

JTestIdentical_2D::JTestIdentical_2D ( )

inline

Default constructor.

Definition at line 28 of file JTestIdentical_2D.hh.

28 {}

Member Function Documentation

std::istream& JTestIdentical_2D::read ( std::istream & in )

inlineoverridevirtual

Read test parameters from input.

Parameters

in	input stream

Returns: input stream

Implements JTest_t.

Definition at line 36 of file JTestIdentical_2D.hh.

                                            { 
     return in >> tolerance;
   };

std::ostream& JTestIdentical_2D::write	(	std::ostream &	out,
		std::string	delimiter = `" "`,
		bool	onlyFailures = `false`
	)		const

inlineoverridevirtual

Write test result to output.

Parameters

out	output stream
delimiter	field delimiter
onlyFailures	If true, write only failures.

Returns: output stream

Implements JTest_t.

Definition at line 48 of file JTestIdentical_2D.hh.

                                                                                                          {
     for (std::vector<JTestResult>::const_iterator r = results.begin() ; r != results.end() ; ++r) {
       if (onlyFailures){
         if (!r->passed)
           out << std::scientific << std::setprecision(2) << (r->passed ? JPP::GREEN : JPP::RED) << r->print(delimiter) << std::endl;
       }else{
         out << std::scientific << std::setprecision(2) << (r->passed ? JPP::GREEN : JPP::RED) << r->print(delimiter) << std::endl;
       }
     }
     return out;
   };

void JTestIdentical_2D::test	(	TObject *	o1,
		TObject *	o2
	)

inlineoverridevirtual

Tests compatibility between two TObjects.

Parameters

o1	First object
o2	Second object

Implements JTest_t.

Definition at line 66 of file JTestIdentical_2D.hh.

                                               {    
 
     using namespace std;
     
     if (!(dynamic_cast<TH2*>(o1) == NULL) && !(dynamic_cast<TH2*>(o2) == NULL)) {
                   
       TH2D* h1 =  dynamic_cast<TH2D*>(o1);
       TH2D* h2 =  dynamic_cast<TH2D*>(o2);
   
       if(h1 -> GetNbinsX() != h2 -> GetNbinsX() || h1 -> GetNbinsY() != h2 -> GetNbinsY())
         ERROR("Histograms with different bining. The objects: " << h1 -> GetName() << " can not be compared." << endl);
 
       JTestResult r = JIdenticalTest<TH2D>(h1, h2, tolerance, name, parameter);
      
       results.push_back(r);
     }
   };

virtual void JTestIdentical_2D::save	(	TFile *	f,
		std::string	path,
		bool	onlyFailures = `false`
	)

inlineoverridevirtual

Writes the test result to root file.

Parameters

f	A ROOT file
path	Path in root file.
onlyFailures	If true, write only failures.

Implements JTest_t.

Definition at line 90 of file JTestIdentical_2D.hh.

                                                                                   {
     
     using namespace std;
     
     for (vector<JTestResult>::const_iterator r = results.begin() ; r != results.end() ; ++r){
       
       if (onlyFailures){
         if (!r->passed){
           if (f -> GetDirectory(path.c_str())==0) f->mkdir(path.c_str());
           f->cd(path.c_str());
           r->obj->Write();
         }
       }else{
         if (f -> GetDirectory(path.c_str())==0) f->mkdir(path.c_str());
         f->cd(path.c_str());
         r->obj->Write();
       }
     }      
   }

void JTestIdentical_2D::clear ( )

inlineoverridevirtual

Clear results.

Implements JTest_t.

Definition at line 113 of file JTestIdentical_2D.hh.

                        {
     results.clear();
   }

std::string JTestIdentical_2D::getName ( )

inlineoverridevirtual

Get test name.

Implements JTest_t.

Definition at line 120 of file JTestIdentical_2D.hh.

                               {
     return name;
   }

std::string JTestIdentical_2D::getParameter ( )

inlineoverridevirtual

Get parameter name.

Implements JTest_t.

Definition at line 127 of file JTestIdentical_2D.hh.

                                    {
     return parameter;
   }

template<class T >

JTestResult JTestIdentical_t::JIdenticalTest	(	T *	h1,
		T *	h2,
		double	tolerance,
		std::string	testName,
		std::string	parameterName
	)

inlineinherited

Bin-by-Bin test of two histograms, that verifies whether the histograms are the same.

For each bin, the test calculates the difference, and compares it with a tolerance passed as an argument.
The test is passed if the difference is smaller than the tolerance for every bin.
The template parameter can be TH1X, TH2X or TH3X.

Parameters

h1	First object
h2	Second object
tolerance	tolerance value for the bin-by-bin differences
parameterName	Name of the parameter used to test the histograms
testName	Name of the test used to compare the histograms

Returns: Test result.

Definition at line 39 of file JTestIdentical_t.hh.

                                                                                                           {    
     
     using namespace std;
     using namespace JPP;
         
     if(h1 -> GetNbinsX() != h2 -> GetNbinsX() || h1 -> GetNbinsY() != h2 -> GetNbinsY() || h1 -> GetNbinsZ() != h2 -> GetNbinsZ())
       ERROR("Histograms with different bining. The objects: " << h1 -> GetName() << " can not be compared." << endl);
         
     T* h3 = (T*)h1->Clone(h1->GetName()==h2->GetName() ?
                           MAKE_CSTRING(to_string(h1->GetName())) :
                           MAKE_CSTRING(to_string(h1->GetName()) + "_VS_" + to_string(h2->GetName())));
     
     h3->Add(h2,-1);
 
     bool passed;
     
     double maxDifference = 0.0;
     
     for (int i=0 ; i < h1->GetNbinsX() ; ++i){
       for (int j=0 ; j< h1->GetNbinsY() ; ++j){
         for (int k=0 ; k< h1->GetNbinsY() ; ++k){
           
           double d = h1->GetBinContent(i+1,j+1,k+1) - h2->GetBinContent(i+1,j+1,k+1);
 
           if (fabs(d) > maxDifference)
             maxDifference = fabs(d);
           if (fabs(d) > tolerance)
             passed = false;
         }       
       }
     }
 
     JResultTitle title(testName, parameterName, passed , maxDifference);
     
     h3->SetTitle(title.getTitle().c_str());
         
     JTestResult r (testName,
                    string (h1->GetDirectory()->GetPath()).append(h1->GetName()),
                    string (h2->GetDirectory()->GetPath()).append(h2->GetName()),
                    h1->GetDirectory()->GetFile()->GetName(),
                    h2->GetDirectory()->GetFile()->GetName(),
                    parameterName, maxDifference, tolerance, h3, passed);
 
     return r;
   };  

Member Data Documentation

double JTestIdentical_2D::tolerance

private

tolerance value to accept the difference as acceptable.

Definition at line 133 of file JTestIdentical_2D.hh.

const std::string JTestIdentical_2D::name = "Identical_2D"

private

test name.

Definition at line 134 of file JTestIdentical_2D.hh.

const std::string JTestIdentical_2D::parameter = "Difference"

private

parameter name.

Definition at line 135 of file JTestIdentical_2D.hh.

std::vector<JTestResult> JTest_t::results

inherited

Buffer to store results of multiple tests.

Definition at line 251 of file JTest_t.hh.

The documentation for this class was generated from the following file:

JTestIdentical_2D.hh

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation