JVariance1D.cc

Go to the documentation of this file.

 
#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <cmath>
 
#include "TROOT.h"
#include "TFile.h"
#include "TKey.h"
#include "TH1D.h"
#include "TH1.h"
#include "TString.h"
#include "TRegexp.h"
 
#include "JTools/JAbstractHistogram.hh"
#include "JGizmo/JRootObjectID.hh"
#include "JGizmo/JGizmoToolkit.hh"
 
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
 
namespace {
  /**
   * Additional options for formula.
   */
  static const char* const first_t = "first";
}
 
 
/**
 * \file
 * Auxiliary program to histogram bin-by-bin deviations of the contents of one (or more) 1D histogram(s).
 * The option <tt>-f</tt> corresponds to <tt><file name>:<object name></tt>.
 *
 * The formula (option <tt>-F <formula></tt>) refers to a ROOT TFormula.
 * The expression may contain member methods of the corresponding object.
 *
 * In case of multiple histograms, the formula is evaluated stand alone (i.e. without ROOT histogram).
 * If formula equals "first", the bin-by-bin deviations of the contents of the histograms are
 * evaluated with respect to the first histogram.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
 
  typedef JAbstractHistogram<Double_t> JHistogram_t;
  
  vector<JRootObjectID> inputFile;
  string                outputFile;
  bool                  reuse;
  JHistogram_t          X;
  TString               formula;
  bool                  reverse;
  int                   debug;
 
  try {
 
    JParser<> zap("Auxiliary program to histogram bin-by-bin deviations of a set of 1D histograms.");
 
    zap['f'] = make_field(inputFile,  "<input file>:<object name>");
    zap['o'] = make_field(outputFile, "ROOT file with histogram (possibly I/O, option -r)")       = "variance.root";
    zap['r'] = make_field(reuse,      "reuse histogram from existing output file");
    zap['x'] = make_field(X,          "histogram binning");
    zap['F'] = make_field(formula,    "ROOT TFormula (may contain method names of object)")       = "0";
    zap['R'] = make_field(reverse,    "reverse sign");
    zap['d'] = make_field(debug)          = 1;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
 
  vector<TH1*> listOfHistograms;
 
  for (vector<JRootObjectID>::const_iterator input = inputFile.begin(); input != inputFile.end(); ++input) {
 
    TH1* h1 = dynamic_cast<TH1*>(getObject(*input));
 
    if (h1 != NULL) {
      listOfHistograms.push_back(h1);
    }
  }
 
  if (listOfHistograms.empty()) {
    FATAL("No histograms." << endl);
  }
 
  if (formula == "") {
    FATAL("Empty formula." << endl);
  }
 
  TH1* h0 = NULL;
 
  if (reuse) {
    h0 = dynamic_cast<TH1*>(getObject(JRootObjectID(outputFile, "h0")));
  }
 
  if (h0 == NULL) {
    h0 = new TH1D("h0", NULL,
                  X.getNumberOfBins(), X.getLowerLimit(), X.getUpperLimit());
  }
 
 
  TH1* h1 = listOfHistograms[0];
 
  if (listOfHistograms.size() == 1) {
 
    const double y1 = getResult(formula, h1);
 
    DEBUG(h1->GetName() << ' ' << formula << ' ' << y1 << endl);
 
    for (Int_t i = 1; i <= h1->GetNbinsX(); ++i) {
 
      const Double_t yp = h1->GetBinContent(i); 
 
      h0->Fill(reverse ? y1 - yp : yp - y1);
    }
 
  } else {
 
    if (formula == first_t) {
 
      for (Int_t i = 1; i <= h1->GetNbinsX(); ++i) {
 
        const double y1 = h1->GetBinContent(i);
        
        for (vector<TH1*>::const_iterator p = listOfHistograms.begin(); ++p != listOfHistograms.end(); ) {
          
          const Double_t yp = (*p)->GetBinContent(i);
          
          h0->Fill(reverse ? y1 - yp : yp - y1);
        }
      }
 
    } else {
 
      const double y1 = getResult(formula);
 
      for (Int_t i = 1; i <= h1->GetNbinsX(); ++i) {
 
        for (vector<TH1*>::const_iterator p = listOfHistograms.begin(); p != listOfHistograms.end(); ++p) {
          
          const Double_t yp = (*p)->GetBinContent(i);
 
          h0->Fill(reverse ? y1 - yp : yp - y1);
        }
      }
    }
  }
 
 
  TFile out(outputFile.c_str(), "recreate");
    
  h0->Write();
    
  out.Write();
  out.Close();
}