JRootfitToGauss2D.cc File Reference

Program to test JRootfit algorithm. More...

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

Go to the source code of this file.

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

Detailed Description

Program to test JRootfit algorithm.

Author

mdejong

Definition in file JRootfitToGauss2D.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 30 of file JRootfitToGauss2D.cc.

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