46#ifdef ROOFIT_LEGACY_EVAL_BACKEND
54constexpr int extendedFitDefault = 2;
70 std::unique_ptr<RooFitResult> rw(minimizer.
save());
74 <<
"RooAbsPdf::fitTo(" << pdf.
GetName()
75 <<
") Calculating covariance matrix according to the asymptotically correct approach. If you find this "
76 "method useful please consider citing https://arxiv.org/abs/1911.01303.\n";
79 int nFloatPars = rw->floatParsFinal().size();
81 for (
int k = 0; k < nFloatPars; k++) {
82 for (
int l = 0;
l < nFloatPars;
l++) {
89 std::vector<std::unique_ptr<RooDerivative>> derivatives;
90 const RooArgList &floated = rw->floatParsFinal();
91 std::unique_ptr<RooArgSet> floatingparams{
93 for (
const auto paramresult : floated) {
94 auto paraminternal =
static_cast<RooRealVar *
>(floatingparams->find(*paramresult));
96 derivatives.emplace_back(pdf.
derivative(*paraminternal, obs, 1));
100 for (
int j = 0; j <
data.numEntries(); j++) {
104 std::vector<double> diffs(floated.
size(), 0.0);
105 for (std::size_t k = 0; k < floated.
size(); k++) {
106 const auto paramresult =
static_cast<RooRealVar *
>(floated.
at(k));
107 auto paraminternal =
static_cast<RooRealVar *
>(floatingparams->find(*paramresult));
109 double diff = derivatives[k]->
getVal();
111 *paraminternal = paramresult->getVal();
115 double prob = pdf.
getVal(&obs);
116 for (std::size_t k = 0; k < floated.
size(); k++) {
117 for (std::size_t
l = 0;
l < floated.
size();
l++) {
118 num(k,
l) +=
data.weightSquared() * diffs[k] * diffs[
l] / (prob * prob);
122 num.Similarity(matV);
130 return rw->covQual();
148 std::unique_ptr<RooFitResult> rw{minimizer.
save()};
151 <<
") Calculating sum-of-weights-squared correction matrix for covariance matrix\n";
153 std::unique_ptr<RooFitResult> rw2{minimizer.
save()};
162 <<
") ERROR: Cannot apply sum-of-weights correction to covariance matrix: correction "
163 "matrix calculated with weight-squared is singular\n";
171 for (
int i = 0; i < matC.
GetNrows(); ++i) {
172 for (
int j = 0; j < i; ++j) {
173 matC(j, i) = matC(i, j);
181 return std::min(rw->covQual(), rw2->covQual());
186struct MinimizerConfig {
187 double recoverFromNaN = 10.;
201 int doAsymptotic = -1;
205 bool enableParallelGradient =
true;
206 bool enableParallelDescent =
false;
207 bool timingAnalysis =
false;
210 std::string minAlg =
"minuit";
213bool interpretExtendedCmdArg(
RooAbsPdf const &pdf,
int extendedCmdArg)
216 if (extendedCmdArg == extendedFitDefault) {
220 <<
"p.d.f. provides expected number of events, including extended term in likelihood." << std::endl;
229 if (extendedCmdArg == 0) {
231 std::string errMsg =
"You used the Extended(false) option on a pdf where the fit MUST be extended! "
232 "The parameters are not well defined and you're getting nonsensical results.";
233 oocoutE(&pdf, InputArguments) << errMsg << std::endl;
236 return extendedCmdArg;
241void resetFitrangeAttributes(
RooAbsArg &pdf,
RooAbsData const &
data, std::string
const &baseName,
const char *rangeName,
250 if (!rangeName || splitRange)
256 std::string fitrangeValue;
258 for (
auto const &subrange : subranges) {
259 if (subrange.empty())
261 std::string fitrangeValueSubrange = std::string(
"fit_") + baseName;
262 if (subranges.size() > 1) {
263 fitrangeValueSubrange +=
"_" + subrange;
265 fitrangeValue += fitrangeValueSubrange +
",";
268 if (arg->isCategory())
270 auto &observable =
static_cast<RooRealVar &
>(*arg);
272 observable.
setRange(fitrangeValueSubrange.c_str(), observable.getMin(subrange.c_str()),
273 observable.getMax(subrange.c_str()));
276 pdf.
setStringAttribute(
"fitrange", fitrangeValue.substr(0, fitrangeValue.size() - 1).c_str());
279std::unique_ptr<RooAbsArg> createSimultaneousNLL(
RooSimultaneous const &simPdf,
bool isExtended,
286 for (
auto const &catState : simCat) {
287 std::string
const &catName = catState.
first;
292 if (!rangeName.empty()) {
295 auto simCatAsRooCategory =
dynamic_cast<RooCategory const *
>(&simCat);
296 if (simCatAsRooCategory && !simCatAsRooCategory->isStateInRange(rangeName.c_str(), catIndex)) {
303 std::unique_ptr<RooArgSet> observables(
304 static_cast<RooArgSet *
>(std::unique_ptr<RooArgSet>(pdf->
getVariables())->selectByAttrib(
"__obs__",
true)));
305 auto nll = std::make_unique<RooNLLVarNew>(
name.c_str(),
name.c_str(), *pdf, *observables, isExtended,
offset);
307 nll->setPrefix(std::string(
"_") + catName +
"_");
313 nll->setSimCount(nllTerms.
size());
317 auto nll = std::make_unique<RooAddition>(
"mynll",
"mynll", nllTerms);
322std::unique_ptr<RooAbsReal> createNLLNew(
RooAbsPdf &pdf,
RooAbsData &
data, std::unique_ptr<RooAbsReal> &&constraints,
323 std::string
const &rangeName,
RooArgSet const &projDeps,
bool isExtended,
334 observables.
remove(projDeps,
true,
true);
337 <<
") fixing normalization set for coefficient determination to observables in data"
344 RooAbsPdf &finalPdf = wrappedPdf ? *wrappedPdf : pdf;
346 binSamplingPdfs.
addOwned(std::move(wrappedPdf));
355 nllTerms.
addOwned(createSimultaneousNLL(*simPdf, isExtended, rangeName,
offset));
358 std::make_unique<RooNLLVarNew>(
"RooNLLVarNew",
"RooNLLVarNew", finalPdf, observables, isExtended,
offset));
361 nllTerms.
addOwned(std::move(constraints));
364 std::string nllName = std::string(
"nll_") + pdf.
GetName() +
"_" +
data.GetName();
365 auto nll = std::make_unique<RooAddition>(nllName.c_str(), nllName.c_str(), nllTerms);
375namespace FitHelpers {
381 MinimizerConfig minimizerDefaults;
383 pc.
defineDouble(
"RecoverFromUndefinedRegions",
"RecoverFromUndefinedRegions", 0, minimizerDefaults.recoverFromNaN);
384 pc.
defineInt(
"optConst",
"Optimize", 0, minimizerDefaults.optConst);
385 pc.
defineInt(
"verbose",
"Verbose", 0, minimizerDefaults.verbose);
386 pc.
defineInt(
"doSave",
"Save", 0, minimizerDefaults.doSave);
387 pc.
defineInt(
"doTimer",
"Timer", 0, minimizerDefaults.doTimer);
388 pc.
defineInt(
"printLevel",
"PrintLevel", 0, minimizerDefaults.printLevel);
389 pc.
defineInt(
"strategy",
"Strategy", 0, minimizerDefaults.strategy);
390 pc.
defineInt(
"initHesse",
"InitialHesse", 0, minimizerDefaults.initHesse);
391 pc.
defineInt(
"hesse",
"Hesse", 0, minimizerDefaults.hesse);
392 pc.
defineInt(
"minos",
"Minos", 0, minimizerDefaults.minos);
393 pc.
defineInt(
"numee",
"PrintEvalErrors", 0, minimizerDefaults.numee);
394 pc.
defineInt(
"doEEWall",
"EvalErrorWall", 0, minimizerDefaults.doEEWall);
395 pc.
defineInt(
"doWarn",
"Warnings", 0, minimizerDefaults.doWarn);
396 pc.
defineInt(
"doSumW2",
"SumW2Error", 0, minimizerDefaults.doSumW2);
397 pc.
defineInt(
"doAsymptoticError",
"AsymptoticError", 0, minimizerDefaults.doAsymptotic);
398 pc.
defineInt(
"maxCalls",
"MaxCalls", 0, minimizerDefaults.maxCalls);
399 pc.
defineInt(
"doOffset",
"OffsetLikelihood", 0, 0);
400 pc.
defineInt(
"parallelize",
"Parallelize", 0, 0);
401 pc.
defineInt(
"enableParallelGradient",
"ParallelGradientOptions", 0, 0);
402 pc.
defineInt(
"enableParallelDescent",
"ParallelDescentOptions", 0, 0);
403 pc.
defineInt(
"timingAnalysis",
"TimingAnalysis", 0, 0);
404 pc.
defineString(
"mintype",
"Minimizer", 0, minimizerDefaults.minType.c_str());
405 pc.
defineString(
"minalg",
"Minimizer", 1, minimizerDefaults.minAlg.c_str());
406 pc.
defineSet(
"minosSet",
"Minos", 0, minimizerDefaults.minosSet);
423 cfg.recoverFromNaN = pc.
getDouble(
"RecoverFromUndefinedRegions");
424 cfg.optConst = pc.
getInt(
"optConst");
425 cfg.verbose = pc.
getInt(
"verbose");
426 cfg.doSave = pc.
getInt(
"doSave");
427 cfg.doTimer = pc.
getInt(
"doTimer");
428 cfg.printLevel = pc.
getInt(
"printLevel");
429 cfg.strategy = pc.
getInt(
"strategy");
430 cfg.initHesse = pc.
getInt(
"initHesse");
431 cfg.hesse = pc.
getInt(
"hesse");
432 cfg.minos = pc.
getInt(
"minos");
433 cfg.numee = pc.
getInt(
"numee");
434 cfg.doEEWall = pc.
getInt(
"doEEWall");
435 cfg.doWarn = pc.
getInt(
"doWarn");
436 cfg.doSumW2 = pc.
getInt(
"doSumW2");
437 cfg.doAsymptotic = pc.
getInt(
"doAsymptoticError");
438 cfg.maxCalls = pc.
getInt(
"maxCalls");
439 cfg.minosSet = pc.
getSet(
"minosSet");
440 cfg.minType = pc.
getString(
"mintype",
"");
441 cfg.minAlg = pc.
getString(
"minalg",
"minuit");
442 cfg.doOffset = pc.
getInt(
"doOffset");
443 cfg.parallelize = pc.
getInt(
"parallelize");
444 cfg.enableParallelGradient = pc.
getInt(
"enableParallelGradient");
445 cfg.enableParallelDescent = pc.
getInt(
"enableParallelDescent");
446 cfg.timingAnalysis = pc.
getInt(
"timingAnalysis");
449 bool weightedData =
data.isNonPoissonWeighted();
451 std::string msgPrefix = std::string{
"RooAbsPdf::fitTo("} + pdf.
GetName() +
"): ";
454 if (weightedData && cfg.doSumW2 == -1 && cfg.doAsymptotic == -1) {
455 oocoutW(&pdf, InputArguments) << msgPrefix <<
456 R
"(WARNING: a likelihood fit is requested of what appears to be weighted data.
457 While the estimated values of the parameters will always be calculated taking the weights into account,
458 there are multiple ways to estimate the errors of the parameters. You are advised to make an
459 explicit choice for the error calculation:
460 - Either provide SumW2Error(true), to calculate a sum-of-weights-corrected HESSE error matrix
461 (error will be proportional to the number of events in MC).
462 - Or provide SumW2Error(false), to return errors from original HESSE error matrix
463 (which will be proportional to the sum of the weights, i.e., a dataset with <sum of weights> events).
464 - Or provide AsymptoticError(true), to use the asymptotically correct expression
465 (for details see https://arxiv.org/abs/1911.01303)."
469 if (cfg.minos && (cfg.doSumW2 == 1 || cfg.doAsymptotic == 1)) {
472 <<
" sum-of-weights and asymptotic error correction do not work with MINOS errors. Not fitting.\n";
475 if (cfg.doAsymptotic == 1 && cfg.minos) {
476 oocoutW(&pdf, InputArguments) << msgPrefix <<
"WARNING: asymptotic correction does not apply to MINOS errors\n";
480 if (cfg.doSumW2 == 1 && cfg.doAsymptotic == 1) {
481 oocoutE(&pdf, InputArguments) << msgPrefix
482 <<
"ERROR: Cannot compute both asymptotically correct and SumW2 errors.\n";
495 m.setMinimizerType(cfg.minType);
496 m.setEvalErrorWall(cfg.doEEWall);
497 m.setRecoverFromNaNStrength(cfg.recoverFromNaN);
498 m.setPrintEvalErrors(cfg.numee);
499 if (cfg.maxCalls > 0)
500 m.setMaxFunctionCalls(cfg.maxCalls);
501 if (cfg.printLevel != 1)
502 m.setPrintLevel(cfg.printLevel);
504 m.optimizeConst(cfg.optConst);
509 if (cfg.strategy != 1)
510 m.setStrategy(cfg.strategy);
513 m.minimize(cfg.minType.c_str(), cfg.minAlg.c_str());
517 int corrCovQual = -1;
519 if (
m.getNPar() > 0) {
520 if (cfg.doAsymptotic == 1)
521 corrCovQual = calcAsymptoticCorrectedCovariance(pdf,
m,
data);
522 if (cfg.doSumW2 == 1)
523 corrCovQual = calcSumW2CorrectedCovariance(pdf,
m, nll);
527 cfg.minosSet ?
m.minos(*cfg.minosSet) :
m.minos();
530 std::unique_ptr<RooFitResult> ret;
532 auto name = std::string(
"fitresult_") + pdf.
GetName() +
"_" +
data.GetName();
533 auto title = std::string(
"Result of fit of p.d.f. ") + pdf.
GetName() +
" to dataset " +
data.GetName();
534 ret = std::unique_ptr<RooFitResult>{
m.save(
name.c_str(), title.c_str())};
535 if ((cfg.doSumW2 == 1 || cfg.doAsymptotic == 1) &&
m.getNPar() > 0)
536 ret->setCovQual(corrCovQual);
546 auto baseName = std::string(
"nll_") + pdf.
GetName() +
"_" +
data.GetName();
551 pc.
defineString(
"rangeName",
"RangeWithName", 0,
"",
true);
553 pc.
defineString(
"globstag",
"GlobalObservablesTag", 0,
"");
554 pc.
defineString(
"globssource",
"GlobalObservablesSource", 0,
"data");
557 pc.
defineInt(
"splitRange",
"SplitRange", 0, 0);
558 pc.
defineInt(
"ext",
"Extended", 0, extendedFitDefault);
560 pc.
defineInt(
"interleave",
"NumCPU", 1, 0);
561 pc.
defineInt(
"verbose",
"Verbose", 0, 0);
562 pc.
defineInt(
"optConst",
"Optimize", 0, 0);
563 pc.
defineInt(
"cloneData",
"CloneData", 0, 2);
564 pc.
defineSet(
"projDepSet",
"ProjectedObservables", 0,
nullptr);
565 pc.
defineSet(
"cPars",
"Constrain", 0,
nullptr);
566 pc.
defineSet(
"glObs",
"GlobalObservables", 0,
nullptr);
567 pc.
defineInt(
"doOffset",
"OffsetLikelihood", 0, 0);
568 pc.
defineSet(
"extCons",
"ExternalConstraints", 0,
nullptr);
570 pc.
defineDouble(
"IntegrateBins",
"IntegrateBins", 0, -1.);
572 pc.
defineMutex(
"GlobalObservables",
"GlobalObservablesTag");
573 pc.
defineInt(
"ModularL",
"ModularL", 0, 0);
588 if (pc.
getInt(
"ModularL")) {
589 int lut[3] = {2, 1, 0};
597 if (
auto tmp = pc.
getSet(
"cPars"))
600 if (
auto tmp = pc.
getSet(
"extCons"))
601 extConsSet.
add(*tmp);
603 if (
auto tmp = pc.
getSet(
"glObs"))
606 const std::string rangeName = pc.
getString(
"globstag",
"",
false);
609 builder.Extended(ext)
610 .ConstrainedParameters(cParsSet)
611 .ExternalConstraints(extConsSet)
612 .GlobalObservables(glObsSet)
613 .GlobalObservablesTag(rangeName.c_str());
615 return std::make_unique<RooFit::TestStatistics::RooRealL>(
"likelihood",
"", builder.build());
619 const char *rangeName = pc.
getString(
"rangeName",
nullptr,
true);
620 const char *addCoefRangeName = pc.
getString(
"addCoefRange",
nullptr,
true);
621 const bool ext = interpretExtendedCmdArg(pdf, pc.
getInt(
"ext"));
623 int splitRange = pc.
getInt(
"splitRange");
624 int optConst = pc.
getInt(
"optConst");
625 int cloneData = pc.
getInt(
"cloneData");
629 if (cloneData == 2) {
630 cloneData = optConst;
634 double rangeLo = pc.
getDouble(
"rangeLo");
635 double rangeHi = pc.
getDouble(
"rangeHi");
640 for (
auto arg : obs) {
643 rrv->
setRange(
"fit", rangeLo, rangeHi);
651 resetFitrangeAttributes(pdf,
data, baseName, rangeName, splitRange);
659 const std::string globalObservablesSource = pc.
getString(
"globssource",
"data",
false);
660 if (globalObservablesSource !=
"data" && globalObservablesSource !=
"model") {
661 std::string errMsg =
"RooAbsPdf::fitTo: GlobalObservablesSource can only be \"data\" or \"model\"!";
662 oocoutE(&pdf, InputArguments) << errMsg << std::endl;
663 throw std::invalid_argument(errMsg);
665 const bool takeGlobalObservablesFromData = globalObservablesSource ==
"data";
670 auto createConstr = [&](
bool removeConstraintsFromPdf =
false) -> std::unique_ptr<RooAbsReal> {
678 takeGlobalObservablesFromData,
679 removeConstraintsFromPdf);
689 std::string oldNormRange;
697 normSet.
remove(projDeps,
true,
true);
703 ctx.setLikelihoodMode(
true);
705 std::unique_ptr<RooAbsPdf> pdfClone = std::unique_ptr<RooAbsPdf>{
static_cast<RooAbsPdf *
>(head.release())};
714 if (addCoefRangeName) {
716 <<
") fixing interpretation of coefficients of any component to range "
717 << addCoefRangeName <<
"\n";
718 pdfClone->fixAddCoefRange(addCoefRangeName,
false);
721 std::unique_ptr<RooAbsReal> compiledConstr;
722 if (std::unique_ptr<RooAbsReal> constr = createConstr()) {
724 compiledConstr->addOwnedComponents(std::move(constr));
727 auto nll = createNLLNew(*pdfClone,
data, std::move(compiledConstr), rangeName ? rangeName :
"", projDeps, ext,
728 pc.getDouble(
"IntegrateBins"),
offset);
730 std::unique_ptr<RooAbsReal> nllWrapper;
736 nllWrapper = std::make_unique<RooFit::Experimental::RooFuncWrapper>(
"nll_func_wrapper",
"nll_func_wrapper",
737 *nll, &
data, simPdf,
true);
739 static_cast<Experimental::RooFuncWrapper &
>(*nllWrapper).createGradient();
741 nllWrapper = std::make_unique<RooEvaluatorWrapper>(
743 takeGlobalObservablesFromData);
746 nllWrapper->addOwnedComponents(std::move(nll));
747 nllWrapper->addOwnedComponents(std::move(pdfClone));
751 std::unique_ptr<RooAbsReal> nll;
753#ifdef ROOFIT_LEGACY_EVAL_BACKEND
756 int numcpu = pc.
getInt(
"numcpu");
757 int numcpu_strategy = pc.
getInt(
"interleave");
759 if (numcpu_strategy == 3 && !pdf.
InheritsFrom(
"RooSimultaneous")) {
760 oocoutW(&pdf, Minimization) <<
"Cannot use a NumCpu Strategy = 3 when the pdf is not a RooSimultaneous, "
761 "falling back to default strategy = 0"
768 RooAbsPdf &actualPdf = binnedLInfo.binnedPdf ? *binnedLInfo.binnedPdf : pdf;
780 cfg.
binnedL = binnedLInfo.isBinnedL;
782 cfg.
rangeName = rangeName ? rangeName :
"";
783 auto nllVar = std::make_unique<RooNLLVar>(baseName.c_str(),
"-log(likelihood)", actualPdf,
data, projDeps, ext, cfg);
785 nll = std::move(nllVar);
789 if (std::unique_ptr<RooAbsReal> constraintTerm = createConstr()) {
801 constraintTerm->setData(
data,
false);
807 auto orignll = std::move(nll);
808 nll = std::make_unique<RooAddition>((baseName +
"_with_constr").c_str(),
"nllWithCons",
810 nll->addOwnedComponents(std::move(orignll), std::move(constraintTerm));
818 nll->enableOffsetting(
true);
821 throw std::runtime_error(
"RooFit was not built with the legacy evaluation backend");
829#ifdef ROOFIT_LEGACY_EVAL_BACKEND
835 pc.
defineInt(
"verbose",
"Verbose", 0, 0);
842 std::string baseName =
"chi2_" + std::string(real.
GetName()) +
"_" +
data.GetName();
848 pc.
defineInt(
"extended",
"Extended", 0, extendedFitDefault);
849 pc.
defineInt(
"split_range",
"SplitRange", 0, 0);
850 pc.
defineDouble(
"integrate_bins",
"IntegrateBins", 0, -1);
859 bool extended =
false;
860 if (
auto pdf =
dynamic_cast<RooAbsPdf const *
>(&real)) {
861 extended = interpretExtendedCmdArg(*pdf, pc.
getInt(
"extended"));
866 const char *rangeName = pc.
getString(
"rangeName",
nullptr,
true);
867 const char *addCoefRangeName = pc.
getString(
"addCoefRange",
nullptr,
true);
869 cfg.
rangeName = rangeName ? rangeName :
"";
877 auto chi2 = std::make_unique<RooChi2Var>(baseName.c_str(), baseName.c_str(), real,
884 pc.
defineInt(
"integrate",
"Integrate", 0, 0);
886 pc.
defineString(
"rangeName",
"RangeWithName", 0,
"",
true);
887 pc.
defineInt(
"interleave",
"NumCPU", 1, 0);
896 bool integrate = pc.
getInt(
"integrate");
898 const char *rangeName = pc.
getString(
"rangeName",
nullptr,
true);
902 if (numcpu_strategy == 3 && !real.
InheritsFrom(
"RooSimultaneous")) {
903 oocoutW(&real, Minimization) <<
"Cannot use a NumCpu Strategy = 3 when the pdf is not a RooSimultaneous, "
904 "falling back to default strategy = 0"
911 cfg.
rangeName = rangeName ? rangeName :
"";
917 std::string
name =
"chi2_" + std::string(real.
GetName()) +
"_" +
data.GetName();
919 return std::make_unique<RooXYChi2Var>(
name.c_str(),
name.c_str(), real,
static_cast<RooDataSet &
>(
data), yvar,
923 throw std::runtime_error(
"createChi2() is not supported without the legacy evaluation backend");
935 std::string nllCmdListString;
937 nllCmdListString =
"ProjectedObservables,Extended,Range,"
938 "RangeWithName,SumCoefRange,NumCPU,SplitRange,Constrained,Constrain,ExternalConstraints,"
939 "CloneData,GlobalObservables,GlobalObservablesSource,GlobalObservablesTag,"
940 "EvalBackend,IntegrateBins,ModularL";
943 nllCmdListString +=
",OffsetLikelihood";
946 auto createChi2DataHistCmdArgs =
"Range,RangeWithName,NumCPU,Optimize,IntegrateBins,ProjectedObservables,"
947 "AddCoefRange,SplitRange,DataError,Extended";
948 auto createChi2DataSetCmdArgs =
"YVar,Integrate,RangeWithName,NumCPU,Verbose";
949 nllCmdListString += isDataHist ? createChi2DataHistCmdArgs : createChi2DataSetCmdArgs;
955 defineMinimizationOptions(pc);
965 oocoutW(&real, Minimization) <<
"The timingAnalysis feature was built for minimization with RooSimultaneous "
966 "and is not implemented for other PDF's. Please create a RooSimultaneous to "
967 "enable this feature."
975 size_t nEvents =
static_cast<size_t>(prefit *
data.numEntries());
976 if (prefit > 0.5 || nEvents < 100) {
977 oocoutW(&real, InputArguments) <<
"PrefitDataFraction should be in suitable range."
978 <<
"With the current PrefitDataFraction=" << prefit
979 <<
", the number of events would be " << nEvents <<
" out of "
980 <<
data.numEntries() <<
". Skipping prefit..." << std::endl;
982 size_t step =
data.numEntries() / nEvents;
986 for (
int i = 0; i <
data.numEntries(); i += step) {
988 tiny.add(*event,
data.weight());
991 pc.
filterCmdList(tinyCmdList,
"Prefit,Hesse,Minos,Verbose,Save,Timer");
995 tinyCmdList.Add(&hesse_option);
996 tinyCmdList.Add(&print_option);
998 fitTo(real, tiny, tinyCmdList, chi2);
1003 if (pc.
getInt(
"parallelize") != 0 || pc.
getInt(
"enableParallelGradient") || pc.
getInt(
"enableParallelDescent")) {
1006 nllCmdList.
Add(&modularL_option);
1009 std::unique_ptr<RooAbsReal> nll;
1014 nll = std::unique_ptr<RooAbsReal>{
dynamic_cast<RooAbsPdf &
>(real).createNLL(
data, nllCmdList)};
1017 return RooFit::FitHelpers::minimize(real, *nll,
data, pc);
header file containing the templated implementation of matrix inversion routines for use with ROOT's ...
std::unique_ptr< RooAbsReal > createConstraintTerm(std::string const &name, RooAbsPdf const &pdf, RooAbsData const &data, RooArgSet const *constrainedParameters, RooArgSet const *externalConstraints, RooArgSet const *globalObservables, const char *globalObservablesTag, bool takeGlobalObservablesFromData, bool removeConstraintsFromPdf)
Create the parameter constraint sum to add to the negative log-likelihood.
ROOT::RRangeCast< T, false, Range_t > static_range_cast(Range_t &&coll)
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 offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
class to compute the Cholesky decomposition of a matrix
Common abstract base class for objects that represent a value and a "shape" in RooFit.
void setOperMode(OperMode mode, bool recurseADirty=true)
Set the operation mode of this node.
void setStringAttribute(const Text_t *key, const Text_t *value)
Associate string 'value' to this object under key 'key'.
RooFit::OwningPtr< RooArgSet > getParameters(const RooAbsData *data, bool stripDisconnected=true) const
Create a list of leaf nodes in the arg tree starting with ourself as top node that don't match any of...
RooFit::OwningPtr< RooArgSet > getObservables(const RooArgSet &set, bool valueOnly=true) const
Given a set of possible observables, return the observables that this PDF depends on.
bool addOwnedComponents(const RooAbsCollection &comps)
Take ownership of the contents of 'comps'.
void removeStringAttribute(const Text_t *key)
Delete a string attribute with a given key.
RooFit::OwningPtr< RooArgSet > getVariables(bool stripDisconnected=true) const
Return RooArgSet with all variables (tree leaf nodes of expression tree)
virtual void applyWeightSquared(bool flag)
Disables or enables the usage of squared weights.
void setAttribute(const Text_t *name, bool value=true)
Set (default) or clear a named boolean attribute of this object.
Abstract base class for objects that represent a discrete value that can be set from the outside,...
virtual bool remove(const RooAbsArg &var, bool silent=false, bool matchByNameOnly=false)
Remove the specified argument from our list.
virtual bool add(const RooAbsArg &var, bool silent=false)
Add the specified argument to list.
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...
Storage_t::size_type size() const
RooAbsArg * first() const
virtual bool addOwned(RooAbsArg &var, bool silent=false)
Add an argument and transfer the ownership to the collection.
Abstract base class for binned and unbinned datasets.
Abstract interface for all probability density functions.
std::unique_ptr< RooAbsArg > compileForNormSet(RooArgSet const &normSet, RooFit::Detail::CompileContext &ctx) const override
void setNormRange(const char *rangeName)
const char * normRange() const
virtual ExtendMode extendMode() const
Returns ability of PDF to provide extended likelihood terms.
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 void fixAddCoefNormalization(const RooArgSet &addNormSet=RooArgSet(), bool force=true)
Fix the interpretation of the coefficient of any RooAddPdf component in the expression tree headed by...
RooDerivative * derivative(RooRealVar &obs, Int_t order=1, double eps=0.001)
Return function representing first, second or third order derivative of this function.
static void setEvalErrorLoggingMode(ErrorLoggingMode m)
Set evaluation error logging mode.
virtual RooFit::OwningPtr< RooAbsReal > createChi2(RooDataHist &data, const RooLinkedList &cmdList)
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.
static std::unique_ptr< RooAbsPdf > create(RooAbsPdf &pdf, RooAbsData const &data, double precision)
Creates a wrapping RooBinSamplingPdf if appropriate.
Object to represent discrete states.
Named container for two doubles, two integers two object points and three string pointers that can be...
Int_t getInt(Int_t idx) const
Configurable parser for RooCmdArg named arguments.
void defineMutex(const char *head, Args_t &&... tail)
Define arguments where any pair is mutually exclusive.
bool process(const RooCmdArg &arg)
Process given RooCmdArg.
bool hasProcessed(const char *cmdName) const
Return true if RooCmdArg with name 'cmdName' has been processed.
double getDouble(const char *name, double defaultValue=0.0) const
Return double property registered with name 'name'.
bool defineDouble(const char *name, const char *argName, int doubleNum, double defValue=0.0)
Define double property name 'name' mapped to double in slot 'doubleNum' in RooCmdArg with name argNam...
RooArgSet * getSet(const char *name, RooArgSet *set=nullptr) const
Return RooArgSet property registered with name 'name'.
bool defineSet(const char *name, const char *argName, int setNum, const RooArgSet *set=nullptr)
Define TObject property name 'name' mapped to object in slot 'setNum' in RooCmdArg with name argName ...
bool ok(bool verbose) const
Return true of parsing was successful.
bool defineObject(const char *name, const char *argName, int setNum, const TObject *obj=nullptr, bool isArray=false)
Define TObject property name 'name' mapped to object in slot 'setNum' in RooCmdArg with name argName ...
const char * getString(const char *name, const char *defaultValue="", bool convEmptyToNull=false) const
Return string property registered with name 'name'.
bool defineString(const char *name, const char *argName, int stringNum, const char *defValue="", bool appendMode=false)
Define double property name 'name' mapped to double in slot 'stringNum' in RooCmdArg with name argNam...
bool defineInt(const char *name, const char *argName, int intNum, int defValue=0)
Define integer property name 'name' mapped to integer in slot 'intNum' in RooCmdArg with name argName...
void allowUndefined(bool flag=true)
If flag is true the processing of unrecognized RooCmdArgs is not considered an error.
int getInt(const char *name, int defaultValue=0) const
Return integer property registered with name 'name'.
RooLinkedList filterCmdList(RooLinkedList &cmdInList, const char *cmdNameList, bool removeFromInList=true) const
Utility function to filter commands listed in cmdNameList from cmdInList.
TObject * getObject(const char *name, TObject *obj=nullptr) const
Return TObject property registered with name 'name'.
Container class to hold N-dimensional binned data.
Container class to hold unbinned data.
static Value & defaultValue()
Collection class for internal use, storing a collection of RooAbsArg pointers in a doubly linked list...
virtual void Add(TObject *arg)
TObject * FindObject(const char *name) const override
Return pointer to object with given name.
Wrapper class around ROOT::Fit:Fitter that provides a seamless interface between the minimizer functi...
RooFit::OwningPtr< RooFitResult > save(const char *name=nullptr, const char *title=nullptr)
Save and return a RooFitResult snapshot of current minimizer status.
int hesse()
Execute HESSE.
void applyCovarianceMatrix(TMatrixDSym const &V)
Apply results of given external covariance matrix.
Variable that can be changed from the outside.
void setRange(const char *name, double min, double max)
Set a fit or plotting range.
Facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset.
RooAbsPdf * getPdf(RooStringView catName) const
Return the p.d.f associated with the given index category name.
void wrapPdfsInBinSamplingPdfs(RooAbsData const &data, double precision)
Wraps the components of this RooSimultaneous in RooBinSamplingPdfs.
const RooAbsCategoryLValue & indexCat() const
TMatrixTSym< Element > & Similarity(const TMatrixT< Element > &n)
Calculate B * (*this) * B^T , final matrix will be (nrowsb x nrowsb) This is a similarity transform w...
const char * GetName() const override
Returns name of object.
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
RooCmdArg WeightVar(const char *name="weight", bool reinterpretAsWeight=false)
RooCmdArg Hesse(bool flag=true)
RooCmdArg ModularL(bool flag=false)
RooCmdArg PrintLevel(Int_t code)
std::vector< std::string > Split(std::string_view str, std::string_view delims, bool skipEmpty=false)
Splits a string at each character in delims.
std::unique_ptr< T > compileForNormSet(T const &arg, RooArgSet const &normSet)
The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or othe...
OffsetMode
For setting the offset mode with the Offset() command argument to RooAbsPdf::fitTo()
std::unique_ptr< T > cloneTreeWithSameParameters(T const &arg, RooArgSet const *observables=nullptr)
Clone RooAbsArg object and reattach to original parameters.
BinnedLOutput getBinnedL(RooAbsPdf const &pdf)
std::string rangeName
Stores the configuration parameters for RooAbsTestStatistic.
std::string addCoefRangeName
bool takeGlobalObservablesFromData
double integrateOverBinsPrecision
RooFit::MPSplit interleave
Config argument to RooMinimizer constructor.
bool enableParallelDescent
bool enableParallelGradient