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

#include <JTestIdentical_1D.hh>

Inheritance diagram for JCOMPAREHISTOGRAMS::JTestIdentical_1D:

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

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

void	test (TObject o1, TObject o2) override
	Applies test for two ROOT TH1 histograms. More...

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

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

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

const std::string &	getTestName ()
	Get test name. More...

const std::string &	getResultType ()
	Get result type. 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
	Buffer to store results of multiple tests.*/. More...

Protected Attributes
const std::string	testName
	test name More...

const std::string	resultType
	result type More...

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

Detailed Description

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

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 20 of file JTestIdentical_1D.hh.

Constructor & Destructor Documentation

JCOMPAREHISTOGRAMS::JTestIdentical_1D::JTestIdentical_1D ( )

inline

Default constructor.

Definition at line 29 of file JTestIdentical_1D.hh.

                         :
       JTest_t("Identical_1D", "Difference"),
       JTestIdentical_t()
     {}

Member Function Documentation

std::istream& JCOMPAREHISTOGRAMS::JTestIdentical_1D::read ( std::istream & in )

inlineoverridevirtual

Read test parameters from input.

Parameters

in	input stream

Returns: input stream

Implements JCOMPAREHISTOGRAMS::JTest_t.

Definition at line 40 of file JTestIdentical_1D.hh.

                                              { 
       return in >> tolerance;
     };

void JCOMPAREHISTOGRAMS::JTestIdentical_1D::test	(	TObject *	o1,
		TObject *	o2
	)

inlineoverridevirtual

Applies test for two ROOT TH1 histograms.

Parameters

o1	First histogram
o2	Second histogram

Implements JCOMPAREHISTOGRAMS::JTest_t.

Definition at line 50 of file JTestIdentical_1D.hh.

                                                 {    
 
       using namespace std;
     
       if (!(dynamic_cast<TH2*>(o1) == NULL) || !(dynamic_cast<TH2*>(o2) == NULL)) {
         ERROR("For 2D histograms call JTestIdentical_2D: " << o1->GetName() << endl);
     
       } else if (!(dynamic_cast<TH1*>(o1) == NULL) && !(dynamic_cast<TH1*>(o2) == NULL)) {
                   
         TH1D* h1 =  dynamic_cast<TH1D*>(o1);
         TH1D* h2 =  dynamic_cast<TH1D*>(o2);
   
         if(h1 -> GetNbinsX() != h2 -> GetNbinsX())
           ERROR("Histograms with different bining. The objects: " << h1 -> GetName() << " can not be compared." << endl);
 
         JTestResult r = JIdenticalTest<TH1D>(h1, h2, tolerance, testName, resultType);
      
         results.push_back(r);
       }
     };

std::ostream& JCOMPAREHISTOGRAMS::JTest_t::write	(	std::ostream &	out,
		const char	delimiter = `' '`,
		const bool	onlyFailures = `false`
	)		const

inlineinherited

Write test result to output.

Parameters

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

Returns: output stream

Definition at line 81 of file JTest_t.hh.

                                                                          {
         
       for (std::vector<JTestResult>::const_iterator r = results.begin() ; r != results.end() ; ++r) {
 
         if (onlyFailures && r->passed) {
           continue;
         }
         
         print(out, *r, delimiter, true);
       }
       
       return out;
     }

virtual void JCOMPAREHISTOGRAMS::JTest_t::save	(	TFile *	f,
		const std::string &	path,
		const bool	onlyFailures = `false`
	)

inlinevirtualinherited

Writes the test result to root file.

Parameters

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

Definition at line 113 of file JTest_t.hh.

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

virtual void JCOMPAREHISTOGRAMS::JTest_t::clear ( )

inlinevirtualinherited

Clear results.

Definition at line 137 of file JTest_t.hh.

                          {
       results.clear();
     }

const std::string& JCOMPAREHISTOGRAMS::JTest_t::getTestName ( )

inlineinherited

Get test name.

Returns: test name

Definition at line 147 of file JTest_t.hh.

                                    {
       return testName;
     }

const std::string& JCOMPAREHISTOGRAMS::JTest_t::getResultType ( )

inlineinherited

Get result type.

Returns: result type

Definition at line 157 of file JTest_t.hh.

                                      {
       return resultType;
     }    

template<class T >

JTestResult JCOMPAREHISTOGRAMS::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 45 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->GetNbinsZ() ; ++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,
                      JRootObjectID(MAKE_STRING(h1->GetDirectory()->GetPath() << h1->GetName())),
                      JRootObjectID(MAKE_STRING(h2->GetDirectory()->GetPath() << h1->GetName())),
                      parameterName, maxDifference, tolerance, h3, passed);
 
       return r;
     };  

Member Data Documentation

double JCOMPAREHISTOGRAMS::JTestIdentical_1D::tolerance

private

tolerance value to accept the difference as acceptable.

Definition at line 69 of file JTestIdentical_1D.hh.

std::vector<JTestResult> JCOMPAREHISTOGRAMS::JTest_t::results

inherited

Buffer to store results of multiple tests.*/.

Definition at line 162 of file JTest_t.hh.

const std::string JCOMPAREHISTOGRAMS::JTest_t::testName

protectedinherited

test name

Definition at line 166 of file JTest_t.hh.

const std::string JCOMPAREHISTOGRAMS::JTest_t::resultType

protectedinherited

result type

Definition at line 167 of file JTest_t.hh.

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

JTestIdentical_1D.hh

Public Member Functions

Public Attributes

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation