UnbinnedLikelihoodFit.h

Go to the documentation of this file.

#ifndef __UnbinnedLikelihoodFit_h_
#define __UnbinnedLikelihoodFit_h_
#include <TObject.h>
#include <TF1.h>
#include <TVirtualFitter.h>
#include <cstdint>
 
// a class to perform a likelihood fit
// Author: Christophe Delaere
 
/* Example of a Landau fit:
 * ------------------------
 * UnbinnedLikelihoodFit myfit;
 * double x[4] = {89,110,70,80};
 * myfit.setData(4,x);
 * TF1* myfunction = new TF1("myLandau","TMath::Landau(x,[0],[1],1)",0,255);
 * myfunction->SetParameters(100,10);
 * myfit.setFunction(myfunction);
 * myfit.fit();
 * myfit.getFunction()->Print();
 * double MPV = myfit.getFunction()->GetParameter(0);
 * double MPVerror = myfit.getFunction()->GetParError(0);
 */
class UnbinnedLikelihoodFit : public TObject {
public:
  // Constructor and destructor
  UnbinnedLikelihoodFit();
  ~UnbinnedLikelihoodFit() override;
 
  // Set the data for the fit: a set of measurements
  void setData(uint32_t n, double* x);
 
  // Set the fit function
  void setFunction(TF1* f);
 
  // Set the fit options
  void setTolerance(double tol) { tolerance_ = tol; }
  void setMaxIterations(uint32_t n) { maxIterations_ = n; }
 
  // Fit
  int32_t fit(int32_t verbosity = -1);
  int32_t fit(int32_t n, double* x, int32_t verbosity = -1) {
    setData(n, x);
    return fit(verbosity);
  }
 
  // Results a retrieved via the TF1
  TF1* getFunction() const { return function_; }
  double getParameterValue(uint32_t i) { return function_ ? function_->GetParameter(i) : 0; }
  double getParameterError(uint32_t i) { return function_ ? function_->GetParError(i) : 0; }
  double* getParameterValues() { return function_ ? function_->GetParameters() : nullptr; }
  const double* getParameterErrors() { return function_ ? function_->GetParErrors() : nullptr; }
 
private:
  // input data
  uint32_t datasize_;
  double* x_;
  // the function
  TF1* function_;
  uint32_t nparameters_;
  // arguments for Minuit methods
  double arglist_[10];
  uint32_t maxIterations_;
  double tolerance_;
  // the minimizer (minuit)
  TVirtualFitter* min;
 
private:
  // LL function
  double logL(const double* x) const;
  // The function to minimize
  friend void UnbinnedLL(Int_t& npar, Double_t* gin, Double_t& val, Double_t* par, Int_t iflag);
};
 
#endif