Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooMinimizer.h
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * File: $Id$
5 * Authors: *
6 * WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
7 * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8 * AL, Alfio Lazzaro, INFN Milan, alfio.lazzaro@mi.infn.it *
9 * PB, Patrick Bos, NL eScience Center, p.bos@esciencecenter.nl *
10 * *
11 * *
12 * Redistribution and use in source and binary forms, *
13 * with or without modification, are permitted according to the terms *
14 * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
15 *****************************************************************************/
16
17#ifndef ROO_MINIMIZER
18#define ROO_MINIMIZER
19
23
24#include <Fit/Fitter.h>
25#include <TStopwatch.h>
26#include <TMatrixDSymfwd.h>
27
28#include <fstream>
29#include <memory> // shared_ptr, unique_ptr
30#include <string>
31#include <utility>
32#include <vector>
33
35class RooAbsReal;
36class RooFitResult;
37class RooArgList;
38class RooRealVar;
39class RooArgSet;
40class RooPlot;
41class RooDataSet;
42
43class RooMinimizer : public TObject {
44public:
45 /// Config argument to RooMinimizer ctor
46 struct Config {
47
48 Config() {}
49
50 std::function<void(double *)> gradFunc;
51
52 double recoverFromNaN = 10.; // RooAbsMinimizerFcn config
53 int printEvalErrors = 10; // RooAbsMinimizerFcn config
54 int doEEWall = 1; // RooAbsMinimizerFcn config
55 int offsetting = -1; // RooAbsMinimizerFcn config
56 const char *logf = nullptr; // RooAbsMinimizerFcn config
57
58 // RooAbsMinimizerFcn config that can only be set in ctor, 0 means no parallelization (default),
59 // -1 is parallelization with the number of workers controlled by RooFit::MultiProcess which
60 // defaults to the number of available processors, n means parallelization with n CPU's
61 int parallelize = 0;
62
63 // Experimental: RooAbsMinimizerFcn config that can only be set in ctor
64 // argument is ignored when parallelize is 0
66
67 // Experimental: RooAbsMinimizerFcn config that can only be set in ctor
68 // argument is ignored when parallelize is 0
70
71 bool verbose = false; // local config
72 bool profile = false; // local config
73 bool timingAnalysis = false; // local config
74 std::string minimizerType = ""; // local config
75 private:
77 };
78
79 explicit RooMinimizer(RooAbsReal &function, Config const &cfg = {});
80
81 ~RooMinimizer() override;
82
83 enum Strategy { Speed = 0, Balance = 1, Robustness = 2 };
84 enum PrintLevel { None = -1, Reduced = 0, Normal = 1, ExtraForProblem = 2, Maximum = 3 };
85
86 // Setters on _theFitter
87 void setStrategy(int strat);
88 void setErrorLevel(double level);
89 void setEps(double eps);
90 void setMaxIterations(int n);
91 void setMaxFunctionCalls(int n);
92 void setPrintLevel(int newLevel);
93
94 // Setters on _fcn
95 void optimizeConst(int flag);
96 void setEvalErrorWall(bool flag) { _cfg.doEEWall = flag; }
97 void setRecoverFromNaNStrength(double strength);
98 void setOffsetting(bool flag);
99 void setPrintEvalErrors(int numEvalErrors) { _cfg.printEvalErrors = numEvalErrors; }
100 void setVerbose(bool flag = true) { _cfg.verbose = flag; }
101 bool setLogFile(const char *logf = nullptr);
102
103 int migrad();
104 int hesse();
105 int minos();
106 int minos(const RooArgSet &minosParamList);
107 int seek();
108 int simplex();
109 int improve();
110
111 int minimize(const char *type, const char *alg = nullptr);
112
113 RooFitResult *save(const char *name = nullptr, const char *title = nullptr);
114 RooPlot *contour(RooRealVar &var1, RooRealVar &var2, double n1 = 1.0, double n2 = 2.0, double n3 = 0.0,
115 double n4 = 0.0, double n5 = 0.0, double n6 = 0.0, unsigned int npoints = 50);
116
117 void setProfile(bool flag = true) { _cfg.profile = flag; }
118 /// Enable or disable the logging of function evaluations to a RooDataSet.
119 /// \see RooMinimizer::getLogDataSet().
120 /// param[in] flag Boolean flag to disable or enable the functionality.
121 void setLoggingToDataSet(bool flag = true) { _loggingToDataSet = flag; }
122
123 /// If logging of function evaluations to a RooDataSet is enabled, returns a
124 /// pointer to a dataset with one row per evaluation of the RooAbsReal passed
125 /// to the minimizer. As columns, there are all floating parameters and the
126 /// values they had for that evaluation.
127 /// \see RooMinimizer::setLoggingToDataSet(bool).
128 RooDataSet *getLogDataSet() const { return _logDataSet.get(); }
129
130 static int getPrintLevel();
131
132 void setMinimizerType(std::string const &type);
133 std::string const &minimizerType() const { return _cfg.minimizerType; }
134
135 static void cleanup();
136 static RooFitResult *lastMinuitFit();
137 static RooFitResult *lastMinuitFit(const RooArgList &varList);
138
139 void saveStatus(const char *label, int status)
140 {
141 _statusHistory.push_back(std::pair<std::string, int>(label, status));
142 }
143
144 int evalCounter() const;
145 void zeroEvalCount();
146
148 const ROOT::Fit::Fitter *fitter() const;
149
151
152 int getNPar() const;
153
154 void applyCovarianceMatrix(TMatrixDSym const &V);
155
156private:
157 friend class RooAbsMinimizerFcn;
158 friend class RooMinimizerFcn;
159
160 std::unique_ptr<RooAbsReal::EvalErrorContext> makeEvalErrorContext() const;
161
163
164 void profileStart();
165 void profileStop();
166
167 std::ofstream *logfile();
168 double &maxFCN();
169
170 bool fitFcn() const;
171
172 // constructor helper functions
174 void initMinimizerFcnDependentPart(double defaultErrorLevel);
175
176 int _status = -99;
177 bool _profileStart = false;
178 bool _loggingToDataSet = false;
179
182
183 std::unique_ptr<TMatrixDSym> _extV;
184
185 std::unique_ptr<RooAbsMinimizerFcn> _fcn;
186
187 static std::unique_ptr<ROOT::Fit::Fitter> _theFitter;
188
189 std::vector<std::pair<std::string, int>> _statusHistory;
190
191 std::unique_ptr<RooDataSet> _logDataSet;
192
193 RooMinimizer::Config _cfg; // local config object
194
195 ClassDefOverride(RooMinimizer, 0) // RooFit interface to ROOT::Fit::Fitter
196};
197
198#endif
#define ClassDefOverride(name, id)
Definition Rtypes.h:341
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
char name[80]
Definition TGX11.cxx:110
Fitter class, entry point for performing all type of fits.
Definition Fitter.h:77
Documentation for the abstract class IBaseFunctionMultiDim.
Definition IFunction.h:61
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition RooAbsReal.h:61
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition RooArgList.h:22
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition RooArgSet.h:55
RooDataSet is a container class to hold unbinned data.
Definition RooDataSet.h:57
RooFitResult is a container class to hold the input and output of a PDF fit to a dataset.
RooMinimizerFcn is an interface to the ROOT::Math::IBaseFunctionMultiDim, a function that ROOT's mini...
RooMinimizer is a wrapper class around ROOT::Fit:Fitter that provides a seamless interface between th...
void setRecoverFromNaNStrength(double strength)
Try to recover from invalid function values.
static int getPrintLevel()
Get the MINUIT internal printing level.
void optimizeConst(int flag)
If flag is true, perform constant term optimization on function being minimized.
void initMinimizerFirstPart()
Initialize the part of the minimizer that is independent of the function to be minimized.
std::ofstream * logfile()
int simplex()
Execute SIMPLEX.
std::unique_ptr< TMatrixDSym > _extV
void setMinimizerType(std::string const &type)
Choose the minimizer algorithm.
std::vector< std::pair< std::string, int > > _statusHistory
std::unique_ptr< RooDataSet > _logDataSet
void profileStart()
Start profiling timer.
void setProfile(bool flag=true)
RooPlot * contour(RooRealVar &var1, RooRealVar &var2, double n1=1.0, double n2=2.0, double n3=0.0, double n4=0.0, double n5=0.0, double n6=0.0, unsigned int npoints=50)
Create and draw a TH2 with the error contours in the parameters var1 and var2.
bool setLogFile(const char *logf=nullptr)
void initMinimizerFcnDependentPart(double defaultErrorLevel)
Initialize the part of the minimizer that is dependent on the function to be minimized.
void setLoggingToDataSet(bool flag=true)
Enable or disable the logging of function evaluations to a RooDataSet.
void profileStop()
Stop profiling timer and report results of last session.
int minos()
Execute MINOS.
double & maxFCN()
int hesse()
Execute HESSE.
RooFitResult * save(const char *name=nullptr, const char *title=nullptr)
Save and return a RooFitResult snapshot of current minimizer status.
void setErrorLevel(double level)
Set the level for MINUIT error analysis to the given value.
static std::unique_ptr< ROOT::Fit::Fitter > _theFitter
void setEvalErrorWall(bool flag)
int migrad()
Execute MIGRAD.
int seek()
Execute SEEK.
void setEps(double eps)
Change MINUIT epsilon.
void setPrintLevel(int newLevel)
Change the MINUIT internal printing level.
std::string const & minimizerType() const
static RooFitResult * lastMinuitFit()
int improve()
Execute IMPROVE.
bool _loggingToDataSet
static void cleanup()
Cleanup method called by atexit handler installed by RooSentinel to delete all global heap objects wh...
void setOffsetting(bool flag)
Enable internal likelihood offsetting for enhanced numeric precision.
TStopwatch _timer
RooMinimizer::Config _cfg
RooDataSet * getLogDataSet() const
If logging of function evaluations to a RooDataSet is enabled, returns a pointer to a dataset with on...
bool fitFcn() const
void saveStatus(const char *label, int status)
~RooMinimizer() override
Destructor.
int minimize(const char *type, const char *alg=nullptr)
Minimise the function passed in the constructor.
ROOT::Math::IMultiGenFunction * getMultiGenFcn() const
void setStrategy(int strat)
Change MINUIT strategy to istrat.
std::unique_ptr< RooAbsReal::EvalErrorContext > makeEvalErrorContext() const
void setVerbose(bool flag=true)
void setPrintEvalErrors(int numEvalErrors)
ROOT::Fit::Fitter * fitter()
Return underlying ROOT fitter object.
void setMaxFunctionCalls(int n)
Change maximum number of likelihood function calss from MINUIT (RooMinimizer default 500 * #parameter...
int evalCounter() const
TStopwatch _cumulTimer
int getNPar() const
void setMaxIterations(int n)
Change maximum number of MINUIT iterations (RooMinimizer default 500 * #parameters)
void addParamsToProcessTimer()
Add parameters in metadata field to process timer.
std::unique_ptr< RooAbsMinimizerFcn > _fcn
void applyCovarianceMatrix(TMatrixDSym const &V)
Apply results of given external covariance matrix.
A RooPlot is a plot frame and a container for graphics objects within that frame.
Definition RooPlot.h:43
RooRealVar represents a variable that can be changed from the outside.
Definition RooRealVar.h:40
Mother of all ROOT objects.
Definition TObject.h:41
Stopwatch class.
Definition TStopwatch.h:28
const Int_t n
Definition legend1.C:16
Config argument to RooMinimizer ctor.
std::function< void(double *)> gradFunc
std::string minimizerType