JRootfitToGauss2D.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <type_traits>
#include <chrono>
 
#include "TROOT.h"
#include "TFile.h"
#include "TH2D.h"
 
#include "JROOT/JRootToolkit.hh"
#include "JROOT/JRootTestkit.hh"
#include "JROOT/JRootfit.hh"
 
#include "JMath/JMathlib2D.hh"
 
#include "JLang/JManip.hh"
 
#include "Jeep/JProperties.hh"
#include "Jeep/JParser.hh"
 
 
/**
 * \file
 *
 * Program to test JRootfit algorithm.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
 
  const char* const count_t = "count";
  const char* const value_t = "value";
 
  struct {
    double signal     = 100;
    double background =   5;
    double center     = 0.0;
    double sigma      = 1.0;
  } parameters;
 
  string     inputFile;
  string     outputFile;
  range_type X;
  range_type Y;
  size_t     N;
  string     option;
  bool       writeFits;
  UInt_t     seed;
  int        debug;
 
  try { 
 
    JProperties properties;
 
    properties.insert(gmake_property(parameters.signal));
    properties.insert(gmake_property(parameters.background));
    properties.insert(gmake_property(parameters.center));
    properties.insert(gmake_property(parameters.sigma));
    
    JParser<> zap("Program to test JRootfit algorithm.");
 
    zap['f'] = make_field(inputFile)           = "";
    zap['o'] = make_field(outputFile);
    zap['@'] = make_field(properties)          = JPARSER::initialised();
    zap['x'] = make_field(X)                   = range_type();
    zap['y'] = make_field(Y)                   = range_type();
    zap['n'] = make_field(N)                   = 0;
    zap['O'] = make_field(option)              = count_t, value_t;
    zap['w'] = make_field(writeFits);
    zap['S'] = make_field(seed)                = 0;
    zap['d'] = make_field(debug)               = 1;
    
    zap(argc, argv);
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }
 
 
  gRandom->SetSeed(seed);
 
  const size_t ls   = 2;
 
  const size_t nx   = 20   * ls;
  const double xmin = -5.0 * ls;
  const double xmax = +5.0 * ls;
 
  const size_t ny   = 20   * ls;
  const double ymin = -5.0 * ls;
  const double ymax = +5.0 * ls;
 
  TH2D* h2 = NULL;
 
  if (inputFile == "") {
 
    h2 = new TH2D("h2", NULL, nx, xmin, xmax, ny, ymin, ymax);
 
    h2->Sumw2();
 
    auto f2 = (JGauss2X<1>(parameters.center, parameters.sigma) * 
               JGauss2Y<2>(parameters.center, parameters.sigma) * 
               JP0<1>(parameters.signal)                            +
               JP0<2>(parameters.background));
    
    if (N == 0)
      FillRandom(h2, f2);
    else
      FillRandom(h2, f2, N);
 
  } else {
 
    TFile* in = TFile::Open(inputFile.c_str(), "exist");
 
    in->GetObject("h2", h2);
  }
 
 
  // determine start values from data
 
  const double x0         = h2->GetMean(1);
  const double y0         = h2->GetMean(2);
  const double xs         = h2->GetStdDev(1) * 0.33;
  const double ys         = h2->GetStdDev(2) * 0.33;
  const double signal     = h2->GetMaximum();
  const double background = h2->GetMinimum() + 0.10;
 
  // fit
 
  auto f2 = (JGauss2X<1>(x0, xs) * 
             JGauss2Y<2>(y0, ys) * 
             JP0<1>(signal))  +  Exp(JP0<2>(log(background)));
 
  //auto f2 = JGauss2D<1>(sqrt(x0*y0), sqrt(xs*ys)) * JP0<1>(signal)  +  JP0<2>(background);
 
  typedef decltype(f2)  function_type;
 
  JRootfit<function_type>::debug = debug;
 
  for (size_t i = 0; i != getNumberOfParameters<function_type>(); ++i) {
    cout << setw(2)     << i                   << ' ' 
         << FIXED(15,9) << getParameter(f2, i) << endl;
  }
 
  {
    const chrono::steady_clock::time_point t0 = chrono::steady_clock::now();
 
    const auto result = (option == count_t ?
                         (writeFits ? Fit<m_count>(h2, f2, {}, X, Y) : Fit<m_count>(*h2, f2, {}, X, Y)) :
                         (writeFits ? Fit<m_value>(h2, f2, {}, X, Y) : Fit<m_value>(*h2, f2, {}, X, Y)));
 
    const chrono::steady_clock::time_point t1 = chrono::steady_clock::now();
 
    cout << "chi2/NDF " << FIXED(7,3) << result.getChi2() << "/" << result.getNDF() << endl;
    cout << "Number of iterations " << result.numberOfIterations << endl;
    cout << "Elapsed time [us] " << setw(8) << chrono::duration_cast<chrono::microseconds>(t1 - t0).count() << endl;
 
    for (size_t i = 0; i != result.getNumberOfParameters(); ++i) {
      cout << setw(2)     << i                  << ' ' 
           << FIXED(15,9) << result.getValue(i) << " +/- "
           << FIXED(15,9) << result.getError(i) << endl;
    }
  }
 
  TFile out(outputFile.c_str(), "recreate");
 
  out << *h2;
 
  out.Write();
  out.Close();
}