JFit2D.cc File Reference

#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include "TROOT.h"
#include "TFile.h"
#include "TKey.h"
#include "TH2.h"
#include "TGraph2D.h"
#include "TProfile.h"
#include "TF12.h"
#include "TString.h"
#include "TRegexp.h"
#include "JLang/JType.hh"
#include "JLang/JTypeList.hh"
#include "JLang/JToken.hh"
#include "JTools/JTuple.hh"
#include "JGizmo/JRootObjectID.hh"
#include "JGizmo/JGizmoToolkit.hh"
#include "Jeep/JPrint.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

General purpose fit program using ROOT. The option -f corresponds to <file name>:<object name>.

The expressions for the fit function, start and fixed values should comply with ROOT class TFormula.

In the expressions of the start and fixed values, names of member methods of corresponding class of the fit object may appear, such as TH1::GetMaximum, TH1::GetRMS, etc., e.g:

     -F "[0]*exp(-0.5*x*x/([1]*[1])*exp(-0.5*y*y/([2]*[2])"
     -@ "p0 = GetMaximum; p1 = 2*GetRMS"
     -= "p2 = 0"

The result of the formulas for the start and fixed values will be evaluated for each histogram separately.

Author

mdejong

Definition in file JFit2D.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 92 of file JFit2D.cc.

{
  using namespace std;
  using namespace JPP;
 
  typedef JLANG::JToken<';'>  JToken_t;
  //typedef JRange<double>      JRange_t;
 
  vector<JRootObjectID>    inputFile;
  string                   outputFile;
  string                   formula;
  vector<JToken_t>         startValues;
  vector<JToken_t>         fixedValues;
  //JRange_t                 X;
  //JRange_t                 Y;
  string                   option;
  int                      debug;
 
  try {
 
    JParser<> zap("General purpose fit program using ROOT.");
 
    zap['f'] = make_field(inputFile,   "<input file>:<object name>");
    zap['o'] = make_field(outputFile,  "ROOT file with fit results")         = "fit.root";
    zap['F'] = make_field(formula,     "fit formula, e.g: \"[0]+[1]*x\"");
    zap['@'] = make_field(startValues, "start values, e.g: \"p0 = GetMaximum;\"");
    zap['='] = make_field(fixedValues, "fixed values, e.g: \"p0 = GetMaximum;\"");
    //zap['x'] = make_field(X,           "abscissa range")                     = JRange_t();
    //zap['y'] = make_field(Y,           "abscissa range")                     = JRange_t();
    zap['O'] = make_field(option,      "Fit option")                         = "";
    zap['d'] = make_field(debug)        = 1;
    
    zap['='] = JPARSER::initialised();
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
 
  if (option.find('O') == string::npos) { option += "O"; }
  //if (option.find('N') == string::npos) { option += "N"; }
  if (debug ==  0 && option.find('Q') == string::npos) { option += "Q"; }
 
 
  TFile out(outputFile.c_str(), "recreate");
 
 
  TF2* fcn = new TF2("user", formula.c_str());
 
  fcn->SetNpx(1000);
 
  if (fcn->IsZombie()) {
    FATAL("Function: " << formula << " is zombie." << endl);
  }
 
  for (vector<JRootObjectID>::const_iterator input = inputFile.begin(); input != inputFile.end(); ++input) {
 
    DEBUG("Input: " << *input << endl);
 
    TDirectory* dir = getDirectory(*input);
 
    if (dir == NULL) {
      ERROR("File: " << input->getFullFilename() << " not opened." << endl);
      continue;
    }
 
    const TRegexp regexp(input->getObjectName());
 
    TIter iter(dir->GetListOfKeys());
 
    for (TKey* key; (key = (TKey*) iter.Next()) != NULL; ) {
       
      const TString tag(key->GetName());
 
      DEBUG("Key: " << tag << " match = " << tag.Contains(regexp) << endl);
 
      // option match
      
      if (tag.Contains(regexp)) {
        
        TObject* object = key->ReadObj();
      
 
        // set fit parameters
 
        try {
 
          for (vector<JToken_t>::const_iterator j = startValues.begin(); j != startValues.end(); ++j) {
            fcn->SetParameter(getParameter(*j), getValue(*j,object));
          }
          
          for (vector<JToken_t>::const_iterator j = fixedValues.begin(); j != fixedValues.end(); ++j) {
            fcn->FixParameter(getParameter(*j), getValue(*j,object));
          }
        }
        catch(JLANG::JParseError& error) {
          FATAL(error << endl);
        }
 
        DEBUG("Start values " << object->GetName() << endl);
 
        for (int j = 0; j != fcn->GetNpar(); ++j) {
          DEBUG(left << setw(12) << fcn->GetParName  (j) << ' ' << 
                SCIENTIFIC(12,5) << fcn->GetParameter(j) << endl);
        }
 
          
        // execute fit
 
        JFit fit(*object);
 
        for_each(fit, JType<JTYPELIST<TH2, TGraph2D>::typelist>(), JPP::make_tuple(fcn, option));
  
 
        if (fit.result != -1) {
 
          // output fit results
            
          NOTICE("Fit values  " << object->GetName() << endl);
          NOTICE("Fit formula " << formula           << endl);
            
          for (int j = 0; j != fcn->GetNpar(); ++j) {
            NOTICE(left << setw(12) << fcn->GetParName  (j) << ' '     << 
                   SCIENTIFIC(12,5) << fcn->GetParameter(j) << " +/- " << 
                   SCIENTIFIC(12,5) << fcn->GetParError (j) << endl);
          }
 
        } else {
 
          WARNING("Object: not compatible with ROOT Fit." << endl);
        }
 
        out.cd();
        
        object->Write();
        fcn   ->Write();
      }
    }
 
    dir->Close();
  }
 
  out.Write();
  out.Close();
}