20#if ROOT_VERSION_CODE < ROOT_VERSION(6, 27, 00)
21#define protected public
55#include "../../roofitcore/src/RooAbsTestStatistic.h"
70std::shared_ptr<RooLinkedList> xRooFit::sDefaultNLLOptions =
nullptr;
71std::shared_ptr<ROOT::Fit::FitConfig> xRooFit::sDefaultFitConfig =
nullptr;
73const char *xRooFit::GetVersion()
77const char *xRooFit::GetVersionDate()
84 return RooCmdArg(
"ReuseNLL", flag, 0, 0, 0,
nullptr,
nullptr,
nullptr,
nullptr);
94 return RooCmdArg(
"StrategySequence", 0, 0, 0, 0, val);
97xRooNLLVar xRooFit::createNLL(
const std::shared_ptr<RooAbsPdf> pdf,
const std::shared_ptr<RooAbsData>
data,
105 return createNLL(std::shared_ptr<RooAbsPdf>(&pdf, [](
RooAbsPdf *) {}),
123 return createNLL(pdf,
data,
l);
126std::shared_ptr<const RooFitResult>
128 const std::pair<std::shared_ptr<RooAbsData>, std::shared_ptr<const RooAbsCollection>> &
data,
136std::shared_ptr<const RooFitResult> xRooFit::fitTo(
RooAbsPdf &pdf,
137 const std::pair<RooAbsData *, const RooAbsCollection *> &
data,
145std::pair<std::shared_ptr<RooAbsData>, std::shared_ptr<const RooAbsCollection>>
149 std::pair<std::shared_ptr<RooAbsData>, std::shared_ptr<const RooAbsCollection>> out;
155 auto _allVars = std::unique_ptr<RooAbsCollection>(pdf.
getVariables());
156 auto _snap = std::unique_ptr<RooAbsCollection>(_allVars->snapshot());
157 *_allVars = fr->constPars();
158 *_allVars = fr->floatParsFinal();
161 auto _globs = std::unique_ptr<RooAbsCollection>(fr->constPars().selectByAttrib(
"global",
true));
172 std::function<std::pair<std::shared_ptr<RooAbsData>, std::shared_ptr<const RooArgSet>>(
RooAbsPdf *)> genSubPdf;
175 std::pair<std::shared_ptr<RooAbsData>, std::shared_ptr<const RooArgSet>> _out;
178 std::unique_ptr<RooArgSet> _obs(_pdf->getVariables());
179 _obs->remove(fr->constPars(),
true,
true);
180 _obs->remove(fr->floatParsFinal(),
true,
true);
182 if (!_globs->empty()) {
187 std::unique_ptr<RooArgSet> globs(_pdf->getObservables(t));
188 globs->snapshot(*toy_gobs);
189 if (!toy_gobs->
empty() &&
193 *toy_gobs = *std::unique_ptr<RooDataSet>(_pdf->generate(*globs, 1))->
get();
198 for (
auto thePdf : pp->pdfList()) {
199 auto gob = std::unique_ptr<RooArgSet>(thePdf->getObservables(*globs));
202 if (gob->size() > 1) {
203 Warning(
"generate",
"%s contains multiple global obs: %s", thePdf->GetName(),
204 gob->contentsString().c_str());
208 std::unique_ptr<RooArgSet> cpars(thePdf->getParameters(*globs));
210 bool foundServer =
false;
218 !(cClass && strcmp(cClass->
GetName(),
"SimpleGaussianConstraint") == 0)) {
221 <<
"AsymptoticCalculator::MakeAsimovData:constraint term " << thePdf->GetName()
222 <<
" of type " << className <<
" is a non-supported type - result might be not correct "
241 <<
"AsymptoticCalculator::MakeAsimovData:constraint term " << thePdf->
GetName()
242 <<
" has no direct dependence on global observable- cannot generate it " << std::endl;
254 for (
RooAbsArg *a2 : thePdf->servers()) {
260 if (thetaGamma ==
nullptr) {
262 <<
"AsymptoticCalculator::MakeAsimovData:constraint term " << thePdf->
GetName()
263 <<
" is a Gamma distribution and no server named theta is found. Assume that the Gamma "
268 for (
RooAbsArg *a2 : thePdf->servers()) {
276 <<
"AsymptoticCalculator::MakeAsimovData:constraint term " << thePdf->
GetName()
277 <<
" constraint term has more server depending on nuisance- cannot generate it "
282 if (thetaGamma && thetaGamma->
getVal() > 0) {
293 <<
"AsymptoticCalculator::MakeAsimovData - can't find nuisance for constraint term - global "
294 "observables will not be set to Asimov value "
295 << thePdf->GetName() << std::endl;
296 std::cerr <<
"Parameters: " << std::endl;
298 std::cerr <<
"Observables: " << std::endl;
303 Error(
"generate",
"Cannot generate global observables, pdf is: %s::%s", _pdf->ClassName(),
309 _out.second.reset(toy_gobs);
316 _out.first = std::make_unique<RooDataSet>(
317 uuid,
TString::Format(
"%s %s", _pdf->GetTitle(), (expected) ?
"Expected" :
"Toy"), *_obs,
320 for (
auto &
c : s->indexCat()) {
321#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 22, 00)
322 std::string cLabel =
c.first;
324 std::string cLabel =
c->GetName();
326 auto p = s->getPdf(cLabel.c_str());
329 auto toy = genSubPdf(
p);
330 if (toy.second && _out.second)
331 *
const_cast<RooArgSet *
>(_out.second.get()) = *toy.second;
332 _obs->setCatLabel(s->indexCat().GetName(), cLabel.c_str());
333 for (
int i = 0; i < toy.first->numEntries(); i++) {
334 *_obs = *toy.first->get(i);
335 _out.first->add(*_obs, toy.first->weight());
341 std::map<RooRealVar *, std::shared_ptr<RooAbsBinning>> binnings;
343 for (
auto &o : *_obs) {
347 if (
auto res = _pdf->binBoundaries(*
r, -std::numeric_limits<double>::infinity(),
348 std::numeric_limits<double>::infinity())) {
349 binnings[
r] = std::shared_ptr<RooAbsBinning>(
r->getBinning().clone(
r->getBinning().GetName()));
351 std::vector<double> boundaries;
352 boundaries.reserve(res->size());
353 for (
auto &rr : *res) {
354 if (boundaries.empty() || std::abs(boundaries.back() - rr) > 1
e-3 ||
355 std::abs(boundaries.back() - rr) > 1
e-5 * boundaries.back())
356 boundaries.push_back(rr);
358 r->setBinning(
RooBinning(boundaries.size() - 1, &boundaries[0]));
360 }
else if (
r->numBins(
r->getBinning().GetName()) == 0 && expected) {
362 binnings[
r] = std::shared_ptr<RooAbsBinning>(
r->getBinning().clone(
r->getBinning().GetName()));
373 _out.first = std::make_unique<RooDataSet>(
"",
"Toy", _tmp,
RooFit::WeightVar(
"weightVar"));
374 _out.first->add(_tmp);
376 if (_pdf->canBeExtended()) {
386 _out.first = std::unique_ptr<RooDataSet>{_pdf->generate(*_obs,
RooFit::ExpectedData(expected))};
390 _out.first->SetName(
TUUID().AsString());
392 for (
auto &
b : binnings) {
394 auto binning =
b.second;
395 v->setBinning(*binning);
398 auto x =
dynamic_cast<RooRealVar *
>(_out.first->get()->find(
v->GetName()));
399 auto r =
x->getRange();
400 if (
r.first > binning->lowBound())
401 x->setMin(binning->lowBound());
402 if (
r.second < binning->highBound())
403 x->setMax(binning->highBound());
408 out = genSubPdf(&pdf);
409 out.first->SetName(expected ? (
TString(fr->GetName()) +
"_asimov") : uuid);
413 out.first->setGlobalObservables(*out.second);
417#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 26, 00)
420 w->setStringAttribute(
"fitResult", fr->GetName());
421 w->setAttribute(
"expected", expected);
431#if ROOT_VERSION_CODE < ROOT_VERSION(6, 27, 00)
432 auto _ws = pdf.
_myws;
439 for (
auto obj : _ws->components()) {
440 for (
int i = 0; i < obj->numCaches(); i++) {
446 p->setNormRange(
p->normRange());
448 obj->setValueDirty();
456std::shared_ptr<RooLinkedList> xRooFit::createNLLOptions()
462 for (
auto opt : *defaultNLLOptions()) {
463 out->Add(opt->Clone(
nullptr));
469std::shared_ptr<RooLinkedList> xRooFit::defaultNLLOptions()
471 if (sDefaultNLLOptions)
472 return sDefaultNLLOptions;
480 return sDefaultNLLOptions;
483std::shared_ptr<ROOT::Fit::FitConfig> xRooFit::createFitConfig()
485 return std::make_shared<ROOT::Fit::FitConfig>(*defaultFitConfig());
488std::shared_ptr<ROOT::Fit::FitConfig> xRooFit::defaultFitConfig()
490 if (sDefaultFitConfig)
491 return sDefaultFitConfig;
492 sDefaultFitConfig = std::make_shared<ROOT::Fit::FitConfig>();
493 auto &fitConfig = *sDefaultFitConfig;
494 fitConfig.SetParabErrors(
true);
495 fitConfig.MinimizerOptions().SetMinimizerType(
"Minuit2");
496 fitConfig.MinimizerOptions().SetErrorDef(0.5);
497 fitConfig.SetParabErrors(
true);
498 fitConfig.SetMinosErrors(
true);
499 fitConfig.MinimizerOptions().SetMaxFunctionCalls(
501 fitConfig.MinimizerOptions().SetMaxIterations(-1);
502 fitConfig.MinimizerOptions().SetStrategy(-1);
506 fitConfig.MinimizerOptions().SetPrintLevel(-2);
509 auto extraOpts =
const_cast<ROOT::Math::IOptions *
>(fitConfig.MinimizerOptions().ExtraOptions());
510 extraOpts->
SetValue(
"OptimizeConst", 2);
512#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 29, 00)
513 extraOpts->SetValue(
"StrategySequence",
"0s01s12s2s3m");
514 extraOpts->SetValue(
"HesseStrategySequence",
"23");
516 extraOpts->SetValue(
"StrategySequence",
"0s01s12s2m");
517 extraOpts->SetValue(
"HesseStrategySequence",
"2");
522 extraOpts->SetValue(
"LogSize", 0);
523 extraOpts->SetValue(
"BoundaryCheck",
525 extraOpts->SetValue(
"TrackProgress", 30);
532 return sDefaultFitConfig;
537 return const_cast<ROOT::Math::IOptions *
>(defaultFitConfig()->MinimizerOptions().ExtraOptions());
547 if (signum == SIGINT) {
548 std::cout <<
"Minimization interrupted ... will exit as soon as possible" << std::endl;
559 fFunc(
"func",
"func", this,
f),
565 vars.reset(std::unique_ptr<RooAbsCollection>(
f.getVariables())->selectByAttrib(
"Constant",
false));
585 return fFunc->getParameters(observables, outputSet, stripDisconnected);
592 fFunc->printMultiline(os, contents, verbose,
indent);
596 fFunc->constOptimizeTestStatistic(opcode, doAlsoTrackingOpt);
602 throw std::runtime_error(
"Keyboard interrupt");
603 return std::numeric_limits<double>::quiet_NaN();
606 if (
prevMin == std::numeric_limits<double>::infinity()) {
610 if (!std::isnan(out)) {
622 std::stringstream sout;
631 nRequired *= (nRequired - 1) / 2;
642 std::vector<std::pair<double, std::string>> parDeltas;
645 parDeltas.emplace_back(std::pair<double, std::string>(
648 std::sort(parDeltas.begin(), parDeltas.end(),
649 [](
auto &left,
auto &right) { return std::abs(left.first) > std::abs(right.first); });
651 for (i = 0; i < std::min(3,
int(parDeltas.size())); i++) {
652 if (parDeltas.at(i).first == 0)
656 sout << parDeltas.at(i).second << (parDeltas.at(i).first >= 0 ?
"+" :
"-") <<
"="
657 << std::abs(parDeltas.at(i).first) <<
"(" <<
minPars.
getRealValue(parDeltas.at(i).second.c_str())
660 if (i <
int(parDeltas.size()) && parDeltas.at(i).first != 0)
665 if (
gROOT->FromPopUp() &&
gROOT->GetListOfBrowsers()->At(0)) {
666 auto browser =
dynamic_cast<TBrowser *
>(
gROOT->GetListOfBrowsers()->At(0));
667 std::string status = sout.str();
670 std::string status_part;
671 if (status.find(
" : ") != std::string::npos) {
672 status_part = status.substr(0, status.find(
" : "));
673 status = status.substr(status.find(
" : ") + 3);
675 status_part = status;
683 std::cerr << sout.str() << std::endl;
699 mutable double minVal = std::numeric_limits<double>::infinity();
700 mutable double prevMin = std::numeric_limits<double>::infinity();
706 std::shared_ptr<RooAbsCollection>
vars;
719 const std::shared_ptr<ROOT::Fit::FitConfig> &_fitConfig,
720 const std::shared_ptr<RooLinkedList> &nllOpts)
724 auto &fitConfig = *myFitConfig;
728 TString resultTitle = nll.getStringAttribute(
"fitresultTitle");
730 if (resultTitle ==
"")
735 if (nll.getStringAttribute(
"userPars")) {
736 TStringToken st(nll.getStringAttribute(
"userPars"),
",");
739 TString parVal = nll.getStringAttribute(parName);
748 auto _nllVars = std::unique_ptr<RooAbsCollection>(_nll->getVariables());
750 std::unique_ptr<RooAbsCollection> constPars(_nllVars->selectByAttrib(
"Constant",
true));
751 constPars->add(fUserPars,
true);
752 std::unique_ptr<RooAbsCollection> floatPars(_nllVars->selectByAttrib(
"Constant",
false));
755 double boundaryCheck = 0;
759#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 29, 00)
760 int hesseStrategy = 3;
762 int hesseStrategy = 2;
764 if (fitConfig.MinimizerOptions().ExtraOptions()) {
765 fitConfig.MinimizerOptions().ExtraOptions()->GetNamedValue(
"StrategySequence", s);
766 fitConfig.MinimizerOptions().ExtraOptions()->GetIntValue(
"TrackProgress", _progress);
767 fitConfig.MinimizerOptions().ExtraOptions()->GetRealValue(
"BoundaryCheck", boundaryCheck);
768 fitConfig.MinimizerOptions().ExtraOptions()->GetIntValue(
"LogSize", logSize);
769 fitConfig.MinimizerOptions().ExtraOptions()->GetIntValue(
"HesseStrategy", hesseStrategy);
770 fitConfig.MinimizerOptions().ExtraOptions()->GetNamedValue(
"HesseStrategySequence", hs);
780 if (
auto nllDir = cacheDir->
GetDirectory(nll.GetName()); nllDir) {
781 if (
auto keys = nllDir->GetListOfKeys(); keys) {
782 for (
auto &&k : *keys) {
784 if (cl->InheritsFrom(
"RooFitResult")) {
786 nllDir->GetList() ?
dynamic_cast<StoredFitResult *
>(nllDir->GetList()->FindObject(k->GetName()))
789 (storedFr) ? storedFr->
fr.get() :
dynamic_cast<TKey *
>(k)->ReadObject<RooFitResult>();
793 nllDir->Add(storedFr);
798 if (!cachedFit->floatParsFinal().equals(*floatPars)) {
801 for (
auto &
p : *constPars) {
808 _p->getCurrentIndex() !=
c->getCurrentIndex()) {
817 if (
auto _p =
dynamic_cast<RooAbsReal *
>(cachedFit->constPars().find(
p->
GetName())); _p) {
820 if (!_p->getAttribute(
"global") && std::abs(_p->getVal() -
v->getVal()) > 1
e-12) {
843 if (nll.getAttribute(
"readOnly"))
846 int printLevel = fitConfig.MinimizerOptions().PrintLevel();
852 if (floatPars->empty() || fitConfig.MinimizerOptions().MaxFunctionCalls() == 1) {
853 std::shared_ptr<RooFitResult>
result;
855 parsList.
add(*floatPars);
857 result = std::make_shared<RooFitResult>();
859 result->SetTitle(resultTitle);
860 result->setFinalParList(parsList);
861 result->setInitParList(parsList);
865 result->setCovarianceMatrix(
d);
866 result->setCovQual(floatPars->empty() ? 3 : -1);
867 result->setMinNLL(_nll->getVal());
869 result->setStatus(floatPars->empty() ? 0 : 1);
871 std::vector<std::pair<std::string, int>> statusHistory;
872 statusHistory.emplace_back(std::make_pair(
"EVAL",
result->status()));
873 result->setStatusHistory(statusHistory);
878 cacheDir->
mkdir(nll.GetName());
879 if (
auto dir = cacheDir->
GetDirectory(nll.GetName()); dir) {
882 if (strlen(nllOpts->GetName()) == 0) {
885 if (!dir->FindKey(nllOpts->GetName())) {
886 dir->WriteObject(nllOpts.get(), nllOpts->GetName());
898 std::shared_ptr<RooFitResult> out;
902 for (
auto p : *floatPars) {
903 if (
p->isCategory()) {
907 if (!floatCats.
empty()) {
908 RooSuperCategory allCats(
"floatCats",
"Floating categorical parameters", floatCats);
909 std::unique_ptr<RooAbsCollection> _snap(floatCats.
snapshot());
912 std::shared_ptr<const RooFitResult> bestFr;
913 for (
auto c : allCats) {
915 Info(
"minimize",
"Minimizing with discrete %s",
c.first.c_str());
916 auto fr =
minimize(nll, _fitConfig, nllOpts);
918 Warning(
"minimize",
"Minimization with discrete %s failed",
c.first.c_str());
921 if (!bestFr || fr->minNll() < bestFr->minNll()) {
932 out = std::make_shared<RooFitResult>(*bestFr);
933 const_cast<RooArgList &
>(out->floatParsFinal())
934 .addClone(*std::unique_ptr<RooAbsCollection>(out->constPars().selectCommon(floatCats)));
935 const_cast<RooArgList &
>(out->floatParsInit()).addClone(*_snap);
936 const_cast<RooArgList &
>(out->constPars()).remove(floatCats);
940 bool restore = !fitConfig.UpdateAfterFit();
943 int strategy = fitConfig.MinimizerOptions().Strategy();
949 auto logger = (logSize > 0) ? std::make_unique<cout_redirect>(logs, logSize) :
nullptr;
951 _minimizer.
fitter()->Config() = fitConfig;
963 bool autoMaxCalls = (_minimizer.
fitter()->Config().MinimizerOptions().MaxFunctionCalls() == 0);
965 _minimizer.
fitter()->Config().MinimizerOptions().SetMaxFunctionCalls(
966 500 * floatPars->size() * floatPars->size());
968 if (_minimizer.
fitter()->Config().MinimizerOptions().MaxIterations() == 0) {
969 _minimizer.
fitter()->Config().MinimizerOptions().SetMaxIterations(500 * floatPars->size());
972 bool hesse = _minimizer.
fitter()->Config().ParabErrors();
973 _minimizer.
fitter()->Config().SetParabErrors(
975 bool minos = _minimizer.
fitter()->Config().MinosErrors();
976 _minimizer.
fitter()->Config().SetMinosErrors(
false);
977 _minimizer.
fitter()->Config().SetUpdateAfterFit(
true);
979 std::vector<std::pair<std::string, int>> statusHistory;
984 TString actualFirstMinimizer = _minimizer.
fitter()->Config().MinimizerType();
988 int constOptimize = 2;
989 _minimizer.
fitter()->Config().MinimizerOptions().ExtraOptions()->GetValue(
"OptimizeConst", constOptimize);
1009 TString minim = _minimizer.
fitter()->Config().MinimizerType();
1010 TString algo = _minimizer.
fitter()->Config().MinimizerAlgoType();
1011 if (minim ==
"Minuit2") {
1012 if (strategy == -1) {
1015 sIdx = m_strategy.
Index(
'0' + strategy);
1018 Warning(
"minimize",
"Strategy %d not specified in StrategySequence %s ... defaulting to start of sequence",
1019 strategy, m_strategy.
Data());
1022 }
else if (minim ==
"Minuit")
1023 sIdx = m_strategy.
Index(
'm');
1028 while (tries < maxtries && sIdx != -1) {
1029 if (m_strategy(sIdx) ==
'm') {
1031 algo =
"migradImproved";
1032 }
else if (m_strategy(sIdx) ==
's') {
1034 }
else if (m_strategy(sIdx) ==
'h') {
1037 strategy =
int(m_strategy(sIdx) -
'0');
1043 fff->fState = minim + algo + std::to_string(_minimizer.
fitter()->Config().MinimizerOptions().Strategy());
1046 status = _minimizer.
minimize(minim, algo);
1047 }
catch (
const std::exception &
e) {
1048 std::cerr <<
"Exception while minimizing: " <<
e.what() << std::endl;
1050 if (first && actualFirstMinimizer != _minimizer.
fitter()->Config().MinimizerType())
1051 actualFirstMinimizer = _minimizer.
fitter()->Config().MinimizerType();
1057 throw std::runtime_error(
"Keyboard interrupt while minimizing");
1061 status = _minimizer.
fitter()
1064 minim = _minimizer.
fitter()->Config().MinimizerType();
1065 statusHistory.emplace_back(_minimizer.
fitter()->Config().MinimizerType() +
1066 _minimizer.
fitter()->Config().MinimizerAlgoType() +
1067 std::to_string(_minimizer.
fitter()->Config().MinimizerOptions().Strategy()),
1069 if (status % 1000 == 0)
1072 if (status == 4 && minim !=
"Minuit") {
1073 if (printLevel >= -1) {
1074 Warning(
"fitTo",
"%s Hit max function calls of %d", fitName.
Data(),
1075 _minimizer.
fitter()->Config().MinimizerOptions().MaxFunctionCalls());
1078 if (printLevel >= -1)
1079 Warning(
"fitTo",
"will try doubling this");
1080 _minimizer.
fitter()->Config().MinimizerOptions().SetMaxFunctionCalls(
1081 _minimizer.
fitter()->Config().MinimizerOptions().MaxFunctionCalls() * 2);
1082 _minimizer.
fitter()->Config().MinimizerOptions().SetMaxIterations(
1083 _minimizer.
fitter()->Config().MinimizerOptions().MaxIterations() * 2);
1091 if (printLevel >= -1) {
1092 Warning(
"fitTo",
"%s %s%s Status=%d (edm=%f, tol=%f, strat=%d), tries=#%d...", fitName.
Data(),
1093 _minimizer.
fitter()->Config().MinimizerType().c_str(),
1094 _minimizer.
fitter()->Config().MinimizerAlgoType().c_str(), status,
1095 _minimizer.
fitter()->Result().Edm(), _minimizer.
fitter()->Config().MinimizerOptions().Tolerance(),
1096 _minimizer.
fitter()->Config().MinimizerOptions().Strategy(), tries);
1100 if (sIdx == m_strategy.
Length() - 1) {
1119 if (printLevel >= -1 && status != 0) {
1120 Warning(
"fitTo",
"%s final status is %d", fitName.
Data(), status);
1129 double dCovar = std::numeric_limits<double>::quiet_NaN();
1137 (m_strategy(sIdx) ==
'h' || ((strategy < 2 || _minimizer.
fitter()->GetMinimizer()->CovMatrixStatus() != 3) &&
1138 _minimizer.
fitter()->Result().IsValid()))) {
1161 if (hesseStrategy == -1) {
1164 sIdx = m_hessestrategy.
Index(
'0' + hesseStrategy);
1168 "HesseStrategy %d not specified in HesseStrategySequence %s ... defaulting to start of sequence",
1169 hesseStrategy, m_hessestrategy.
Data());
1172 while (sIdx != -1) {
1173 hesseStrategy =
int(m_hessestrategy(sIdx) -
'0');
1174 _minimizer.
fitter()->Config().MinimizerOptions().SetStrategy(hesseStrategy);
1179 fff->fState =
TString::Format(
"Hesse%d", _minimizer.
fitter()->Config().MinimizerOptions().Strategy());
1180 fff->counter2 = fff->counter;
1188 auto _status = _minimizer.
hesse();
1211 statusHistory.push_back(std::pair<std::string, int>(
1216 throw std::runtime_error(
"Keyboard interrupt while hesse calculating");
1218 if ((_status != 0 || _minimizer.
fitter()->GetMinimizer()->CovMatrixStatus() != 3) && status == 0 &&
1220 Warning(
"fitTo",
"%s hesse status is %d, covQual=%d", fitName.
Data(), _status,
1221 _minimizer.
fitter()->GetMinimizer()->CovMatrixStatus());
1224 if (sIdx >= m_hessestrategy.
Length() - 1) {
1228 if (_status == 0 && _minimizer.
fitter()->GetMinimizer()->CovMatrixStatus() == 3) {
1231 }
else if (_status == 0) {
1233 statusHistory.back().second = _minimizer.
fitter()->GetMinimizer()->CovMatrixStatus();
1240 if (status == 0 &&
minos) {
1241 if (std::unique_ptr<RooAbsCollection> mpars(floatPars->selectByAttrib(
"minos",
true)); !mpars->empty()) {
1243 fff->fState =
"Minos";
1245 auto _status = _minimizer.
minos(*mpars);
1246 statusHistory.push_back(std::pair(
"Minos", _status));
1255 out = std::unique_ptr<RooFitResult>{_minimizer.
save(fitName, resultTitle)};
1259 if (out->status() == 0 && out->covQual() != 3 && hesse) {
1260 if (out->covQual() == 2) {
1268 out->setStatusHistory(statusHistory);
1271 const_cast<RooArgList &
>(out->constPars()).addClone(fUserPars,
true);
1273 if (!std::isnan(dCovar)) {
1275 .addClone(
RooRealVar(
".dCovar",
"dCovar from minimization", dCovar),
true);
1278 if (boundaryCheck) {
1281 int limit_status = 0;
1282 std::string listpars;
1283 for (
auto *
v : dynamic_range_cast<RooRealVar *>(*floatPars)) {
1286 double vRange =
v->getMax() -
v->getMin();
1287 if (
v->getMin() >
v->getVal() - vRange * boundaryCheck ||
1288 v->getMax() <
v->getVal() + vRange * boundaryCheck) {
1292 auto tmp =
v->getVal();
1293 v->setVal(
v->getMin());
1294 double boundary_nll = _nll->getVal();
1295 if (boundary_nll <= out->minNll()) {
1296 static_cast<RooRealVar *
>(out->floatParsFinal().find(
v->GetName()))->
setVal(
v->getMin());
1297 out->setMinNLL(boundary_nll);
1305 if (
v->hasRange(
"physical"))
1307 listpars +=
v->GetName();
1310 (
v->getMin() >
v->getVal() -
v->getError() ||
v->getMax() <
v->getVal() +
v->getError())) {
1311 if (printLevel >= 0) {
1312 Info(
"minimize",
"PARLIM: %s (%f +/- %f) range (%f - %f)",
v->GetName(),
v->getVal(),
v->getError(),
1313 v->getMin(),
v->getMax());
1315 limit_status = 9000;
1318 if (limit_status == 900) {
1319 if (printLevel >= 0) {
1320 Warning(
"minimize",
"BOUNDCHK: Parameters within %g%% limit in fit result: %s", boundaryCheck * 100,
1323 }
else if (limit_status > 0) {
1324 if (printLevel >= 0)
1325 Warning(
"minimize",
"BOUNDCHK: Parameters near limit in fit result");
1329 statusHistory.emplace_back(
"BOUNDCHK", limit_status);
1330 out->setStatusHistory(statusHistory);
1331 out->setStatus(out->status() + limit_status);
1357 out->setMinNLL(_nll->getVal());
1360 for (
auto o : out->floatParsFinal()) {
1362 v && !
v->
getAttribute(
"minos") && !
v->getAttribute(
"xminos") && !
v->getAttribute(
"xMinos"))
1363 v->removeAsymError();
1367 if (fitConfig.MinimizerOptions().MinimizerType() != actualFirstMinimizer) {
1368 fitConfig.MinimizerOptions().SetMinimizerType(actualFirstMinimizer);
1376 if (status == 0 &&
minos) {
1377 for (
auto label : {
"xminos",
"xMinos"}) {
1378 std::unique_ptr<RooAbsCollection> pars(floatPars->selectByAttrib(label,
true));
1379 for (
auto p : *pars) {
1380 Info(
"minimize",
"Computing xminos error for %s",
p->
GetName());
1384 *floatPars = out->floatParsFinal();
1390 *floatPars = out->floatParsInit();
1393 if (out && !logs.empty()) {
1395#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 28, 00)
1396 const_cast<RooArgList &
>(out->constPars()).addOwned(std::make_unique<RooStringVar>(
".log",
"log", logs.c_str()));
1402 if (out && cacheDir && cacheDir->
IsWritable()) {
1406 cacheDir->
mkdir(nll.GetName());
1407 if (
auto dir = cacheDir->
GetDirectory(nll.GetName()); dir) {
1410 if (strlen(nllOpts->GetName()) == 0) {
1413 if (!dir->FindKey(nllOpts->GetName())) {
1414 dir->WriteObject(nllOpts.get(), nllOpts->GetName());
1419 std::string configName;
1420 if (!fitConfig.MinimizerOptions().ExtraOptions()->GetValue(
"Name", configName)) {
1421 auto extraOpts =
const_cast<ROOT::Math::IOptions *
>(fitConfig.MinimizerOptions().ExtraOptions());
1423 extraOpts->SetValue(
"Name", configName.data());
1425 if (!dir->GetKey(configName.data())) {
1426 dir->WriteObject(&fitConfig, configName.data());
1429#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 28, 00)
1431 .addOwned(std::make_unique<RooStringVar>(
".fitConfigName",
"fitConfigName", configName.c_str()));
1434 .addOwned(*
new RooStringVar(
".fitConfigName",
"fitConfigName", configName.c_str()));
1436 dir->WriteObject(out.get(), out->GetName());
1450 const std::shared_ptr<ROOT::Fit::FitConfig> &_fitConfig)
1453 auto par =
dynamic_cast<RooRealVar *
>(std::unique_ptr<RooArgSet>(nll.getVariables())->find(parName));
1462 auto &fitConfig = *myFitConfig;
1464 bool pErrs = fitConfig.ParabErrors();
1465 fitConfig.SetParabErrors(
false);
1466 double mErrs = fitConfig.MinosErrors();
1467 fitConfig.SetMinosErrors(
false);
1469 double val_best = par_hat->getVal();
1470 double val_err = (par_hat->hasError() ? par_hat->getError() : -1);
1471 double orig_err = val_err;
1472 double nll_min = ufit.
minNll();
1476 bool isConst = par->isConstant();
1477 par->setConstant(
true);
1479 auto findValue = [&](
double val_guess,
double N_sigma = 1,
double precision = 0.002,
int printLevel = 0) {
1482 double sigma_guess = std::abs((val_guess - val_best) / N_sigma);
1485 10 * precision * sigma_guess;
1486 bool lastOverflow =
false;
1487 bool lastUnderflow =
false;
1488 while (std::abs(val_pre - val_guess) > precision * sigma_guess) {
1489 val_pre = val_guess;
1490 if (val_guess > 0 && par->getMax() < val_guess)
1491 par->setMax(2 * val_guess);
1492 if (val_guess < 0 && par->getMin() > val_guess)
1493 par->setMin(2 * val_guess);
1494 par->setVal(val_guess);
1499 return std::numeric_limits<double>::quiet_NaN();
1501 double nll_val =
result->minNll();
1502 status +=
result->status() * 10;
1503 tmu = 2 * (nll_val - nll_min);
1504 sigma_guess = std::abs(val_guess - val_best) / sqrt(tmu);
1508 std::cout <<
"Warning: Alternative best-fit of " << par->GetName() <<
" @ " << val_guess <<
" vs "
1509 << val_best <<
" (delta=" << tmu / 2. <<
")" << std::endl;
1510 double new_guess = val_guess + (val_guess - val_best);
1511 val_best = val_guess;
1512 val_guess = new_guess;
1513 sigma_guess = std::abs((val_guess - val_best) / N_sigma);
1514 val_pre = val_guess - 10 * precision * sigma_guess;
1515 status = (status / 10) * 10 + 1;
1519 double corr = (val_pre - val_best - N_sigma * sigma_guess);
1524 if (printLevel > 1) {
1528 std::cout <<
"NLL min: " << nll_min << std::endl;
1529 std::cout <<
"N_sigma*sigma(pre): " << std::abs(val_pre - val_best) << std::endl;
1530 std::cout <<
"sigma(guess): " << sigma_guess << std::endl;
1531 std::cout <<
"par(guess): " << val_guess + corr << std::endl;
1532 std::cout <<
"true val: " << val_best << std::endl;
1533 std::cout <<
"tmu: " << tmu << std::endl;
1534 std::cout <<
"Precision: " << sigma_guess * precision << std::endl;
1535 std::cout <<
"Correction: " << (-corr < 0 ?
" " :
"") << -corr << std::endl;
1536 std::cout <<
"N_sigma*sigma(guess): " << std::abs(val_guess - val_best) << std::endl;
1537 std::cout << std::endl;
1539 if (val_guess > par->getMax()) {
1541 val_guess = par->getMin();
1544 lastOverflow =
true;
1545 lastUnderflow =
false;
1546 val_guess = par->getMax() - 1
e-12;
1547 }
else if (val_guess < par->getMin()) {
1548 if (lastUnderflow) {
1549 val_guess = par->getMin();
1552 lastOverflow =
false;
1553 lastUnderflow =
true;
1554 val_guess = par->getMin() + 1
e-12;
1556 lastUnderflow =
false;
1557 lastOverflow =
false;
1562 status = (status / 10) * 10 + 3;
1570 status = (status / 10) * 10 + 2;
1571 }
else if (lastUnderflow) {
1574 status = (status / 10) * 10 + 2;
1578 std::cout <<
"Found sigma for nll " << nll.GetName() <<
": " << (val_guess - val_best) / N_sigma << std::endl;
1580 std::cout <<
"Finished in " << nrItr <<
" iterations." << std::endl;
1582 std::cout << std::endl;
1583 return (val_guess - val_best) / N_sigma;
1588 par_hat->setError(std::numeric_limits<double>::quiet_NaN());
1589 double lo = par_hat->getErrorLo();
1590 double hi = par_hat->getErrorHi();
1591 if (std::isnan(
hi)) {
1592 hi = findValue(val_best + val_err, 1) + val_best -
1597 if (std::isnan(lo)) {
1598 lo = -findValue(val_best - val_err, -1) + val_best -
1604 fitConfig.SetParabErrors(pErrs);
1605 fitConfig.SetMinosErrors(mErrs);
1606 par->setConstant(isConst);
1608 std::vector<std::pair<std::string, int>> statusHistory;
1612 statusHistory.emplace_back(
TString::Format(
"xMinos:%s", parName), status);
1613 const_cast<RooFitResult &
>(ufit).setStatusHistory(statusHistory);
1626 std::deque<RooAbsArg *> topPdfs;
1628 for (
auto p :
w.allPdfs()) {
1629 if (
p->hasClients())
1631 flagCount +=
p->getAttribute(
"hypoTest");
1632 if (
p->getAttribute(
"hypoTest")) {
1633 topPdfs.push_front(
p);
1635 topPdfs.push_back(
p);
1638 if (topPdfs.empty()) {
1639 Error(
"hypoTest",
"Cannot find top-level pdf in workspace");
1641 }
else if (topPdfs.size() > 1) {
1643 if (flagCount == 0) {
1644 Error(
"hypoTest",
"Multiple top-level pdfs. Flag which one to test with "
1645 "w->pdf(\"pdfName\")->setAttribute(\"hypoTest\",true)");
1647 }
else if (flagCount != 1) {
1648 Error(
"hypoTest",
"Multiple top-level pdfs flagged for hypoTest -- pick one.");
1652 model =
dynamic_cast<RooAbsPdf *
>(topPdfs.front());
1654 Info(
"hypoTest",
"Using PDF: %s", model->
GetName());
1660 std::shared_ptr<RooArgSet> obsGlobs =
nullptr;
1662 for (
auto p :
w.allData()) {
1664 Error(
"hypoTest",
"Multiple datasets in workspace. Flag which one to test with "
1665 "w->data(\"dataName\")->setAttribute(\"hypoTest\",true)");
1672 Error(
"hypoTest",
"No data -- cannot determine observables");
1676 Info(
"hypoTest",
"Using Dataset: %s", obsData->
GetName());
1679 auto _globs = xRooNode(
w).datasets()[obsData->
GetName()]->globs();
1680 obsGlobs = std::make_shared<RooArgSet>();
1681 obsGlobs->addClone(_globs.argList());
1682 Info(
"hypoTest",
"Using Globs: %s", (obsGlobs->empty()) ?
" <NONE>" : obsGlobs->contentsString().c_str());
1687 auto _vars = std::unique_ptr<RooArgSet>(model->
getVariables());
1690 for (
auto _v : *_vars) {
1695 if (poi.
size() > 1) {
1696 auto _const = std::unique_ptr<RooAbsCollection>(poi.
selectByAttrib(
"Constant",
true));
1700 if (!args.
empty()) {
1704 Error(
"hypoTest",
"No POI detected: add the hypoPoints binning to at least one non-const model parameter e.g.:\n "
1705 "w->var(\"mu\")->setBinning(RooUniformBinning(0.5,10.5,10),\"hypoPoints\"))");
1717 xRooNLLVar
nll(*model, std::make_pair(obsData, obsGlobs.get()), *nllOpts);
1718 nll.SetFitConfig(fitConfig);
1720 if (poi.
size() == 1) {
1723 double altVal = (mu->getStringAttribute(
"altVal")) ?
TString(mu->getStringAttribute(
"altVal")).Atof()
1724 : std::numeric_limits<double>::quiet_NaN();
1726 if (std::isnan(altVal) && mu->hasRange(
"physical")) {
1728 altVal = mu->getMin(
"physical");
1729 Info(
"hypoTest",
"No altVal specified - using min of given physical range = %g", altVal);
1731 if (!std::isnan(altVal)) {
1732 Info(
"hypoTest",
"alt hypo: %g - CLs activated", altVal);
1734 Info(
"hypoTest",
"No altVal found - to specify setStringAttribute(\"altVal\",\"<value>\") on POI or set "
1735 "the physical range");
1738 bool doCLs = !std::isnan(altVal) && std::abs(mu->getMin(
"hypoPoints")) > altVal &&
1739 std::abs(mu->getMax(
"hypoPoints")) > altVal;
1741 const char *sCL = (doCLs) ?
"CLs" :
"null";
1742 Info(
"hypoTest",
"%s testing active", sCL);
1752 std::vector<int> expSig = {-2, -1, 0, 1, 2};
1753 if (std::isnan(altVal))
1755 std::map<int, TGraphErrors> exp_pcls;
1756 std::map<int, TGraphErrors> exp_cls;
1757 for (
auto &s : expSig) {
1759 TString::Format(
"Expected (%d#sigma) p_{%s};%s", s, sCL, mu->GetTitle()));
1761 TString::Format(
"Expected (%d#sigma) %s;%s", s, sCL, mu->GetTitle()));
1765 double _out = std::numeric_limits<double>::quiet_NaN();
1766 bool lastAbove =
false;
1767 for (
int i = 0; i < pValues.GetN(); i++) {
1768 bool thisAbove = pValues.GetPointY(i) >= (1. - CL);
1769 if (i != 0 && thisAbove != lastAbove) {
1772 _out = pValues.GetPointX(i - 1) + (pValues.GetPointX(i) - pValues.GetPointX(i - 1)) *
1773 ((1. - CL) - pValues.GetPointY(i - 1)) /
1774 (pValues.GetPointY(i) - pValues.GetPointY(i - 1));
1776 lastAbove = thisAbove;
1781 auto testPoint = [&](
double testVal) {
1782 auto hp =
nll.hypoPoint(mu->GetName(), testVal, altVal, pllType);
1783 obs_ts->SetPoint(obs_ts->GetN(), testVal, hp.pll().first);
1784 obs_ts->SetPointError(obs_ts->GetN() - 1, 0, hp.pll().second);
1786 if (nToysNull > 0) {
1789 obs_pcls->SetPoint(obs_pcls->GetN(), testVal, (doCLs) ? hp.pCLs_asymp().first : hp.pNull_asymp().first);
1790 obs_pcls->SetPointError(obs_pcls->GetN() - 1, 0, (doCLs) ? hp.pCLs_asymp().second : hp.pNull_asymp().second);
1791 for (
auto &s : expSig) {
1792 exp_pcls[s].SetPoint(exp_pcls[s].GetN(), testVal,
1793 (doCLs) ? hp.pCLs_asymp(s).first : hp.pNull_asymp(s).first);
1796 Info(
"hypoTest",
"%s=%g: %s=%g sigma_mu=%g %s=%g", mu->GetName(), testVal, obs_ts->GetName(),
1797 obs_ts->GetPointY(obs_ts->GetN() - 1), hp.sigma_mu().first, obs_pcls->GetName(),
1798 obs_pcls->GetPointY(obs_pcls->GetN() - 1));
1800 Info(
"hypoTest",
"%s=%g: %s=%g %s=%g", mu->GetName(), testVal, obs_ts->GetName(),
1801 obs_ts->GetPointY(obs_ts->GetN() - 1), obs_pcls->GetName(), obs_pcls->GetPointY(obs_pcls->GetN() - 1));
1805 if (mu->getBins(
"hypoPoints") <= 0) {
1808 testPoint(mu->getMin(
"hypoPoints"));
1809 testPoint(mu->getMax(
"hypoPoints"));
1810 testPoint((mu->getMax(
"hypoPoints") + mu->getMin(
"hypoPoints")) / 2.);
1812 while (std::abs(obs_pcls->GetPointY(obs_pcls->GetN() - 1) - (1. - CL)) > 0.01) {
1814 double nextTest = getLimit(*obs_pcls);
1815 if (std::isnan(nextTest))
1817 testPoint(nextTest);
1819 for (
auto s : expSig) {
1820 while (std::abs(exp_pcls[s].GetPointY(exp_pcls[s].GetN() - 1) - (1. - CL)) > 0.01) {
1822 double nextTest = getLimit(exp_pcls[s]);
1823 if (std::isnan(nextTest))
1825 testPoint(nextTest);
1830 for (
auto &s : expSig)
1834 for (
int i = 0; i <= mu->getBins(
"hypoPoints"); i++) {
1835 testPoint((i == mu->getBins(
"hypoPoints")) ? mu->getBinning(
"hypoPoints").binHigh(i - 1)
1836 : mu->getBinning(
"hypoPoints").binLow(i));
1840 obs_cls->SetPoint(obs_cls->GetN(), getLimit(*obs_pcls), 0.05);
1841 for (
auto &s : expSig) {
1842 exp_cls[s].SetPoint(exp_cls[s].GetN(), getLimit(exp_pcls[s]), 0.05);
1846 if (exp_pcls[2].GetN() > 1) {
1852 band2down->
SetNameTitle(
".pCLs_2sigma_downUncert",
"");
1858 for (
int i = 0; i < exp_pcls[2].GetN(); i++) {
1859 band2->
SetPoint(band2->
GetN(), exp_pcls[2].GetPointX(i),
1860 exp_pcls[2].GetPointY(i) - exp_pcls[2].GetErrorYlow(i));
1861 band2up->
SetPoint(band2up->
GetN(), exp_pcls[2].GetPointX(i),
1862 exp_pcls[2].GetPointY(i) + exp_pcls[2].GetErrorYhigh(i));
1864 for (
int i = exp_pcls[2].GetN() - 1; i >= 0; i--) {
1865 band2up->
SetPoint(band2up->
GetN(), exp_pcls[2].GetPointX(i),
1866 exp_pcls[2].GetPointY(i) - exp_pcls[2].GetErrorYlow(i));
1868 for (
int i = 0; i < exp_pcls[-2].GetN(); i++) {
1869 band2down->
SetPoint(band2down->
GetN(), exp_pcls[-2].GetPointX(i),
1870 exp_pcls[-2].GetPointY(i) + exp_pcls[-2].GetErrorYhigh(i));
1872 for (
int i = exp_pcls[-2].GetN() - 1; i >= 0; i--) {
1873 band2->
SetPoint(band2->
GetN(), exp_pcls[-2].GetPointX(i),
1874 exp_pcls[-2].GetPointY(i) + exp_pcls[-2].GetErrorYhigh(i));
1875 band2down->
SetPoint(band2down->
GetN(), exp_pcls[-2].GetPointX(i),
1876 exp_pcls[-2].GetPointY(i) - exp_pcls[-2].GetErrorYlow(i));
1881 auto ax =
static_cast<TNamed *
>(band2->
Clone(
".axis"));
1886 band2down->
Draw(
"F");
1889 if (exp_pcls[1].GetN() > 1) {
1895 band2down->
SetNameTitle(
".pCLs_1sigma_downUncert",
"");
1901 for (
int i = 0; i < exp_pcls[1].GetN(); i++) {
1902 band2->
SetPoint(band2->
GetN(), exp_pcls[1].GetPointX(i),
1903 exp_pcls[1].GetPointY(i) - exp_pcls[1].GetErrorYlow(i));
1904 band2up->
SetPoint(band2up->
GetN(), exp_pcls[1].GetPointX(i),
1905 exp_pcls[1].GetPointY(i) + exp_pcls[1].GetErrorYhigh(i));
1907 for (
int i = exp_pcls[1].GetN() - 1; i >= 0; i--) {
1908 band2up->
SetPoint(band2up->
GetN(), exp_pcls[1].GetPointX(i),
1909 exp_pcls[1].GetPointY(i) - exp_pcls[1].GetErrorYlow(i));
1911 for (
int i = 0; i < exp_pcls[-1].GetN(); i++) {
1912 band2down->
SetPoint(band2down->
GetN(), exp_pcls[-1].GetPointX(i),
1913 exp_pcls[-1].GetPointY(i) + exp_pcls[-1].GetErrorYhigh(i));
1915 for (
int i = exp_pcls[-1].GetN() - 1; i >= 0; i--) {
1916 band2->
SetPoint(band2->
GetN(), exp_pcls[-1].GetPointX(i),
1917 exp_pcls[-1].GetPointY(i) + exp_pcls[-1].GetErrorYhigh(i));
1918 band2down->
SetPoint(band2down->
GetN(), exp_pcls[-1].GetPointX(i),
1919 exp_pcls[-1].GetPointY(i) - exp_pcls[-1].GetErrorYlow(i));
1926 band2down->
Draw(
"F");
1930 if (exp_cls[0].GetN() > 0) {
1931 exp_pcls[0].SetLineStyle(2);
1932 exp_pcls[0].SetFillColor(
kGreen);
1933 exp_pcls[0].SetMarkerStyle(0);
1937 obs_pcls->Draw(
gPad->GetListOfPrimitives()->IsEmpty() ?
"ALP" :
"LP");
1939 obs_ts->SetLineColor(
kRed);
1940 obs_ts->SetMarkerColor(
kRed);
1944 auto l =
new TLegend(0.5, 0.6, 1. -
gPad->GetRightMargin(), 1. -
gPad->GetTopMargin());
1945 l->SetName(
"legend");
1946 l->AddEntry(obs_ts, obs_ts->GetTitle(),
"LPE");
1947 l->AddEntry(obs_pcls, obs_pcls->GetTitle(),
"LPE");
1949 l->AddEntry(expPlot,
"Expected",
"LFE");
1953 obs_cls->SetMarkerStyle(29);
1954 obs_cls->SetEditable(
false);
1955 obs_cls->Draw(
"LP");
1956 for (
auto s : expSig) {
1957 exp_cls[s].SetMarkerStyle(29);
1958 exp_cls[s].SetEditable(
false);
1959 exp_cls[s].DrawClone(
"LP");
1973 double factor = pow(10.0, digits - ceil(log10(std::abs(
value))));
1974 return std::round(
value * factor) / factor;
1978 const double multiplier = std::pow(10.0, decimal_places);
1979 return std::round(
value * multiplier) / multiplier;
1986 if (!std::isinf(out.second)) {
1987 auto tmp = out.second;
1989 int expo = (out.second == 0) ? 0 : (
int)std::floor(std::log10(std::abs(out.second)));
1992 out.first = (expo >= 0) ? round(out.first) :
round_to_decimal(out.first, -expo);
1993 }
else if (out.second != 0) {
1994 out.first = (expo >= 0) ? round(out.first) :
round_to_decimal(out.first, -expo + 1);
static void indent(ostringstream &buf, int indent_level)
void Info(const char *location, const char *msgfmt,...)
Use this function for informational messages.
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
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 Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
R__EXTERN TSystem * gSystem
double getValV(const RooArgSet *) const override
Return value of object.
double evaluate() const override
Evaluate this PDF / function / constant. Needs to be overridden by all derived classes.
bool setData(RooAbsData &data, bool cloneData) override
ProgressMonitor(const ProgressMonitor &other, const char *name=nullptr)
~ProgressMonitor() override
void printMultiline(std::ostream &os, Int_t contents, bool verbose=false, TString indent="") const override
Interface for detailed printing of object.
TObject * clone(const char *newname) const override
std::shared_ptr< RooAbsCollection > vars
bool getParameters(const RooArgSet *observables, RooArgSet &outputSet, bool stripDisconnected) const override
Fills a list with leaf nodes in the arg tree starting with ourself as top node that don't match any o...
void applyWeightSquared(bool flag) override
Disables or enables the usage of squared weights.
void constOptimizeTestStatistic(ConstOpCode opcode, bool doAlsoTrackingOpt) override
Interface function signaling a request to perform constant term optimization.
ProgressMonitor(RooAbsReal &f, int interval=30)
static ProgressMonitor * me
double defaultErrorLevel() const override
static void interruptHandler(int signum)
StoredFitResult(RooFitResult *_fr)
std::shared_ptr< RooFitResult > fr
static int minos(RooAbsReal &nll, const RooFitResult &ufit, const char *parName="", const std::shared_ptr< ROOT::Fit::FitConfig > &_fitConfig=nullptr)
static std::shared_ptr< const RooFitResult > minimize(RooAbsReal &nll, const std::shared_ptr< ROOT::Fit::FitConfig > &fitConfig=nullptr, const std::shared_ptr< RooLinkedList > &nllOpts=nullptr)
static std::shared_ptr< RooLinkedList > createNLLOptions()
static TCanvas * hypoTest(RooWorkspace &w, const xRooFit::Asymptotics::PLLType &pllType=xRooFit::Asymptotics::Unknown)
static std::shared_ptr< ROOT::Fit::FitConfig > createFitConfig()
static std::pair< double, double > matchPrecision(const std::pair< double, double > &in)
This xRooNLLVar object has several special methods, e.g.
xRooFitResult minimize(const std::shared_ptr< ROOT::Fit::FitConfig > &=nullptr)
Class describing the configuration of the fit, options and parameter settings using the ROOT::Fit::Pa...
class implementing generic options for a numerical algorithm Just store the options in a map of strin...
Generic interface for defining configuration options of a numerical algorithm.
void SetValue(const char *name, double val)
generic methods for retrieving options
Common abstract base class for objects that represent a value and a "shape" in RooFit.
bool dependsOn(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg=nullptr, bool valueOnly=false) const
Test whether we depend on (ie, are served by) any object in the specified collection.
RooWorkspace * _myws
Prevent 'AlwaysDirty' mode for this node.
bool isConstant() const
Check if the "Constant" attribute is set.
RooWorkspace * workspace() const
bool getAttribute(const Text_t *name) const
Check if a named attribute is set. By default, all attributes are unset.
RooFit::OwningPtr< RooArgSet > getVariables(bool stripDisconnected=true) const
Return RooArgSet with all variables (tree leaf nodes of expression tree)
RooAbsArg * findServer(const char *name) const
Return server of this with name name. Returns nullptr if not found.
A space to attach TBranches.
RooAbsCollection * selectByAttrib(const char *name, bool value) const
Create a subset of the current collection, consisting only of those elements with the specified attri...
double getRealValue(const char *name, double defVal=0.0, bool verbose=false) const
Get value of a RooAbsReal stored in set with given name.
virtual bool remove(const RooAbsArg &var, bool silent=false, bool matchByNameOnly=false)
Remove the specified argument from our list.
Storage_t const & get() const
Const access to the underlying stl container.
void assignFast(const RooAbsCollection &other, bool setValDirty=true) const
Functional equivalent of assign() but assumes this and other collection have same layout.
virtual bool add(const RooAbsArg &var, bool silent=false)
Add the specified argument to list.
void setAttribAll(const Text_t *name, bool value=true)
Set given attribute in each element of the collection by calling each elements setAttribute() functio...
Storage_t::size_type size() const
RooAbsArg * first() const
virtual RooAbsArg * addClone(const RooAbsArg &var, bool silent=false)
Add a clone of the specified argument to list.
std::string contentsString() const
Return comma separated list of contained object names as STL string.
RooAbsArg * find(const char *name) const
Find object with given name in list.
Abstract base class for binned and unbinned datasets.
Abstract interface for all probability density functions.
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.
RooArgList is a container object that can hold multiple RooAbsArg objects.
RooArgSet is a container object that can hold multiple RooAbsArg objects.
RooArgSet * snapshot(bool deepCopy=true) const
Use RooAbsCollection::snapshot(), but return as RooArgSet.
Implements a RooAbsBinning in terms of an array of boundary values, posing no constraints on the choi...
Named container for two doubles, two integers two object points and three string pointers that can be...
Container class to hold unbinned data.
RooRealVar * weightVar() const
Returns a pointer to the weight variable (if set).
RooFitResult is a container class to hold the input and output of a PDF fit to a dataset.
Int_t statusCodeHistory(UInt_t icycle) const
const char * statusLabelHistory(UInt_t icycle) const
const RooArgList & floatParsFinal() const
Return list of floating parameters after fit.
Int_t status() const
Return MINUIT status code.
UInt_t numStatusHistory() const
double minNll() const
Return minimized -log(L) value.
Collection class for internal use, storing a collection of RooAbsArg pointers in a doubly linked list...
Wrapper class around ROOT::Math::Minimizer that provides a seamless interface between the minimizer f...
void optimizeConst(int flag)
If flag is true, perform constant term optimization on function being minimized.
auto fitter()
Return underlying ROOT fitter object.
RooFit::OwningPtr< RooFitResult > save(const char *name=nullptr, const char *title=nullptr)
Save and return a RooFitResult snapshot of current minimizer status.
int minos()
Execute MINOS.
int hesse()
Execute HESSE.
int minimize(const char *type, const char *alg=nullptr)
Minimise the function passed in the constructor.
void setStrategy(int istrat)
Change MINUIT strategy to istrat.
static RooMsgService & instance()
Return reference to singleton instance.
void setGlobalKillBelow(RooFit::MsgLevel level)
RooFit::MsgLevel globalKillBelow() const
Implementation of a RooCacheManager<RooAbsCacheElement> that specializes in the storage of cache elem...
void setNoRounding(bool flag=true)
Switch off/on rounding of x to the nearest integer.
Efficient implementation of a product of PDFs of the form.
static TRandom * randomGenerator()
Return a pointer to a singleton random-number generator implementation.
Variable that can be changed from the outside.
void setVal(double value) override
Set value of variable to 'value'.
void setError(double value)
bool hasBinning(const char *name) const override
Returns true if variable has a binning named 'name'.
Facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset.
static RooAbsData * GenerateAsimovData(const RooAbsPdf &pdf, const RooArgSet &observables)
generate the asimov data for the observables (not the global ones) need to deal with the case of a si...
A RooAbsArg implementing string values.
Joins several RooAbsCategoryLValue objects into a single category.
bool setIndex(value_type index, bool printError=true) override
Set the value of the super category to the specified index.
Persistable container for RooFit projects.
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Using a TBrowser one can browse all ROOT objects.
void SetStatusText(const char *txt, Int_t col)
static TCanvas * MakeDefCanvas()
Static function to build a default canvas.
TClass instances represent classes, structs and namespaces in the ROOT type system.
TClass * IsA() const override
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130...
const char * AsString() const
Return the date & time as a string (ctime() format).
Describe directory structure in memory.
virtual TDirectory * GetDirectory(const char *namecycle, Bool_t printError=false, const char *funcname="GetDirectory")
Find a directory using apath.
virtual Bool_t IsWritable() const
virtual TDirectory * mkdir(const char *name, const char *title="", Bool_t returnExistingDirectory=kFALSE)
Create a sub-directory "a" or a hierarchy of sub-directories "a/b/c/...".
void SetName(const char *newname) override
Set the name for directory If the directory name is changed after the directory was written once,...
A TGraphErrors is a TGraph with error bars.
A TGraph is an object made of two arrays X and Y with npoints each.
virtual void SetPoint(Int_t i, Double_t x, Double_t y)
Set x and y values for point number i.
void Draw(Option_t *chopt="") override
Draw this graph with its current attributes.
void SetNameTitle(const char *name="", const char *title="") override
Set graph name and title.
Book space in a file, create I/O buffers, to fill them, (un)compress them.
This class displays a legend box (TPaveText) containing several legend entries.
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...
The TNamed class is the base class for all named ROOT classes.
TObject * Clone(const char *newname="") const override
Make a clone of an object using the Streamer facility.
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
const char * GetName() const override
Returns name of object.
Mother of all ROOT objects.
virtual const char * GetName() const
Returns name of object.
virtual TObject * DrawClone(Option_t *option="") const
Draw a clone of this object in the current selected pad with: gROOT->SetSelectedPad(c1).
virtual void Delete(Option_t *option="")
Delete this object.
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
virtual void Draw(Option_t *option="")
Default Draw method for all objects.
virtual void SetSeed(ULong_t seed=0)
Set the random generator seed.
virtual UInt_t Integer(UInt_t imax)
Returns a random integer uniformly distributed on the interval [ 0, imax-1 ].
Double_t RealTime()
Stop the stopwatch (if it is running) and return the realtime (in seconds) passed between the start a...
void Start(Bool_t reset=kTRUE)
Start the stopwatch.
void Continue()
Resume a stopped stopwatch.
Provides iteration through tokens of a given string.
Bool_t NextToken()
Get the next token, it is stored in this TString.
Double_t Atof() const
Return floating-point value contained in string.
Bool_t IsFloat() const
Returns kTRUE if string contains a floating point or integer number.
const char * Data() const
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
This class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDent...
TDatime GetTime() const
Get time from UUID.
const char * AsString() const
Return UUID as string. Copy string immediately since it will be reused.
RooCmdArg WeightVar(const char *name="weight", bool reinterpretAsWeight=false)
RooCmdArg Offset(std::string const &mode)
RooCmdArg Optimize(Int_t flag=2)
RooCmdArg Extended(bool flag=true)
RooCmdArg ExpectedData(bool flag=true)
double nll(double pdf, double weight, int binnedL, int doBinOffset)
MsgLevel
Verbosity level for RooMsgService::StreamConfig in RooMsgService.
void Sort(Index n, const Element *a, Index *index, Bool_t down=kTRUE)
Sort the n elements of the array a of generic templated type Element.
#define BEGIN_XROOFIT_NAMESPACE
#define END_XROOFIT_NAMESPACE
double round_to_decimal(double value, int decimal_places)
double round_to_digits(double value, int digits)