58#ifdef ROOFIT_MULTIPROCESS
78class FreezeDisconnectedParametersRAII {
81 : _minimizer{minimizer}, _frozen{fcn.freezeDisconnectedParameters()}
83 if (!_frozen.empty()) {
84 oocoutI(_minimizer, Minimization) <<
"Freezing disconnected parameters: " << _frozen << std::endl;
87 ~FreezeDisconnectedParametersRAII()
89 if (!_frozen.empty()) {
90 oocoutI(_minimizer, Minimization) <<
"Unfreezing disconnected parameters: " << _frozen << std::endl;
100std::vector<std::vector<int>> generateOrthogonalCombinations(
const std::vector<int> &maxValues)
102 std::vector<std::vector<int>> combos;
103 std::vector<int> base(maxValues.size(), 0);
104 combos.push_back(base);
105 for (
size_t i = 0; i < maxValues.size(); ++i) {
106 for (
int v = 1;
v < maxValues[i]; ++
v) {
107 std::vector<int> tmp = base;
109 combos.push_back(tmp);
115void reorderCombinations(std::vector<std::vector<int>> &combos,
const std::vector<int> &max,
116 const std::vector<int> &base)
118 for (
auto &combo : combos) {
119 for (
size_t i = 0; i < combo.size(); ++i) {
120 combo[i] = (combo[i] + base[i]) % max[i];
133std::unique_ptr<ChangeOperModeRAII> setOperModesDirty(
RooAbsReal &function)
135 if (
auto *wrapper =
dynamic_cast<RooFit::Experimental::RooEvaluatorWrapper *
>(&function)) {
160 if (nll_real !=
nullptr) {
163#ifdef ROOFIT_MULTIPROCESS
167 coutI(InputArguments) <<
"Modular likelihood detected and likelihood parallelization requested, "
168 <<
"also setting parallel gradient calculation mode." << std::endl;
177 _fcn = std::make_unique<RooFit::TestStatistics::MinuitFcnGrad>(
180 static_cast<RooFit::TestStatistics::LikelihoodMode>(int(_cfg.enableParallelDescent))},
183 throw std::logic_error(
184 "Parallel minimization requested, but multiprocessing is not supported on this platform");
187 coutW(InputArguments)
188 <<
"Requested modular likelihood without gradient parallelization, some features such as offsetting "
189 <<
"may not work yet. Non-modular likelihoods are more reliable without parallelization." << std::endl;
195 _fcn = std::make_unique<RooMinimizerFcn>(&function,
this);
199 throw std::logic_error(
"In RooMinimizer constructor: Selected likelihood evaluation but a "
200 "non-modular likelihood was given. Please supply ModularL(true) as an "
201 "argument to createNLL for modular likelihoods to use likelihood "
202 "or gradient parallelization.");
204 _fcn = std::make_unique<RooMinimizerFcn>(&function,
this);
212 RooSentinel::activate();
320 std::stringstream ss;
321 ss <<
"In RooMinimizer::setMinimizerType: only Minuit2 is supported when not using classic function mode!";
323 ss <<
"\nPlease set it as your default minimizer via "
324 "ROOT::Math::MinimizerOptions::SetDefaultMinimizer(\"Minuit2\").";
326 throw std::invalid_argument(ss.str());
337 coutE(Minimization) <<
"RooMinimizer: all function calls during minimization gave invalid NLL values!"
354#ifdef ROOFIT_MULTIPROCESS
357 throw std::logic_error(
"ProcessTimer requested, but multiprocessing is not supported on this platform.");
388 return exec(
"migrad",
"MIGRAD");
393 FreezeDisconnectedParametersRAII freeze(
this, *
_fcn);
401 if (algoName ==
"hesse") {
405 }
else if (algoName ==
"minos") {
432 coutW(Minimization) <<
"RooMinimizer::hesse: Error, run Migrad before Hesse!" << std::endl;
437 return exec(
"hesse",
"HESSE");
449 coutW(Minimization) <<
"RooMinimizer::minos: Error, run Migrad before Minos!" << std::endl;
454 return exec(
"minos",
"MINOS");
466 coutW(Minimization) <<
"RooMinimizer::minos: Error, run Migrad before Minos!" << std::endl;
468 }
else if (!minosParamList.
empty()) {
469 FreezeDisconnectedParametersRAII freeze(
this, *
_fcn);
477 std::vector<unsigned int> paramInd;
483 paramInd.push_back(
index);
487 if (!paramInd.empty()) {
515 return exec(
"seek",
"SEEK");
526 return exec(
"simplex",
"SIMPLEX");
537 return exec(
"migradimproved",
"IMPROVE");
574 coutW(Minimization) <<
"RooMinimizer::save: Error, run minimization before!" << std::endl;
578 std::string
name = userName ? std::string{userName} :
_fcn->getFunctionName();
579 std::string title = userTitle ? std::string{userTitle} :
_fcn->getFunctionTitle();
580 auto fitRes = std::make_unique<RooFitResult>(
name.c_str(), title.c_str());
582 fitRes->setConstParList(
_fcn->constParams());
584 fitRes->setNumInvalidNLL(
_fcn->GetNumInvalidNLL());
587 fitRes->setCovQual(
_minimizer->CovMatrixStatus());
588 fitRes->setMinNLL(
_result->fVal -
_fcn->getOffset());
591 fitRes->setInitParList(
_fcn->initFloatParams());
592 fitRes->setFinalParList(
_fcn->floatParams());
597 fitRes->setCovarianceMatrix(*
_extV);
608double covMatrix(std::vector<double>
const &covMat,
unsigned int i,
unsigned int j)
612 return j < i ? covMat[j + i * (i + 1) / 2] : covMat[i + j * (j + 1) / 2];
616double correlation(std::vector<double>
const &covMat,
unsigned int i,
unsigned int j)
620 double tmp = covMatrix(covMat, i, i) * covMatrix(covMat, j, j);
621 return tmp > 0 ? covMatrix(covMat, i, j) / std::sqrt(tmp) : 0;
628 const std::size_t nParams =
_fcn->getNDim();
631 std::vector<double> globalCC =
_minimizer->GlobalCC();
632 globalCC.resize(nParams);
633 for (std::size_t ic = 0; ic < nParams; ic++) {
634 for (std::size_t ii = 0; ii < nParams; ii++) {
635 corrs(ic, ii) = correlation(
_result->fCovMatrix, ic, ii);
636 covs(ic, ii) = covMatrix(
_result->fCovMatrix, ic, ii);
659 double n5,
double n6,
unsigned int npoints)
666 int index1 = params.
index(&var1);
668 coutE(Minimization) <<
"RooMinimizer::contour(" <<
GetName() <<
") ERROR: " << var1.
GetName()
669 <<
" is not a floating parameter of " <<
_fcn->getFunctionName() << std::endl;
673 int index2 = params.
index(&var2);
675 coutE(Minimization) <<
"RooMinimizer::contour(" <<
GetName() <<
") ERROR: " << var2.
GetName()
676 <<
" is not a floating parameter of PDF " <<
_fcn->getFunctionName() << std::endl;
690 coutW(Minimization) <<
"RooMinimizer::contour: Error, run Migrad before contours!" << std::endl;
705 auto operModeRAII = setOperModesDirty(
_function);
706 for (
int ic = 0; ic < 6; ic++) {
713 std::vector<double> xcoor(npoints + 1);
714 std::vector<double> ycoor(npoints + 1);
715 bool ret =
_minimizer->Contour(index1, index2, npoints, xcoor.data(), ycoor.data());
718 coutE(Minimization) <<
"RooMinimizer::contour(" <<
GetName()
719 <<
") ERROR: MINUIT did not return a contour graph for n=" <<
n[ic] << std::endl;
721 xcoor[npoints] = xcoor[0];
722 ycoor[npoints] = ycoor[0];
723 TGraph *graph =
new TGraph(npoints + 1, xcoor.data(), ycoor.data());
725 std::stringstream
name;
726 name <<
"contour_" <<
_fcn->getFunctionName() <<
"_n" <<
n[ic];
750#ifdef ROOFIT_MULTIPROCESS
752 std::vector<std::string> parameter_names;
754 parameter_names.push_back(parameter->GetName());
756 coutI(Minimization) <<
"parameter name: " << parameter_names.back() << std::endl;
761 coutI(Minimization) <<
"Not adding parameters to processtimer because multiprocessing is not enabled." << std::endl;
785 coutI(Minimization) <<
"Command timer: ";
787 coutI(Minimization) <<
"Session timer: ";
809 oocoutE(
nullptr, InputArguments) <<
"RooMinimizer::save: Error, run minimization before!" << std::endl;
813 auto res = std::make_unique<RooFitResult>(
"lastMinuitFit",
"Last MINUIT fit");
822 for (
unsigned int i = 0; i <
_fcn->getNDim(); ++i) {
825 bool isConst(
_result->isParameterFixed(i));
829 double xerr =
_result->error(i);
830 double xval =
_result->fParams[i];
832 std::unique_ptr<RooRealVar> var;
834 if ((xlo < xhi) && !isConst) {
835 var = std::make_unique<RooRealVar>(varName, varName, xval, xlo, xhi);
837 var = std::make_unique<RooRealVar>(varName, varName, xval);
839 var->setConstant(isConst);
849 res->setConstParList(constPars);
850 res->setInitParList(floatPars);
851 res->setFinalParList(floatPars);
854 res->setCovQual(
_minimizer->CovMatrixStatus());
855 res->setStatus(
_result->fStatus);
880 return _fcn->evalCounter();
884 _fcn->zeroEvalCount();
889 return _fcn->getNDim();
894 return _fcn->GetLogFile();
898 return _fcn->GetMaxFCN();
902 return _fcn->getOffset();
912 return std::make_unique<RooAbsReal::EvalErrorContext>(
m);
920 auto operModeRAII = setOperModesDirty(
_function);
925 coutE(Minimization) <<
"RooMinimizer::fitFCN(): FCN function has zero parameters" << std::endl;
934 for (
auto arg :
_fcn->allParams()) {
935 if (arg->isCategory() && !arg->isConstant())
936 floatingCats.
add(*arg);
939 std::vector<RooCategory *> pdfIndices;
940 for (
auto *arg : floatingCats) {
942 pdfIndices.push_back(cat);
945 const size_t nPdfs = pdfIndices.size();
949 for (
auto arg :
_fcn->allParams()) {
950 if (!arg->isCategory() && !arg->isConstant())
951 floatReals.
add(*arg);
955 coutI(Minimization) <<
"[fitFCN] No discrete parameters, performing continuous minimization only" << std::endl;
956 FreezeDisconnectedParametersRAII freeze(
this, *
_fcn);
959 _result = std::make_unique<FitResult>();
968 std::vector<int> maxIndices;
969 maxIndices.reserve(pdfIndices.size());
970 for (
auto *cat : pdfIndices)
971 maxIndices.push_back(cat->size());
973 std::set<std::vector<int>> tried;
974 std::map<std::vector<int>,
double> nllMap;
975 std::vector<int> bestIndices(nPdfs, 0);
976 double bestNLL = 1e30;
978 bool improved =
true;
981 auto combos = generateOrthogonalCombinations(maxIndices);
982 reorderCombinations(combos, maxIndices, bestIndices);
984 for (
const auto &combo : combos) {
985 if (tried.count(combo))
988 for (
size_t i = 0; i < nPdfs; ++i)
989 pdfIndices[i]->setIndex(combo[i]);
992 std::vector<bool> wasConst(nPdfs);
993 for (
size_t i = 0; i < nPdfs; ++i) {
994 wasConst[i] = pdfIndices[i]->isConstant();
995 pdfIndices[i]->setConstant(
true);
997 FreezeDisconnectedParametersRAII freeze(
this, *
_fcn);
1000 for (
size_t i = 0; i < nPdfs; ++i)
1001 pdfIndices[i]->setConstant(wasConst[i]);
1004 tried.insert(combo);
1005 nllMap[combo] = val;
1007 if (val < bestNLL) {
1009 bestIndices = combo;
1015 for (
size_t i = 0; i < nPdfs; ++i) {
1016 pdfIndices[i]->setIndex(bestIndices[i]);
1019 FreezeDisconnectedParametersRAII freeze(
this, *
_fcn);
1022 coutI(Minimization) <<
"All NLL Values per Combination:" << std::endl;
1023 for (
const auto &entry : nllMap) {
1024 const auto &combo = entry.first;
1025 double val = entry.second;
1027 std::stringstream ss;
1029 for (
size_t i = 0; i < combo.size(); ++i) {
1031 if (i + 1 < combo.size())
1034 ss <<
"], NLL: " << val;
1036 coutI(Minimization) << ss.str() << std::endl;
1039 std::stringstream ssBest;
1040 ssBest <<
"DP Best Indices: [";
1041 for (
size_t i = 0; i < bestIndices.size(); ++i) {
1042 ssBest << bestIndices[i];
1043 if (i + 1 < bestIndices.size())
1046 ssBest <<
"], NLL = " << bestNLL;
1048 coutI(Minimization) << ssBest.str() << std::endl;
1051 _result = std::make_unique<FitResult>();
1062 auto operModeRAII = setOperModesDirty(
_function);
1066 coutE(Minimization) <<
"RooMinimizer::calculateHessErrors() Error re-initializing the minimizer" << std::endl;
1073 coutE(Minimization) <<
"RooMinimizer::calculateHessErrors() Error when calculating Hessian" << std::endl;
1098 auto operModeRAII = setOperModesDirty(
_function);
1102 coutE(Minimization) <<
"RooMinimizer::calculateHessErrors() Error re-initializing the minimizer" << std::endl;
1107 unsigned int n = (!ipars.empty()) ? ipars.size() :
_fcn->getNDim();
1115 if (iparNewMin > 0) {
1116 coutI(Minimization) <<
"RooMinimizer::calculateMinosErrors() Run again Minos for some parameters because a "
1117 "new Minimum has been found"
1121 for (
int i = 0; i < iparMax; ++i) {
1124 unsigned int index = (!ipars.empty()) ? ipars[i] : i;
1131 _result->fMinosErrors.emplace(
index, std::make_pair(elow, eup));
1135 iparMax = iparNewMin;
1137 }
while (iparNewMin > 0 && iter < 10);
1140 <<
"RooMinimizer::calculateMinosErrors() Minos error calculation failed for all the selected parameters"
1158 std::vector<double>
v;
1159 for (std::size_t i = 0; i <
_fcn->getNDim(); ++i) {
1176 if (canDifferentMinim) {
1177 std::string msg =
"Using now " + newMinimType;
1178 coutI(Minimization) <<
"RooMinimizer::updateMinimizerOptions(): " << msg << std::endl;
1181 std::string msg =
"Cannot change minimizer. Continue using " +
_result->fMinimType;
1182 coutW(Minimization) <<
"RooMinimizer::updateMinimizerOptions() " << msg << std::endl;
1201 for (
unsigned int i = 0; i <
_config.
NPar(); ++i) {
1212 fParams(fconfig.NPar()),
1213 fErrors(fconfig.NPar()),
1214 fMinimType(fconfig.MinimizerType())
1222 if ((
fMinimType.find(
"Fumili") == std::string::npos) && (
fMinimType.find(
"GSLMultiFit") == std::string::npos)) {
1228 for (
unsigned int i = 0; i < fconfig.
NPar(); ++i) {
1245 _result->fStatus = min.Status();
1246 _result->fCovStatus = min.CovMatrixStatus();
1247 _result->fVal = min.MinValue();
1252 const unsigned int npar = min.NDim();
1257 _result->fParams = std::vector<double>(min.X(), min.X() + npar);
1260 _result->fParams.resize(npar);
1261 for (
unsigned int i = 0; i < npar; ++i) {
1267 for (
unsigned int ipar = 0; ipar < npar; ++ipar) {
1269 _result->fFixedParams[ipar] =
true;
1277 if (min.Errors() !=
nullptr) {
1293 const std::size_t npar =
_result->fParams.size();
1297 _result->fVal = min.MinValue();
1299 _result->fStatus = min.Status();
1300 _result->fCovStatus = min.CovMatrixStatus();
1303 std::copy(min.X(), min.X() + npar,
_result->fParams.begin());
1305 if (min.Errors() !=
nullptr) {
1314 const std::size_t npar =
_result->fParams.size();
1316 _result->fErrors.resize(npar);
1317 std::copy(min.Errors(), min.Errors() + npar,
_result->fErrors.begin());
1319 if (
_result->fCovStatus != 0) {
1322 unsigned int r = npar * (npar + 1) / 2;
1325 for (
unsigned int i = 0; i < npar; ++i) {
1326 for (
unsigned int j = 0; j <= i; ++j)
1327 _result->fCovMatrix[
l++] = min.CovMatrix(i, j);
1337 auto itr = fMinosErrors.find(i);
1338 return (itr != fMinosErrors.end()) ? itr->second.first : error(i);
1345 auto itr = fMinosErrors.find(i);
1346 return (itr != fMinosErrors.end()) ? itr->second.second : error(i);
1351 return fFixedParams.find(ipar) != fFixedParams.end();
1356 const size_t nParams = fParams.size();
1358 for (std::size_t ic = 0; ic < nParams; ic++) {
1359 for (std::size_t ii = 0; ii < nParams; ii++) {
1360 covs(ic, ii) = covMatrix(fCovMatrix, ic, ii);
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 r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
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
Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::Pa...
const std::vector< unsigned int > & MinosParams() const
return vector of parameter indices for which the Minos Error will be computed
void SetMinimizer(const char *type, const char *algo=nullptr)
set minimizer type and algorithm
void SetMinosErrors(bool on=true)
set Minos errors computation to be performed after fitting
const std::string & MinimizerAlgoType() const
return type of minimizer algorithms
unsigned int NPar() const
number of parameters settings
std::string MinimizerName() const
return Minimizer full name (type / algorithm)
const std::vector< ROOT::Fit::ParameterSettings > & ParamsSettings() const
get the vector of parameter settings (const method)
ROOT::Math::Minimizer * CreateMinimizer()
create a new minimizer according to chosen configuration
const ParameterSettings & ParSettings(unsigned int i) const
get the parameter settings for the i-th parameter (const method)
ROOT::Math::MinimizerOptions & MinimizerOptions()
access to the minimizer control parameter (non const method)
Class, describing value, limits and step size of the parameters Provides functionality also to set/re...
bool IsFixed() const
check if is fixed
void SetValue(double val)
set the value
double LowerLimit() const
return lower limit value
void SetStepSize(double err)
set the step size
double Value() const
return parameter value
double StepSize() const
return step size
double UpperLimit() const
return upper limit value
void SetMaxFunctionCalls(unsigned int maxfcn)
set maximum of function calls
void SetStrategy(int stra)
set the strategy
void SetMaxIterations(unsigned int maxiter)
set maximum iterations (one iteration can have many function calls)
static const std::string & DefaultMinimizerType()
int PrintLevel() const
non-static methods for retrieving options
void SetErrorDef(double err)
set error def
void SetPrintLevel(int level)
set print level
void SetTolerance(double tol)
set the tolerance
Abstract Minimizer class, defining the interface for the various minimizer (like Minuit2,...
Common abstract base class for objects that represent a value and a "shape" in RooFit.
bool isConstant() const
Check if the "Constant" attribute is set.
RooAbsCollection * snapshot(bool deepCopy=true) const
Take a snap shot of current collection contents.
virtual bool add(const RooAbsArg &var, bool silent=false)
Add the specified argument to list.
Int_t index(const RooAbsArg *arg) const
Returns index of given arg, or -1 if arg is not in the collection.
void assign(const RooAbsCollection &other) const
Sets the value, cache and constant attribute of any argument in our set that also appears in the othe...
virtual bool addOwned(RooAbsArg &var, bool silent=false)
Add an argument and transfer the ownership to the collection.
RooAbsArg * find(const char *name) const
Find object with given name in list.
Abstract base class for objects that represent a real value and implements functionality common to al...
double getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
virtual double defaultErrorLevel() const
static void clearEvalErrorLog()
Clear the stack of evaluation error messages.
RooArgList is a container object that can hold multiple RooAbsArg objects.
RooAbsArg * at(Int_t idx) const
Return object at given index, or nullptr if index is out of range.
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Object to represent discrete states.
RooFitResult is a container class to hold the input and output of a PDF fit to a dataset.
void fillCorrMatrix(const std::vector< double > &globalCC, const TMatrixDSym &corrs, const TMatrixDSym &covs)
Function called by RooMinimizer.
static void setDefaultNWorkers(unsigned int N_workers)
static void setTimingAnalysis(bool timingAnalysis)
static void add_metadata(json data)
RooAbsReal that wraps RooAbsL likelihoods for use in RooFit outside of the RooMinimizer context.
Wrapper class around ROOT::Math::Minimizer that provides a seamless interface between the minimizer f...
void setRecoverFromNaNStrength(double strength)
Try to recover from invalid function values.
int getPrintLevel()
Get the MINUIT internal printing level.
void optimizeConst(int flag)
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.
RooFit::OwningPtr< RooFitResult > save(const char *name=nullptr, const char *title=nullptr)
Save and return a RooFitResult snapshot of current minimizer status.
std::vector< std::pair< std::string, int > > _statusHistory
void profileStart()
Start profiling timer.
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.
std::unique_ptr< ROOT::Math::Minimizer > _minimizer
! pointer to used minimizer
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 fillCorrMatrix(RooFitResult &fitRes)
double & fcnOffset() const
ROOT::Fit::FitConfig _config
fitter configuration (options and parameter settings)
void profileStop()
Stop profiling timer and report results of last session.
int minos()
Execute MINOS.
bool calculateHessErrors()
int hesse()
Execute HESSE.
bool calculateMinosErrors()
void setErrorLevel(double level)
Set the level for MINUIT error analysis to the given value.
void determineStatus(bool fitterReturnValue)
int migrad()
Execute MIGRAD.
bool update(bool isValid)
bool updateMinimizerOptions(bool canDifferentMinim=true)
void setEps(double eps)
Change MINUIT epsilon.
void setPrintLevel(int newLevel)
Change the MINUIT internal printing level.
void fillResult(bool isValid)
int exec(std::string const &algoName, std::string const &statusName)
int improve()
Execute IMPROVE.
void setOffsetting(bool flag)
Enable internal likelihood offsetting for enhanced numeric precision.
RooMinimizer::Config _cfg
std::unique_ptr< FitResult > _result
! pointer to the object containing the result of the fit
RooFit::OwningPtr< RooFitResult > lastMinuitFit()
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.
std::unique_ptr< RooAbsReal::EvalErrorContext > makeEvalErrorContext() const
RooMinimizer(RooAbsReal &function, Config const &cfg={})
Construct MINUIT interface to given function.
void setMaxFunctionCalls(int n)
Change maximum number of likelihood function class from MINUIT (RooMinimizer default 500 * #parameter...
void setStrategy(int istrat)
Change MINUIT strategy to istrat.
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.
static RooMsgService & instance()
Return reference to singleton instance.
Plot frame and a container for graphics objects within that frame.
void addObject(TObject *obj, Option_t *drawOptions="", bool invisible=false)
Add a generic object to this plot.
Variable that can be changed from the outside.
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
virtual void SetLineColor(Color_t lcolor)
Set the line color.
A TGraph is an object made of two arrays X and Y with npoints each.
void SetName(const char *name="") override
Set graph name.
TMatrixTBase< Element > & ResizeTo(Int_t nrows, Int_t ncols, Int_t=-1) override
Set size of the matrix to nrows x ncols New dynamic elements are created, the overlapping part of the...
const char * GetName() const override
Returns name of object.
virtual const char * GetName() const
Returns name of object.
void Start(Bool_t reset=kTRUE)
Start the stopwatch.
void Stop()
Stop the stopwatch.
void Print(Option_t *option="") const override
Print the real and cpu time passed between the start and stop events.
T * OwningPtr
An alias for raw pointers for indicating that the return type of a RooFit function is an owning point...
OwningPtr< T > makeOwningPtr(std::unique_ptr< T > &&ptr)
Internal helper to turn a std::unique_ptr<T> into an OwningPtr.
bool setAllConstant(const RooAbsCollection &coll, bool constant=true)
set all RooRealVars to constants. return true if at least one changed status
Config argument to RooMinimizer constructor.
bool setInitialCovariance
std::string minimizerType
bool enableParallelGradient
double upperError(unsigned int i) const
std::string fMinimType
string indicating type of minimizer
std::vector< double > fErrors
errors
std::vector< double > fParams
parameter values. Size is total number of parameters
void GetCovarianceMatrix(TMatrixDSym &cov) const
std::map< unsigned int, bool > fFixedParams
list of fixed parameters
bool isParameterFixed(unsigned int ipar) const
double lowerError(unsigned int i) const