Implementation of a bin-by-bin compatibility test for 2D histograms with low bin contents. More...

#include <JTestZero.hh>

Inheritance diagram for JCOMPAREHISTOGRAMS::JTestZero:

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

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

void	test (TObject o1, TObject o2) override
	Bin-by-bin comparison for ROOT TH2 histograms, of compatibility with a Poisson pdf of parameter 1. 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...

JTestResult	JTestZero_2D (TH2 h1, TH2 h2, double outliersThreshold, double threshold, std::string testName, std::string parameterName)
	Bin-by-Bin test for 2D histograms where a very low number of entries is expected. 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	outliersThreshold
	Fraction of bins allowed to fail. More...

double	threshold
	threshold p-value to decide if test is passed. More...

Detailed Description

Implementation of a bin-by-bin compatibility test for 2D histograms with low bin contents.

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 test is run by the method JTestZero_2D().

Definition at line 29 of file JTestZero.hh.

Constructor & Destructor Documentation

JCOMPAREHISTOGRAMS::JTestZero::JTestZero ( )

inline

Default constructor.

Definition at line 38 of file JTestZero.hh.

                 :
       JTest_t("Zero", "failure_fraction"),
       JTestZero_t()
     {}

Member Function Documentation

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

inlineoverridevirtual

Read test parameters from input.

Parameters

in	input stream

Returns: input stream

Implements JCOMPAREHISTOGRAMS::JTest_t.

Definition at line 49 of file JTestZero.hh.

                                              { 
       return in >> outliersThreshold >> threshold;
     };

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

inlineoverridevirtual

Bin-by-bin comparison for ROOT TH2 histograms, of compatibility with a Poisson pdf of parameter 1.

Parameters

o1	First histogram
o2	Second histogram

Implements JCOMPAREHISTOGRAMS::JTest_t.

Definition at line 59 of file JTestZero.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);
       
         JTestResult r = JTestZero_2D(h1, h2, outliersThreshold, threshold, 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;
     }    

JTestResult JCOMPAREHISTOGRAMS::JTestZero_t::JTestZero_2D	(	TH2 *	h1,
		TH2 *	h2,
		double	outliersThreshold,
		double	threshold,
		std::string	testName,
		std::string	parameterName
	)

inlineinherited

Bin-by-Bin test for 2D histograms where a very low number of entries is expected.

The test loops over all the bins of both histograms and performs the following operations.
-Calculates the probability that the observed bin content for histogram A is obtained from a Poisson of parameter 1.
-Compares the previous result with the threshold value given as an input parameter. The result is true if the probability is higher than the threshold.
-Calculates the probability that the observed bin content for histogram B is obtained from a Poisson of parameter 1.
-Compares the previous result with the threshold value given as an input parameter. The result is true if the probability is higher than the threshold.
-Compares the results from both bins: If both are true, or both are false, the test is passed. If one is true and the other is false, the test is failed.
At the end of the loop, a failure fraction is computed and compared to the outliersThreshold parameter. If the failure fraction is above the threshold, the test is failed.

Parameters

h1	First object
h2	Second object
outliersThreshold	Fraction of incompatible bins allowed.
threshold	Poisson p-value
parameterName	Name of the parameter used to test the histograms
testName	Name of the test used to compare the histograms

Definition at line 54 of file JTestZero_t.hh.

                                                                                                                                         {    
 
       using namespace std;
       using namespace JPP;
     
       int nx1 = h1->GetNbinsX();
       int nx2 = h2->GetNbinsX();      
       int ny1 = h1->GetNbinsY();
       int ny2 = h2->GetNbinsY();
 
       if(nx1 != nx2 || ny1 != ny2)
         ERROR("Histograms with different binning. The objects: " << h1->GetName() << " can not be compared." << endl);
         
       TH2D* h3 = (TH2D*)h1->Clone(h1->GetName()==h2->GetName() ?
                                   MAKE_CSTRING(to_string(h1->GetName())) :
                                   MAKE_CSTRING(to_string(h1->GetName()) + "_VS_" + to_string(h2->GetName())));
       h3->Reset();
 
       double failures = 0;
     
       for (int i=1 ; i<nx1+1 ; ++i){
         for (int j=1 ; j<ny1+1 ; ++j){
         
           double m = h1 -> GetBinContent(i,j);
           double n = h2 -> GetBinContent(i,j);
         
           double p1 = 1 - ROOT::Math::poisson_cdf(m,1);
           double p2 = 1 - ROOT::Math::poisson_cdf(n,1);         
 
           if ((p1 > threshold && p2 < threshold) || 
               (p1 < threshold && p2 > threshold)){
             h3->Fill(i,j);
             failures+=1./(nx1*ny1);
           }      
         }
       }
 
       bool passed;
     
       (failures > outliersThreshold ? passed = false : passed = true);
     
       JResultTitle title(testName, parameterName, passed , failures);
     
       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, failures, threshold, h3, passed);
 
       return r;      
     };

Member Data Documentation

double JCOMPAREHISTOGRAMS::JTestZero::outliersThreshold

private

Fraction of bins allowed to fail.

Definition at line 71 of file JTestZero.hh.

double JCOMPAREHISTOGRAMS::JTestZero::threshold

private

threshold p-value to decide if test is passed.

Definition at line 75 of file JTestZero.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:

JTestZero.hh

Public Member Functions

Public Attributes

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation