JTestSlice2D.hh

Go to the documentation of this file.

#ifndef __JCOMPAREHISTOGRAMS__JTESTSLICE2D__
#define __JCOMPAREHISTOGRAMS__JTESTSLICE2D__
 
#include <memory>
#include <iostream>
 
#include "TH1.h"
#include "TH2.h"
 
#include "JLang/JException.hh"
 
#include "JCompareHistograms/JTest_t.hh"
 
 
/**
 * \author bjung
 */
namespace JCOMPAREHISTOGRAMS {}
namespace JPP { using namespace JCOMPAREHISTOGRAMS; }
 
namespace JCOMPAREHISTOGRAMS {
 
  /**
   * Abstract base class for 2D slice tests. 
   * The parameter `slice` can have the values x, X, y or Y. The histograms are sliced along the corresponding axis, and the runs test is applied to each slice.\n 
   * This test uses the input parameter `threshold` to evaluate whether the test is passed or failed for each slice.\n 
   * The evaluation is done by comparing the threshold value with the result of the runs test.\n 
   */
  class JTestSlice2D:
    public JTest_t
  { 
  public:  
 
    /**
     * Constructor.
     *
     * \param  testName      test name
     * \param  resultType    result type
     * \param  p             pointer to 1D test variant
     */
    JTestSlice2D(const std::string& testName,
                 const std::string& resultType,
                 JTest_t*           p) :
      JTest_t(testName, resultType),
      mfp1(&TH2::ProjectionX),
      mfp2(&TH2::ProjectionY),
      pTest1D(p),
      threshold(0.0),
      failuresThreshold(0.0),
      slice('x')
    {
      using namespace JPP;
      
      if (!p) {
        THROW(JNullPointerException, "JTestSlice2D::JTestSlice2D(): Uninitialised 1D test variant");
      }
    }
    
    
    /**
     * Check if given input histograms have equal binning.
     *
     * \param  h1          first  histogram
     * \param  h2          second histogram
     */
    void check(const TH1* h1,
               const TH1* h2) const
    {
      using namespace JPP;
 
      if (h1 == NULL || h2 == NULL) {
        THROW(JCastException, "JTestSlice2D::check(): Could not cast given TObjects to TH2.");
      }
      
      int nSlices1 = 0;
      int nSlices2 = 0;
      
      if        (slice == 'x' || slice == 'X') {
 
        nSlices1 = h1->GetNbinsX();
        nSlices2 = h2->GetNbinsX();
        
      } else if (slice == 'y' || slice == 'Y') {
 
        nSlices1 = h1->GetNbinsY();
        nSlices2 = h2->GetNbinsY();
      }
 
      if (nSlices1 != nSlices2) {
        THROW(JValueOutOfRange, "JTestSlice2D::configure(): Histograms with different binning. The objects: " << h1->GetName() << " and " << h2->GetName() << " can not be compared");
      }
    }
    
 
    /**
     * Get projection of given 2D histogram onto sliced axis.
     *
     * \param  h           histogram
     * \param  name        name
     * \param  firstBin    first bin
     * \param  lastBin     last  bin 
     * \param  option      option
     * \return             projection of input histogram on sliced axis
     */
    TH1& getProjectionOntoSlicedAxis(const TH2&        h,
                                     const char* const name     = "projection",
                                     const Int_t       firstBin =  0,
                                     const Int_t       lastBin  = -1,
                                     const Option_t*   option   = "") const
    {
      using namespace JPP;
      
      TH1* hp = (h.*mfp1)(name, firstBin, lastBin, option);
 
      if (hp != NULL) {
        return *hp;
      } else {
        THROW(JNullPointerException, "JTestSlice2D::getProjectionOntoSlicedAxis(): Projection failed.");
      }
    }
 
 
    /**
     * Get projection of given 2D histogram onto non-sliced axis.
     *
     * \param  h           histogram
     * \param  name        name
     * \param  firstBin    first bin
     * \param  lastBin     last  bin
     * \param  option      option
     * \return             projection of input histogram on sliced axis
     */
    TH1& getProjection(const TH2&        h,
                       const char* const name     = "projection",
                       const Int_t       firstBin =  0,
                       const Int_t       lastBin  = -1,
                       const Option_t*   option   = "") const
    {
      using namespace JPP;
      
      TH1* hp =  (h.*mfp2)(name, firstBin, lastBin, option);
 
      if (hp != NULL) {
        return *hp;
      } else {
        THROW(JNullPointerException, "JTestSlice2D::getProjection(): Projection failed.");
      }
    }
 
 
    /**
     * Tests the statistical compatibility of two ROOT TObjects
     * 
     * \param o1 First object
     * \param o2 Second object
     */
    void test(const TObject* o1, const TObject* o2) override
    {    
      using namespace std;
      using namespace JPP;
 
      const TH2* h1 = dynamic_cast<const TH2*>(o1);
      const TH2* h2 = dynamic_cast<const TH2*>(o2);
 
      check(h1, h2);
      
      const char* const h3name = (h1->GetName() == h2->GetName() ?
                                  MAKE_CSTRING(h1->GetName()                            << "_" << testName << "_" << slice) :
                                  MAKE_CSTRING(h1->GetName() << "_VS_" << h2->GetName() << "_" << testName << "_" << slice));
 
      TH1& h3 = getProjectionOntoSlicedAxis(*h1, h3name);
 
      const int nSlices = h3.GetNbinsX();
      
      int nFailures = 0;
 
      for (int i=1 ; i<=nSlices ; ++i){
 
        const std::string sliceName = MAKE_STRING(h3.GetName() << "_" << to_string(i));
             
        const TH1& s1 = getProjection(*h1, sliceName.c_str(), i, i);
        const TH1& s2 = getProjection(*h2, sliceName.c_str(), i, i);
 
        if (!(s1.GetSumOfWeights() > 0 && s2.GetSumOfWeights() > 0)) { continue; }
 
        pTest1D->test(&s1, &s2);
 
        const JTestResult& result1D = pTest1D->back();
        
        if (!result1D.passed) nFailures++;
        
        h3.SetBinContent(i, result1D.parameterValue);
      }
 
      const bool passed = (nFailures/((double) nSlices) < failuresThreshold);
      
      const JResultTitle title(testName, resultType, passed , nFailures);
 
      h3.SetTitle(title.getTitle().c_str());
      h3.GetYaxis()->SetTitle(resultType.c_str());      
      
      const JTestResult r(testName,
                          JRootObjectID(MAKE_STRING(h1->GetDirectory()->GetPath() << h1->GetName())),
                          JRootObjectID(MAKE_STRING(h2->GetDirectory()->GetPath() << h1->GetName())),
                          resultType, nFailures, failuresThreshold, h3.Clone(), passed);
 
      this->push_back(r);
 
      pTest1D->clear();
    }
 
 
    /**
     * Read test parameters from input.
     *
     * \param  in            input stream
     * \return               input stream
     */
    std::istream& read(std::istream& in) override
    {
      using namespace std;
      using namespace JPP;
 
      if (pTest1D) {
        
        try {
          in >> (*pTest1D);
        }
        catch (const std::exception& error) {
          THROW(JValueOutOfRange, "JTestSlice2D::read(): Could not read 1D test variant parameters due to the following error:" << endl << error.what());
        }
        
      } else {
        THROW(JNullPointerException, "JTestSlice2D::read(): 1D test variant is not set");
      }
      
      in >> failuresThreshold >> slice;
      
      if (failuresThreshold < 0.0 || failuresThreshold > 1.0) {
        THROW(JValueOutOfRange, "JTestSlice2D::read(): Invalid failuresThreshold value " << failuresThreshold);
      }
 
      if        (slice == 'x' || slice == 'X') {
        mfp1 = &TH2::ProjectionX;
        mfp2 = &TH2::ProjectionY;
      } else if (slice == 'y' || slice == 'Y') {
        mfp1 = &TH2::ProjectionY;       
        mfp2 = &TH2::ProjectionX;
      } else {
        THROW(JValueOutOfRange, "JTestSlice2D::read(): Invalid slice option \'" << slice << "\'");
      }
                                                                           
      return in;
    };
    
    
  protected:
 
    /** Type definition of pointer to `TH2` member function for projection **/
    typedef TH1D* (TH2::*pFunction)(const char*, Int_t, Int_t, Option_t*) const;
 
    pFunction mfp1;                         //!< Pointer to `TH2` member method for projections onto the sliced axis
    pFunction mfp2;                         //!< Pointer to `TH2` member method for projections onto the non-sliced axis
 
    std::unique_ptr<JTest_t> pTest1D;       //!< Unique pointer to 1D test variant
 
    double threshold;                       //!< threshold value to decide if test has passed.
    double failuresThreshold;               //!< threshold value to decide if test has passed.
    char   slice;                           //!< Axis to slice. x or X for x-axis, y or Y for y-axis, n or N for None.
  };
}
  
#endif