JFit2D.cc

Go to the documentation of this file.

#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/JRange.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"
 
 
namespace {
 
  using namespace std;
  using namespace JPP;
 
  /**
   * Auxiliary class for ROOT fit.
   */
  struct JFit {
    /**
     * Constructor.
     *
     * \param  object      object
     */
    JFit(TObject& object) :
      object(object)
    {}
 
 
    /**
     * Attempt fit for given data type.
     *
     * \param  type        data type
     * \param  tuple       argument data
     */
    template<class T>
    void operator()(const JType<T>& type, const JTuple<JTYPELIST<TF2*, string>::typelist>& tuple) 
    {
      try {
        result = dynamic_cast<T&>(object).Fit(tuple.first, tuple.second.c_str(), "same");
      }
      catch(const std::exception&) {}
    }
 
 
    TObject&      object;
    TFitResultPtr result;
  };
}
 
 
/**
 * \file
 * General purpose fit program using ROOT.
 * The option <tt>-f</tt> corresponds to <tt><file name>:<object name></tt>.
 *
 * 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:
 * <pre>
 *      -F "[0]*exp(-0.5*x*x/([1]*[1])*exp(-0.5*y*y/([2]*[2])"
 *      -@ "p0 = GetMaximum; p1 = 2*GetRMS"
 *      -= "p2 = 0"
 * </pre>
 * The result of the formulas for the start and fixed values will be evaluated
 * for each histogram separately.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  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();
}