JHistogramToolkit.hh

Go to the documentation of this file.

#ifndef __JHISTOGRAM_TOOLKIT__
#define __JHISTOGRAM_TOOLKIT__

#include <string>

#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"

#include "JFit/JFitParameters.hh"


/**
 * \author mdejong
 */

using namespace JFIT;

static const int JQUALITY = -1;   //!< fit quality identifier


/**
 * Map key.
 */
struct JKey {
  /**
   * Constructor.
   *
   * \param  name             parameter name
   * \param  index            parameter value (= index in user data)
   */
  JKey(const char* name,
       const int   index)
  {
    this->name  = name;
    this->index = index;
  }

    
  /**
   * Less than operator.
   *
   * \param  first            first  key
   * \param  second           second key
   * \return                  true if index of first key less than that of second; else false
   */
  friend inline bool operator<(const JKey& first, const JKey& second)
  {
    return first.index < second.index;
  }
    
  std::string name;
  int         index;
};

  
/**
 * Make key.
 *
 * \param  PARAMETER        parameter
 * \return                  key
 */
#define make_key(PARAMETER) JKey(#PARAMETER, PARAMETER)


/**
 * Map value.
 */
struct JValue {
  /**
   * Default constructor.
   */
  JValue() :
    hA(NULL),
    hB(NULL),
    hC(NULL),
    hD(NULL),
    logx(false)
  {}
    
    
  /**
   * Constructor.
   *
   * \param  hA               pointer to histogram
   * \param  hB               pointer to histogram
   * \param  hC               pointer to histogram
   * \param  hD               pointer to histogram
   * \param  logx             log10(x) filling mode
   */
  JValue(TH1D* hA,
         TH1D* hB,
         TH1D* hC,
         TH1D* hD,
         bool  logx = false)
  {
    this->hA   = hA;
    this->hB   = hB;
    this->hC   = hC;
    this->hD   = hD;
    this->logx = logx;
  }

    
  /**
   * Fill histograms.
   *
   * \param  xA               first  abscissa value
   * \param  xB               second abscissa value
   * \param  option           option
   */
  void Fill(const Double_t xA, const Double_t xB, const bool option)
  {
    hA->Fill(logx ? log10(xA) : xA);
    hB->Fill(logx ? log10(xB) : xB);
    if (option)
      hC->Fill(logx ? log10(xB/xA) : xB - xA);
    else
      hD->Fill(logx ? log10(xB/xA) : xB - xA);
  }

      
  /**
   * Scale histograms.
   */
  void Scale()
  {
    if (hA->GetEntries() != 0) { hA->Scale(1.0/hA->GetEntries()); }
    if (hB->GetEntries() != 0) { hB->Scale(1.0/hB->GetEntries()); }
    if (hC->GetEntries() != 0) { hC->Scale(1.0/hC->GetEntries()); }
    if (hD->GetEntries() != 0) { hD->Scale(1.0/hD->GetEntries()); }
  }

      
  /**
   * Write histograms to file.
   *
   * \param  out              ROOT file
   */
  void Write(TFile& out)
  {
    out.WriteTObject(hA);
    out.WriteTObject(hB);
    out.WriteTObject(hC);
    out.WriteTObject(hD);
  }

protected:
  TH1D* hA;
  TH1D* hB;
  TH1D* hC;
  TH1D* hD;
  bool  logx;
};
    

/**
 * Auxiliary class to manage set of histograms.
 */
struct JManager :
  public std::map<JKey, JValue>
{
  /**
   * Insert set of histograms.
   *
   * \param  key              key
   * \param  nx               number of bins
   * \param  xmin             minimal abscissa value
   * \param  xmax             maximal abscissa value
   * \param  logx             log10(x)
   */
  void insert(const JKey&    key,
              const Int_t    nx,
              const Double_t xmin,
              const Double_t xmax,
              const double   logx = false)
  {
    TH1D* hA = new TH1D(("[A " + key.name + "]").c_str(), NULL, nx,  xmin, xmax);
    TH1D* hB = new TH1D(("[B " + key.name + "]").c_str(), NULL, nx,  xmin, xmax);
    TH1D* hC = new TH1D(("[C " + key.name + "]").c_str(), NULL, nx, -xmax, xmax);
    TH1D* hD = new TH1D(("[D " + key.name + "]").c_str(), NULL, nx, -xmax, xmax);
      
    std::map<JKey, JValue>::insert(make_pair(key, JValue(hA,hB,hC,hD,logx)));
  }

    
  /**
   * Fill histograms.
   *
   * \param  fA               first  fit result
   * \param  fB               second fit result
   * \param  option           option
   */
  void Fill(const JFit& fA, const JFit& fB, const bool option)
  {
    for (iterator i = begin(); i != end(); ++i) {

      const int index = i->first.index;
        
      if (index == JQUALITY) {
        i->second.Fill(fA.getQ(),      fB.getQ(),      option);
      } else if (fA.hasW(index) && fB.hasW(index)) {
        i->second.Fill(fA.getW(index), fB.getW(index), option);
      }
    };
  }

      
  /**
   * Scale histograms.
   */
  void Scale()
  {
    for (iterator i = this->begin(); i != this->end(); ++i) {
      i->second.Scale();
    }
  }

      
  /**
   * Write histograms to file.
   *
   * \param  out              ROOT file
   */
  void Write(TFile& out)
  {
    for (iterator i = this->begin(); i != this->end(); ++i) {
      i->second.Write(out);
    }
  }

    
  /**
   * Write histograms to file.
   *
   * \param  file_name        file name
   */
  void Write(const char* file_name)
  {
    TFile out(file_name, "RECREATE");

    this->Write(out);

    out.Write();
    out.Close();
  }
};

#endif