JVariance1D.cc File Reference

Auxiliary program to histogram bin-by-bin deviations of the contents of one (or more) 1D histogram(s). More...

#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"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Detailed Description

Auxiliary program to histogram bin-by-bin deviations of the contents of one (or more) 1D histogram(s).

The option -f corresponds to <file name>:<object name>.

The formula (option -F <formula>) 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

Definition in file JVariance1D.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 44 of file JVariance1D.cc.

{
  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();
}