JTestKolmogorovSlice.hh

Go to the documentation of this file.

#ifndef __JTESTKOLMOGOROV_SLICE__
#define __JTESTKOLMOGOROV_SLICE__

#include <istream>
#include <ostream>
#include "TMath.h"
#include "JCompareHistograms/JTest_t.hh"
#include "JCompareHistograms/JTestKolmogorov_t.hh"

/**
 * \author rgruiz
 */

/**
 * Implementation of the Kolmogorov test for 2D histograms.\n
 * 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.\n
 * This test compares two 2D histograms. If the parameter slice() equals x, X y or Y, the histograms are sliced along the corresponding axis, and the JKolmogorovTest() test is applied to each slice.\n 
 * If slice() equals n or N, the histograms are not sliced, and JKolmogorovTest2D() is applied.\n 
 * The input parameter threshold(), is used to evaluate whether the test is passed or failed for each slice or for the full 2D distribution.\n
 * The evaluation is done by comparing the threshold() value with the result produced by JKolmogorovTest() or JKolmogorovTest2D(), which is a p-value.\n 
 * The parameter threshold() should therefore be a real value between 0 and 1.
 */
class JTestKolmogorovSlice: 
  public JTestKolmogorov_t, 
  public JTest_t 
{ 
public:  
  /**
   * Default constructor.
   */    
  JTestKolmogorovSlice(){}
  
  /**
   * Read test parameters from input.
   *
   * \param  in            input stream
   * \return               input stream
   */
  std::istream& read(std::istream& in) override{ 
    return in >> threshold >> slice >> failuresThreshold;
  };

  /**
   * Write test result to output.
   *
   * \param  out           output stream
   * \param  delimiter     field delimiter
   * \param  onlyFailures  If true, write only failures.
   * \return               output stream
   */
  std::ostream& write(std::ostream& out, std::string delimiter = " ", bool onlyFailures = false) const override{
    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;
  };

  /**
   * Applies Kolmogorov test for two ROOT TH2 histograms.
   *
   * \param o1 First histogram
   * \param o2 Second histogram
   */
  void test(TObject* o1, TObject* o2) override{    
      
    using namespace std;
    using namespace JPP;
    
    if (!(dynamic_cast<TH2*>(o1) == NULL) && !(dynamic_cast<TH2*>(o2) == NULL)) {
                  
      TH2D* h1 = dynamic_cast<TH2D*>(o1);
      TH2D* h2 = dynamic_cast<TH2D*>(o2);

      if(slice == 'x' || slice == 'X' || slice == 'y' || slice == 'Y'){

        JTestResult r = JKolmogorovTestSlice(h1, h2, threshold, failuresThreshold, name, parameter, slice);

        results.push_back(r);
        
      } else {
        ERROR ("Slice option should be: x, X, y or Y, and not " + slice);
      }

    }else if (!(dynamic_cast<TH1*>(o1) == NULL) && !(dynamic_cast<TH1*>(o2) == NULL)) {
      ERROR("For 1D histograms call JTestKolmogorov_1D: " << o1->GetName() << endl);
   }
  };

  /**
   * Writes the test result to root file
   * \param f A ROOT file 
   * \param path Path in root file.
   * \param onlyFailures  If true, write only failures.
   */
  virtual void save(TFile* f , std::string path, bool onlyFailures = false) override{
    
    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();
      }
    }      
  }

  /**
   * Clear results
   */
  void clear() override{
    results.clear();
  }
  
  /**
   * Get test name.
   */
  std::string getName() override{
    return name;
  }

  /**
   * Get parameter name.
   */
  std::string getParameter() override{
    return parameter;
  }


private:
  double threshold;                            //!< threshold p-value to decide if test is passed.
  double failuresThreshold;                    //!< threshold p-value to decide if test is passed.
  char   slice;                                //!< axis to slice. x or X for x-axis, y or Y for y-axis, n or N for None.
  const std::string name = "KS_Slice";         //!< test name.
  const std::string parameter = "p-Value(KS)"; //!< parameter name.
}; 

#endif