Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooGlobalFunc.cxx
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * @(#)root/roofitcore:$Id$
5 * Authors: *
6 * WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
7 * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8 * *
9 * Copyright (c) 2000-2005, Regents of the University of California *
10 * and Stanford University. All rights reserved. *
11 * *
12 * Redistribution and use in source and binary forms, *
13 * with or without modification, are permitted according to the terms *
14 * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
15 *****************************************************************************/
16
17// Global helper functions
18
19#include <RooGlobalFunc.h>
20
21#include <RooAbsData.h>
22#include <RooAbsPdf.h>
23#include <RooBatchCompute.h>
24#include <RooCategory.h>
25#include <RooDataHist.h>
26#include <RooDataSet.h>
27#include <RooFitResult.h>
28#include <RooFormulaVar.h>
29#include <RooHelpers.h>
30#include <RooMsgService.h>
31#include <RooNumIntConfig.h>
32#include <RooRealConstant.h>
33#include <RooRealVar.h>
34
35#include "RooEvaluatorWrapper.h"
36
37#include <TH1.h>
38#include <TInterpreter.h>
39
40#include <algorithm>
41
42namespace RooFit {
43
44/// Get the global choice for the RooBatchCompute library that RooFit will load.
45/// \see RooFit::setBatchCompute().
50
51/// Globally select the RooBatchCompute CPU implementation that will be loaded
52/// in RooFit.
53/// Supported options are "auto" (default), "avx512", "avx2", "avx", "sse", "generic".
54/// \note It is not possible to change the selection after RooFit has already
55/// loaded a library (which is usually triggered by likelihood creation or fitting).
56void setBatchCompute(std::string const &value)
57{
59}
60
61// anonymous namespace for helper functions for the implementation of the global functions
62namespace {
63
64template <class T>
65RooCmdArg processImportItem(std::string const &key, T *val)
66{
67 return Import(key.c_str(), *val);
68}
69
70template <class T>
71RooCmdArg processLinkItem(std::string const &key, T *val)
72{
73 return Link(key.c_str(), *val);
74}
75
76RooCmdArg processSliceItem(RooCategory *key, std::string const &val)
77{
78 return Slice(*key, val.c_str());
79}
80
81template <class Key_t, class Val_t, class Func_t>
82RooCmdArg processMap(const char *name, Func_t func, std::map<Key_t, Val_t> const &map)
83{
84 RooCmdArg container(name, 0, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
85 for (auto const &item : map) {
86 container.addArg(func(item.first, item.second));
87 }
88 container.setProcessRecArgs(true, false);
89 return container;
90}
91
92template <class Key_t, class Val_t, class Func_t>
93RooCmdArg processFlatMap(const char *name, Func_t func, Detail::FlatMap<Key_t, Val_t> const &map)
94{
95 RooCmdArg container(name, 0, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
96 for (std::size_t i = 0; i < map.keys.size(); ++i) {
97 container.addArg(func(map.keys[i], map.vals[i]));
98 }
99 container.setProcessRecArgs(true, false);
100 return container;
101}
102
103int interpretString(std::string const &s)
104{
105 return gInterpreter->ProcessLine(s.c_str());
106}
107
108Style_t interpretLineStyleString(std::string const &style)
109{
110 using Map = std::unordered_map<std::string, Style_t>;
111 // Style dictionary to define matplotlib conventions
112 static Map styleMap{{"-", kSolid}, {"--", kDashed}, {":", kDotted}, {"-.", kDashDotted}};
113 auto found = styleMap.find(style);
114 if (found != styleMap.end())
115 return found->second;
116 // Use interpreter if style was not matched in the style map
117 return gInterpreter->ProcessLine(style.c_str());
118}
119
120} // namespace
121
122namespace Experimental {
123
124RooCmdArg ParallelGradientOptions(bool enable, int orderStrategy, int chainFactor)
125{
126 return RooCmdArg("ParallelGradientOptions", enable, chainFactor, orderStrategy, 0, nullptr, nullptr, nullptr,
127 nullptr);
128}
129RooCmdArg ParallelDescentOptions(bool enable, int splitStrategy, int numSplits)
130{
131 return RooCmdArg("ParallelDescentOptions", enable, numSplits, splitStrategy, 0, nullptr, nullptr, nullptr, nullptr);
132}
133
134void writeCodegenDebugMacro(RooAbsReal const &absReal, std::string const &name)
135{
136 if (auto *wrapper = dynamic_cast<RooEvaluatorWrapper const *>(&absReal)) {
137 wrapper->writeDebugMacro(name);
138 }
139}
140
141} // namespace Experimental
142
143// RooAbsReal::plotOn arguments
144RooCmdArg DrawOption(const char *opt)
145{
146 return RooCmdArg("DrawOption", 0, 0, 0, 0, opt, nullptr, nullptr, nullptr);
147}
148RooCmdArg Slice(const RooArgSet &sliceSet)
149{
150 RooCmdArg out{"SliceVars", 0};
151 out.setSet(0, sliceSet);
152 return out;
153}
154RooCmdArg Slice(RooCategory &cat, const char *label)
155{
156 // We don't support adding multiple slices for a single category by
157 // concatenating labels with a comma. Users were trying to do that, and were
158 // surprised it did not work. So we explicitly check if there is a comma,
159 // and if there is, we will give some helpful advice on how to get to the
160 // desired plot.
161 std::string lbl{label};
162 if (lbl.find(',') != std::string::npos) {
163 std::stringstream errorMsg;
164 errorMsg << "RooFit::Slice(): you tried to pass a comma-separated list of state labels \"" << label
165 << "\" for a given category, but selecting multiple slices like this is not supported!"
166 << " If you want to make a plot of multiple slices, use the ProjWData() command where you pass a "
167 "dataset that includes "
168 "the desired slices. If the slices are a subset of all slices, then you can create such a dataset "
169 "with RooAbsData::reduce(RooFit::Cut(\"cat==cat::label_1 || cat==cat::label_2 || ...\")). You can "
170 "find some examples in the rf501_simultaneouspdf tutorial.";
171 oocoutE(nullptr, InputArguments) << errorMsg.str() << std::endl;
172 throw std::invalid_argument(errorMsg.str().c_str());
173 }
174 return RooCmdArg("SliceCat", 0, 0, 0, 0, label, nullptr, &cat, nullptr);
175}
176RooCmdArg Slice(std::map<RooCategory *, std::string> const &arg)
177{
178 return processMap("SliceCatMany", processSliceItem, arg);
179}
180
182{
183 RooCmdArg out{"Project", 0};
184 out.setSet(0, projSet);
185 return out;
186}
187RooCmdArg ProjWData(const RooArgSet &projSet, const RooAbsData &projData, bool binData)
188{
189 RooCmdArg out{"ProjData", binData, 0, 0, 0, nullptr, nullptr, nullptr, &projData};
190 out.setSet(0, projSet);
191 return out;
192}
193RooCmdArg ProjWData(const RooAbsData &projData, bool binData)
194{
195 return RooCmdArg("ProjData", binData, 0, 0, 0, nullptr, nullptr, nullptr, &projData);
196}
198{
199 return RooCmdArg("Asymmetry", 0, 0, 0, 0, nullptr, nullptr, &cat, nullptr);
200}
202{
203 return RooCmdArg("Precision", 0, 0, prec, 0, nullptr, nullptr, nullptr, nullptr);
204}
206{
207 return RooCmdArg("ShiftToZero", 1);
208}
209RooCmdArg Normalization(double scaleFactor)
210{
211 return RooCmdArg("Normalization", RooAbsReal::Relative, 0, scaleFactor, 0, nullptr, nullptr, nullptr, nullptr);
212}
213RooCmdArg Range(const char *rangeName, bool adjustNorm)
214{
215 return RooCmdArg("RangeWithName", adjustNorm, 0, 0, 0, rangeName, nullptr, nullptr, nullptr);
216}
217RooCmdArg Range(double lo, double hi, bool adjustNorm)
218{
219 return RooCmdArg("Range", adjustNorm, 0, lo, hi, nullptr, nullptr, nullptr, nullptr);
220}
221RooCmdArg NormRange(const char *rangeNameList)
222{
223 return RooCmdArg("NormRange", 0, 0, 0, 0, rangeNameList, nullptr, nullptr, nullptr);
224}
226{
227 return RooCmdArg("VLines", 1, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
228}
230{
231 return RooCmdArg("LineColor", color.number());
232}
234{
235 return RooCmdArg("LineStyle", style);
236}
237RooCmdArg LineStyle(std::string const &style)
238{
239 return LineStyle(interpretLineStyleString(style));
240}
242{
243 return RooCmdArg("LineWidth", width);
244}
246{
247 return RooCmdArg("FillColor", color.number());
248}
250{
251 return RooCmdArg("FillStyle", style);
252}
253RooCmdArg FillStyle(std::string const &style)
254{
255 return FillStyle(interpretString(style));
256}
257RooCmdArg ProjectionRange(const char *rangeName)
258{
259 return RooCmdArg("ProjectionRange", 0, 0, 0, 0, rangeName, nullptr, nullptr, nullptr);
260}
261RooCmdArg Name(const char *name)
262{
263 return RooCmdArg("Name", 0, 0, 0, 0, name, nullptr, nullptr, nullptr);
264}
266{
267 return RooCmdArg("Invisible", inv, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
268}
269RooCmdArg AddTo(const char *name, double wgtSel, double wgtOther)
270{
271 return RooCmdArg("AddTo", 0, 0, wgtSel, wgtOther, name, nullptr, nullptr, nullptr);
272}
274{
275 return RooCmdArg("EvalErrorValue", 1, 0, val, 0, nullptr, nullptr, nullptr, nullptr);
276}
278{
279 return RooCmdArg("MoveToBack", 1, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
280}
281RooCmdArg VisualizeError(const RooFitResult &fitres, double Z, bool linearMethod)
282{
283 return RooCmdArg("VisualizeError", linearMethod, 0, Z, 0, nullptr, nullptr, &fitres, nullptr);
284}
285RooCmdArg VisualizeError(const RooFitResult &fitres, const RooArgSet &param, double Z, bool linearMethod)
286{
287 return RooCmdArg("VisualizeError", linearMethod, 0, Z, 0, nullptr, nullptr, &fitres, nullptr, nullptr, nullptr,
288 &param);
289}
290RooCmdArg VisualizeError(const RooDataSet &paramData, double Z)
291{
292 return RooCmdArg("VisualizeErrorData", 0, 0, Z, 0, nullptr, nullptr, &paramData, nullptr);
293}
295{
296 return RooCmdArg("ShowProgress", 1, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
297}
298
299// RooAbsPdf::plotOn arguments
300RooCmdArg Components(const char *compSpec)
301{
302 return RooCmdArg("SelectCompSpec", 0, 0, 0, 0, compSpec, nullptr, nullptr, nullptr);
303}
304RooCmdArg Normalization(double scaleFactor, Int_t scaleType)
305{
306 return RooCmdArg("Normalization", scaleType, 0, scaleFactor, 0, nullptr, nullptr, nullptr, nullptr);
307}
308
309// RooAbsData::plotOn arguments
310RooCmdArg Cut(const char *cutSpec)
311{
312 return RooCmdArg("CutSpec", 0, 0, 0, 0, cutSpec, nullptr, nullptr, nullptr);
313}
315{
316 return RooCmdArg("CutVar", 0, 0, 0, 0, nullptr, nullptr, &cutVar, nullptr);
317}
319{
320 return RooCmdArg("Binning", 0, 0, 0, 0, nullptr, nullptr, &binning, nullptr);
321}
322RooCmdArg Binning(const char *binningName)
323{
324 return RooCmdArg("BinningName", 0, 0, 0, 0, binningName, nullptr, nullptr, nullptr);
325}
326RooCmdArg Binning(int nBins, double xlo, double xhi)
327{
328 return RooCmdArg("BinningSpec", nBins, 0, xlo, xhi, nullptr, nullptr, nullptr, nullptr);
329}
331{
332 return RooCmdArg("MarkerStyle", style, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
333}
334RooCmdArg MarkerStyle(std::string const &style)
335{
336 return MarkerStyle(interpretString(style));
337}
339{
340 return RooCmdArg("MarkerSize", 0, 0, size, 0, nullptr, nullptr, nullptr, nullptr);
341}
343{
344 return RooCmdArg("MarkerColor", color.number());
345}
346RooCmdArg CutRange(const char *rangeName)
347{
348 return RooCmdArg("CutRange", 0, 0, 0, 0, rangeName, nullptr, nullptr, nullptr);
349}
351{
352 return RooCmdArg("XErrorSize", 0, 0, width, 0, nullptr, nullptr, nullptr, nullptr);
353}
355{
356 return RooCmdArg("RefreshNorm", 1, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
357}
359{
360 return RooCmdArg("Efficiency", 0, 0, 0, 0, nullptr, nullptr, &cat, nullptr);
361}
362RooCmdArg Rescale(double factor)
363{
364 return RooCmdArg("Rescale", 0, 0, factor, 0, nullptr, nullptr, nullptr, nullptr);
365}
366
367// RooDataHist::ctor arguments
368RooCmdArg Weight(double wgt)
369{
370 return RooCmdArg("Weight", 0, 0, wgt, 0, nullptr, nullptr, nullptr, nullptr);
371}
373{
374 return RooCmdArg("IndexCat", 0, 0, 0, 0, nullptr, nullptr, &icat, nullptr);
375}
376RooCmdArg Import(const char *state, TH1 &histo)
377{
378 return RooCmdArg("ImportDataSlice", 0, 0, 0, 0, state, nullptr, &histo, nullptr);
379}
380RooCmdArg Import(const char *state, RooDataHist &dhist)
381{
382 return RooCmdArg("ImportDataSlice", 0, 0, 0, 0, state, nullptr, &dhist, nullptr);
383}
384RooCmdArg Import(TH1 &histo, bool importDensity)
385{
386 return RooCmdArg("ImportHisto", importDensity, 0, 0, 0, nullptr, nullptr, &histo, nullptr);
387}
388
389RooCmdArg Import(const std::map<std::string, RooDataHist *> &arg)
390{
391 return processMap("ImportDataSliceMany", processImportItem<RooDataHist>, arg);
392}
393RooCmdArg Import(const std::map<std::string, TH1 *> &arg)
394{
395 return processMap("ImportDataSliceMany", processImportItem<TH1>, arg);
396}
397
398// RooDataSet::ctor arguments
399RooCmdArg WeightVar(const char *name, bool reinterpretAsWeight)
400{
401 if (name == nullptr)
402 return RooCmdArg::none(); // Passing a nullptr name means no weight variable
403 return RooCmdArg("WeightVarName", reinterpretAsWeight, 0, 0, 0, name, nullptr, nullptr, nullptr);
404}
405RooCmdArg WeightVar(const RooRealVar &arg, bool reinterpretAsWeight)
406{
407 return RooCmdArg("WeightVar", reinterpretAsWeight, 0, 0, 0, nullptr, nullptr, &arg, nullptr);
408}
409RooCmdArg Link(const char *state, RooAbsData &data)
410{
411 return RooCmdArg("LinkDataSlice", 0, 0, 0, 0, state, nullptr, &data, nullptr);
412}
413RooCmdArg Import(const char *state, RooAbsData &data)
414{
415 return RooCmdArg("ImportDataSlice", 0, 0, 0, 0, state, nullptr, &data, nullptr);
416}
418{
419 return RooCmdArg("ImportData", 0, 0, 0, 0, nullptr, nullptr, &data, nullptr);
420}
422{
423 return RooCmdArg("ImportTree", 0, 0, 0, 0, nullptr, nullptr, reinterpret_cast<TObject *>(&tree), nullptr);
424}
425RooCmdArg ImportFromFile(const char *fname, const char *tname)
426{
427 return RooCmdArg("ImportFromFile", 0, 0, 0, 0, fname, tname, nullptr, nullptr);
428}
430{
431 return RooCmdArg("StoreError", 0, 0, 0, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &aset);
432}
434{
435 return RooCmdArg("StoreAsymError", 0, 0, 0, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &aset);
436}
438{
439 return RooCmdArg("OwnLinked", 1, 0, 0, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
440}
441
442RooCmdArg Import(const std::map<std::string, RooDataSet *> &arg)
443{
444 return processMap("ImportDataSliceMany", processImportItem<RooDataSet>, arg);
445}
446RooCmdArg Link(const std::map<std::string, RooAbsData *> &arg)
447{
448 return processMap("LinkDataSliceMany", processLinkItem<RooAbsData>, arg);
449}
450
451// createChi2() / createNLL() arguments
453{
454 return RooCmdArg("Extended", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
455}
457{
458 return RooCmdArg("DataError", etype);
459}
460RooCmdArg DataError(std::string const &etype)
461{
463}
464RooCmdArg NumCPU(Int_t nCPU, Int_t interleave)
465{
466 return RooCmdArg("NumCPU", nCPU, interleave, 0, 0, nullptr, nullptr, nullptr, nullptr);
467}
469{
470 return RooCmdArg("ModularL", flag, 0, 0, 0, nullptr, nullptr, nullptr);
471}
473{
474 return RooCmdArg("Parallelize", nWorkers, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
475}
477{
478 return RooCmdArg("TimingAnalysis", flag, 0, 0, 0, nullptr, nullptr, nullptr);
479}
480/// Integrate the PDF over bins. Improves accuracy for binned fits. Switch off using `0.` as argument. \see
481/// RooAbsPdf::fitTo().
482RooCmdArg IntegrateBins(double precision)
483{
484 return RooCmdArg("IntegrateBins", 0, 0, precision);
485}
486
487// RooAbsCollection::printLatex arguments
489{
490 return RooCmdArg("Columns", ncol, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
491}
492RooCmdArg OutputFile(const char *fileName)
493{
494 return RooCmdArg("OutputFile", 0, 0, 0, 0, fileName, nullptr, nullptr, nullptr);
495}
497{
498 return RooCmdArg("Sibling", 0, 0, 0, 0, nullptr, nullptr, &sibling, nullptr);
499}
500RooCmdArg Format(const char *what, const RooCmdArg &arg1, const RooCmdArg &arg2, const RooCmdArg &arg3,
501 const RooCmdArg &arg4, const RooCmdArg &arg5, const RooCmdArg &arg6, const RooCmdArg &arg7,
502 const RooCmdArg &arg8)
503{
504 RooCmdArg ret("FormatArgs", 0, 0, 0, 0, what, nullptr, nullptr, nullptr);
505 ret.addArg(arg1);
506 ret.addArg(arg2);
507 ret.addArg(arg3);
508 ret.addArg(arg4);
509 ret.addArg(arg5);
510 ret.addArg(arg6);
511 ret.addArg(arg7);
512 ret.addArg(arg8);
513 ret.setProcessRecArgs(false);
514 return ret;
515}
516
517// RooAbsRealLValue::frame arguments
518RooCmdArg Title(const char *name)
519{
520 return RooCmdArg("Title", 0, 0, 0, 0, name, nullptr, nullptr, nullptr);
521}
523{
524 return RooCmdArg("Bins", nbin, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
525}
526RooCmdArg AutoSymRange(const RooAbsData &data, double marginFactor)
527{
528 return RooCmdArg("AutoRange", 1, 0, marginFactor, 0, nullptr, nullptr, &data, nullptr);
529}
530RooCmdArg AutoRange(const RooAbsData &data, double marginFactor)
531{
532 return RooCmdArg("AutoRange", 0, 0, marginFactor, 0, nullptr, nullptr, &data, nullptr);
533}
534
535// RooAbsData::reduce arguments
537{
538 RooCmdArg out{"SelectVars", 0};
539 out.setSet(0, vars);
540 return out;
541}
543{
544 return RooCmdArg("EventRange", nStart, nStop, 0, 0, nullptr, nullptr, nullptr, nullptr);
545}
546
547// RooAbsPdf::fitTo arguments
548
550{
551#ifndef ROOFIT_CLAD
552 if (value == Value::Codegen) {
553 oocoutE(nullptr, InputArguments)
554 << "RooFit was built without clad. The \"codegen\" backend is unavailable. Falling back to default.\n";
555 setInt(0, static_cast<int>(defaultValue()));
556 }
557#endif
558}
559EvalBackend::EvalBackend(std::string const &name) : EvalBackend{toValue(name)} {}
561{
562 std::string lower = name;
563 std::transform(lower.begin(), lower.end(), lower.begin(), [](unsigned char c) { return std::tolower(c); });
564 if (lower == toName(Value::Cpu))
565 return Value::Cpu;
566 if (lower == toName(Value::Cuda))
567 return Value::Cuda;
568 if (lower == toName(Value::Codegen))
569 return Value::Codegen;
570 if (lower == toName(Value::CodegenNoGrad))
572 if (lower == "legacy") {
573 throw std::runtime_error("The \"legacy\" evaluation backend was removed in ROOT 6.44. Please use the default "
574 "\"cpu\" backend instead.");
575 }
576 throw std::runtime_error("Only supported string values for EvalBackend() are \"cpu\", \"cuda\", "
577 "\"codegen\", or \"codegen_no_grad\".");
578}
595std::string EvalBackend::name() const
596{
597 return toName(value());
598}
600{
601 if (value == Value::Cpu)
602 return "cpu";
603 if (value == Value::Cuda)
604 return "cuda";
605 if (value == Value::Codegen)
606 return "codegen";
608 return "codegen_no_grad";
609 return "";
610}
616
618{
619 return RooCmdArg("Prefit", 0, 0, data_ratio, 0, nullptr, nullptr, nullptr, nullptr);
620}
621
622/// \deprecated Has no effect anymore. Functionality was removed in ROOT 6.42,
623/// and this function is kept as an empty shell that does nothing (for API
624/// compatibility between different ROOT versions).
626{
627 return RooCmdArg{};
628}
630{
631 return RooCmdArg("Verbose", flag);
632}
633RooCmdArg Save(bool flag)
634{
635 return RooCmdArg("Save", flag);
636}
637RooCmdArg Timer(bool flag)
638{
639 return RooCmdArg("Timer", flag);
640}
642{
643 return RooCmdArg("PrintLevel", level);
644}
646{
647 return RooCmdArg("MaxCalls", n);
648}
650{
651 return RooCmdArg("Warnings", flag);
652}
654{
655 return RooCmdArg("Strategy", code);
656}
658{
659 return RooCmdArg("InitialHesse", flag);
660}
661RooCmdArg Hesse(bool flag)
662{
663 return RooCmdArg("Hesse", flag);
664}
665RooCmdArg Minos(bool flag)
666{
667 return RooCmdArg("Minos", flag);
668}
669RooCmdArg Minos(const RooArgSet &minosArgs)
670{
671 RooCmdArg out{"Minos", 1};
672 out.setSet(0, minosArgs);
673 return out;
674}
676{
677 return RooCmdArg("SplitRange", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
678}
679RooCmdArg SumCoefRange(const char *rangeName)
680{
681 return RooCmdArg("SumCoefRange", 0, 0, 0, 0, rangeName, nullptr, nullptr, nullptr);
682}
684{
685 for (RooAbsArg *param : params) {
686 if (!dynamic_cast<RooRealVar *>(param)) {
687 std::stringstream errorMsg;
688 errorMsg << "RooFit::Constrain(): you passed the argument \"" << param->GetName()
689 << "\", but it's not a RooRealVar!"
690 << " You can only constrain parameters, which must be RooRealVars.";
691 oocoutE(nullptr, InputArguments) << errorMsg.str() << std::endl;
692 throw std::invalid_argument(errorMsg.str().c_str());
693 }
694 }
695 return RooCmdArg("Constrain", 0, 0, 0, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &params);
696}
697RooCmdArg GlobalObservablesSource(const char *sourceName)
698{
699 return {"GlobalObservablesSource", 0, 0, 0, 0, sourceName, nullptr, nullptr, nullptr};
700}
701RooCmdArg GlobalObservablesTag(const char *tagName)
702{
703 return RooCmdArg("GlobalObservablesTag", 0, 0, 0, 0, tagName, nullptr, nullptr, nullptr);
704}
706{
707 return RooCmdArg("ExternalConstraints", 0, 0, 0, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
708 &constraintPdfs);
709}
711{
712 return RooCmdArg("PrintEvalErrors", numErrors, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
713}
715{
716 return RooCmdArg("EvalErrorWall", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
717}
719{
720 return RooCmdArg("SumW2Error", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
721}
723{
724 return RooCmdArg("AsymptoticError", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
725}
727{
728 oocoutI(nullptr, InputArguments) << "The deprecated RooFit::CloneData(" << flag
729 << ") option passed to createNLL() is ignored." << std::endl;
730 return RooCmdArg("CloneData", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
731}
733{
734 return RooCmdArg("Integrate", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
735}
736RooCmdArg Minimizer(const char *type, const char *alg)
737{
738 return RooCmdArg("Minimizer", 0, 0, 0, 0, type, alg, nullptr, nullptr);
739}
740
741RooCmdArg Offset(std::string const &mode)
742{
743 std::string lower = mode;
744 std::transform(lower.begin(), lower.end(), lower.begin(), [](unsigned char c) { return std::tolower(c); });
746 if (lower == "none") {
747 modeVal = OffsetMode::None;
748 } else if (lower == "initial") {
749 modeVal = OffsetMode::Initial;
750 } else if (lower == "bin") {
751 modeVal = OffsetMode::Bin;
752 }
753 return RooCmdArg("OffsetLikelihood", static_cast<int>(modeVal));
754}
755
756/// When parameters are chosen such that a PDF is undefined, try to indicate to the minimiser how to leave this region.
757/// \param strength Strength of hints for minimiser. Set to zero to switch off.
759{
760 return RooCmdArg("RecoverFromUndefinedRegions", 0, 0, strength, 0, nullptr, nullptr, nullptr, nullptr);
761}
762
763// RooAbsPdf::paramOn arguments
764RooCmdArg Label(const char *str)
765{
766 return RooCmdArg("Label", 0, 0, 0, 0, str, nullptr, nullptr, nullptr);
767}
768RooCmdArg Layout(double xmin, double xmax, double ymin)
769{
770 return RooCmdArg("Layout", Int_t(ymin * 10000), 0, xmin, xmax, nullptr, nullptr, nullptr, nullptr);
771}
773{
774 RooCmdArg out{"Parameters", 0};
775 out.setSet(0, params);
776 return out;
777}
779{
780 return RooCmdArg("ShowConstants", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
781}
782
783// RooTreeData::statOn arguments
784RooCmdArg What(const char *str)
785{
786 return RooCmdArg("What", 0, 0, 0, 0, str, nullptr, nullptr, nullptr);
787}
788
789// RooProdPdf::ctor arguments
790RooCmdArg Conditional(const RooArgSet &pdfSet, const RooArgSet &depSet, bool depsAreCond)
791{
792 return RooCmdArg("Conditional", depsAreCond, 0, 0, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &pdfSet,
793 &depSet);
794};
795
796// RooAbsPdf::generate arguments
797RooCmdArg ProtoData(const RooAbsData &protoData, bool randomizeOrder, bool resample)
798{
799 return RooCmdArg("PrototypeData", randomizeOrder, resample, 0, 0, nullptr, nullptr, &protoData, nullptr);
800}
802{
803 return RooCmdArg("NumEvents", numEvents, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
804}
805RooCmdArg NumEvents(double numEvents)
806{
807 return RooCmdArg("NumEventsD", 0, 0, numEvents, 0, nullptr, nullptr, nullptr, nullptr);
808}
810{
811 return RooCmdArg("ExpectedData", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
812}
814{
815 return ExpectedData(flag);
816}
818{
819 return RooCmdArg("AutoBinned", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
820}
821RooCmdArg GenBinned(const char *tag)
822{
823 return RooCmdArg("GenBinned", 0, 0, 0, 0, tag, nullptr, nullptr, nullptr);
824}
826{
827 return RooCmdArg("GenBinned", 0, 0, 0, 0, "*", nullptr, nullptr, nullptr);
828}
829
830// RooAbsRealLValue::createHistogram arguments
832{
833 return RooCmdArg("YVar", 0, 0, 0, 0, nullptr, nullptr, &var, nullptr, &arg);
834}
836{
837 return RooCmdArg("ZVar", 0, 0, 0, 0, nullptr, nullptr, &var, nullptr, &arg);
838}
840{
841 return RooCmdArg("AxisLabel", 0, 0, 0, 0, name, nullptr, nullptr, nullptr);
842}
844{
845 return RooCmdArg("Scaling", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
846}
847
848// RooAbsReal::createHistogram arguments
850{
851 return RooCmdArg("IntrinsicBinning", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
852}
853
854// RooAbsData::createHistogram arguments
855RooCmdArg AutoSymBinning(Int_t nbins, double marginFactor)
856{
857 return RooCmdArg("AutoRangeData", 1, nbins, marginFactor, 0, nullptr, nullptr, nullptr, nullptr);
858}
859RooCmdArg AutoBinning(Int_t nbins, double marginFactor)
860{
861 return RooCmdArg("AutoRangeData", 0, nbins, marginFactor, 0, nullptr, nullptr, nullptr, nullptr);
862}
863
864// RooAbsReal::fillHistogram arguments
866{
867 return RooCmdArg("IntObs", 0, 0, 0, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &intObs, nullptr);
868};
869
870// RooAbsReal::createIntegral arguments
872{
873 return RooCmdArg("NumIntConfig", 0, 0, 0, 0, nullptr, nullptr, &cfg, nullptr);
874}
875
876// RooMCStudy::ctor arguments
878{
879 return RooCmdArg("Silence", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
880}
882{
883 return RooCmdArg("FitModel", 0, 0, 0, 0, nullptr, nullptr, &pdf, nullptr);
884}
885RooCmdArg FitOptions(const RooCmdArg &arg1, const RooCmdArg &arg2, const RooCmdArg &arg3, const RooCmdArg &arg4,
886 const RooCmdArg &arg5, const RooCmdArg &arg6)
887{
888 RooCmdArg ret("FitOptArgs", 0, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
889 ret.addArg(arg1);
890 ret.addArg(arg2);
891 ret.addArg(arg3);
892 ret.addArg(arg4);
893 ret.addArg(arg5);
894 ret.addArg(arg6);
895 ret.setProcessRecArgs(false);
896 return ret;
897}
899{
900 return RooCmdArg("Binned", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
901}
903{
904 return RooCmdArg("BootStrapData", 0, 0, 0, 0, nullptr, nullptr, &dset, nullptr);
905}
906
907// RooMCStudy::plot* arguments
908RooCmdArg Frame(const RooCmdArg &arg1, const RooCmdArg &arg2, const RooCmdArg &arg3, const RooCmdArg &arg4,
909 const RooCmdArg &arg5, const RooCmdArg &arg6)
910{
911 RooCmdArg ret("FrameArgs", 0, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
912 ret.addArg(arg1);
913 ret.addArg(arg2);
914 ret.addArg(arg3);
915 ret.addArg(arg4);
916 ret.addArg(arg5);
917 ret.addArg(arg6);
918 ret.setProcessRecArgs(false);
919 return ret;
920}
922{
923 return RooCmdArg("Bins", nbins, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
924}
925RooCmdArg FrameRange(double xlo, double xhi)
926{
927 return RooCmdArg("Range", 0, 0, xlo, xhi, nullptr, nullptr, nullptr, nullptr);
928}
930{
931 return RooCmdArg("FitGauss", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
932}
933
934// RooRealVar::format arguments
936{
937 return RooCmdArg("ShowName", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
938}
940{
941 return RooCmdArg("ShowValue", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
942}
944{
945 return RooCmdArg("ShowError", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
946}
948{
949 return RooCmdArg("ShowAsymError", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
950}
952{
953 return RooCmdArg("ShowUnit", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
954}
956{
957 return RooCmdArg("AutoPrecision", ndigit, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
958}
960{
961 return RooCmdArg("FixedPrecision", ndigit, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
962}
964{
965 return RooCmdArg("TLatexStyle", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
966}
968{
969 return RooCmdArg("LatexStyle", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
970}
972{
973 return RooCmdArg("LatexTableStyle", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
974}
976{
977 return RooCmdArg("VerbatimName", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
978}
979
980// RooMsgService::addReportingStream arguments
982{
983 return RooCmdArg("Topic", topic, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
984}
986{
987 return RooCmdArg("ObjectName", 0, 0, 0, 0, name, nullptr, nullptr, nullptr);
988}
990{
991 return RooCmdArg("ClassName", 0, 0, 0, 0, name, nullptr, nullptr, nullptr);
992}
994{
995 return RooCmdArg("BaseClassName", 0, 0, 0, 0, name, nullptr, nullptr, nullptr);
996}
998{
999 return RooCmdArg("LabelName", 0, 0, 0, 0, name, nullptr, nullptr, nullptr);
1000}
1001RooCmdArg OutputStream(std::ostream &os)
1002{
1003 return RooCmdArg("OutputStream", 0, 0, 0, 0, nullptr, nullptr, new RooHelpers::WrapIntoTObject<std::ostream>(os),
1004 nullptr);
1005}
1007{
1008 return RooCmdArg("Prefix", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
1009}
1011{
1012 return RooCmdArg("Color", color.number());
1013}
1014
1015// RooWorkspace::import() arguments
1016RooCmdArg RenameConflictNodes(const char *suffix, bool renameOrigNodes)
1017{
1018 return RooCmdArg("RenameConflictNodes", renameOrigNodes, 0, 0, 0, suffix, nullptr, nullptr, nullptr);
1019}
1021{
1022 return RooCmdArg("RecycleConflictNodes", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
1023}
1024RooCmdArg RenameAllNodes(const char *suffix)
1025{
1026 return RooCmdArg("RenameAllNodes", 0, 0, 0, 0, suffix, nullptr, nullptr, nullptr);
1027}
1029{
1030 return RooCmdArg("RenameAllVariables", 0, 0, 0, 0, suffix, nullptr, nullptr, nullptr);
1031}
1032RooCmdArg RenameAllVariablesExcept(const char *suffix, const char *except)
1033{
1034 return RooCmdArg("RenameAllVariables", 0, 0, 0, 0, suffix, except, nullptr, nullptr);
1035}
1036RooCmdArg RenameVariable(const char *in, const char *out)
1037{
1038 return RooCmdArg("RenameVar", 0, 0, 0, 0, in, out, nullptr, nullptr);
1039}
1040RooCmdArg Rename(const char *suffix)
1041{
1042 return RooCmdArg("Rename", 0, 0, 0, 0, suffix, nullptr, nullptr, nullptr);
1043}
1045{
1046 return RooCmdArg("Embedded", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
1047}
1049{
1050 return RooCmdArg("NoRecursion", flag, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
1051}
1052
1053// RooSimCloneTool::build() arguments
1054RooCmdArg SplitParam(const char *varname, const char *catname)
1055{
1056 return RooCmdArg("SplitParam", 0, 0, 0, 0, varname, catname, nullptr, nullptr);
1057}
1059{
1060 return RooCmdArg("SplitParam", 0, 0, 0, 0, var.GetName(), cat.GetName(), nullptr, nullptr);
1061}
1062RooCmdArg SplitParamConstrained(const char *varname, const char *catname, const char *rsname)
1063{
1064 return RooCmdArg("SplitParamConstrained", 0, 0, 0, 0, varname, catname, nullptr, nullptr, nullptr, rsname);
1065}
1066RooCmdArg SplitParamConstrained(const RooRealVar &var, const RooAbsCategory &cat, const char *rsname)
1067{
1068 return RooCmdArg("SplitParamConstrained", 0, 0, 0, 0, var.GetName(), cat.GetName(), nullptr, nullptr, nullptr,
1069 rsname);
1070}
1071RooCmdArg Restrict(const char *catName, const char *stateNameList)
1072{
1073 return RooCmdArg("Restrict", 0, 0, 0, 0, catName, stateNameList, nullptr, nullptr);
1074}
1075
1076// RooAbsPdf::createCdf() arguments
1078{
1079 RooCmdArg out{"SupNormSet", 0};
1080 out.setSet(0, nset);
1081 return out;
1082}
1084{
1085 return RooCmdArg("ScanParameters", nbins, intOrder, 0, 0, nullptr, nullptr, nullptr, nullptr);
1086}
1088{
1089 return RooCmdArg("ScanNumCdf", 1, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
1090}
1092{
1093 return RooCmdArg("ScanAllCdf", 1, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
1094}
1096{
1097 return RooCmdArg("ScanNoCdf", 1, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
1098}
1099
1100RooCmdArg MultiArg(const RooCmdArg &arg1, const RooCmdArg &arg2, const RooCmdArg &arg3, const RooCmdArg &arg4,
1101 const RooCmdArg &arg5, const RooCmdArg &arg6, const RooCmdArg &arg7, const RooCmdArg &arg8)
1102{
1103 RooCmdArg ret("MultiArg", 0, 0, 0, 0, nullptr, nullptr, nullptr, nullptr);
1104 ret.addArg(arg1);
1105 ret.addArg(arg2);
1106 ret.addArg(arg3);
1107 ret.addArg(arg4);
1108 ret.addArg(arg5);
1109 ret.addArg(arg6);
1110 ret.addArg(arg7);
1111 ret.addArg(arg8);
1112 ret.setProcessRecArgs(true, false);
1113 return ret;
1114}
1115
1117{
1118 return RooRealConstant::value(val);
1119}
1120
1121namespace Detail {
1122
1124{
1125 return processFlatMap("SliceCatMany", processSliceItem, args);
1126}
1128{
1129 return processFlatMap("ImportDataSliceMany", processImportItem<RooDataHist>, args);
1130}
1132{
1133 return processFlatMap("ImportDataSliceMany", processImportItem<TH1>, args);
1134}
1136{
1137 return processFlatMap("ImportDataSliceMany", processImportItem<RooDataSet>, args);
1138}
1140{
1141 return processFlatMap("LinkDataSliceMany", processLinkItem<RooAbsData>, args);
1142}
1143
1144} // namespace Detail
1145
1146} // namespace RooFit
1147
1148namespace RooFitShortHand {
1149
1151{
1152 return RooFit::RooConst(value);
1153}
1154
1155} // namespace RooFitShortHand
#define c(i)
Definition RSha256.hxx:101
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
#define oocoutE(o, a)
#define oocoutI(o, a)
short Style_t
Style number (short)
Definition RtypesCore.h:97
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:60
float Size_t
Attribute size (float)
Definition RtypesCore.h:104
short Width_t
Line width (short)
Definition RtypesCore.h:99
@ kDashed
Definition TAttLine.h:54
@ kSolid
Definition TAttLine.h:54
@ kDashDotted
Definition TAttLine.h:54
@ kDotted
Definition TAttLine.h:54
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 value
Option_t Option_t TPoint TPoint const char mode
Option_t Option_t width
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
Option_t Option_t style
char name[80]
Definition TGX11.cxx:142
float xmin
#define hi
float ymin
float xmax
#define gInterpreter
void(* Func_t)()
Definition TSystem.h:249
Common abstract base class for objects that represent a value and a "shape" in RooFit.
Definition RooAbsArg.h:77
Abstract base class for RooRealVar binning definitions.
A space to attach TBranches.
Abstract container object that can hold multiple RooAbsArg objects.
Abstract base class for binned and unbinned datasets.
Definition RooAbsData.h:55
static ErrorType errorTypeFromString(std::string const &name)
Convert a string to the value of the RooAbsData::ErrorType enum with the same name.
Abstract interface for all probability density functions.
Definition RooAbsPdf.h:32
Abstract base class for objects that represent a real value that may appear on the left hand side of ...
Abstract base class for objects that represent a real value and implements functionality common to al...
Definition RooAbsReal.h:63
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition RooArgSet.h:24
Object to represent discrete states.
Definition RooCategory.h:28
Named container for two doubles, two integers two object points and three string pointers that can be...
Definition RooCmdArg.h:26
void addArg(const RooCmdArg &arg)
Utility function to add nested RooCmdArg to payload of this RooCmdArg.
void setInt(Int_t idx, Int_t value)
Definition RooCmdArg.h:73
static const RooCmdArg & none()
Return reference to null argument.
Definition RooCmdArg.cxx:48
void setSet(Int_t idx, const RooArgSet &set)
void setProcessRecArgs(bool flag, bool prefix=true)
Definition RooCmdArg.h:46
Represents a constant real-valued object.
Definition RooConstVar.h:23
Container class to hold N-dimensional binned data.
Definition RooDataHist.h:40
Container class to hold unbinned data.
Definition RooDataSet.h:32
RooFitResult is a container class to hold the input and output of a PDF fit to a dataset.
static Value & defaultValue()
static EvalBackend Cuda()
static EvalBackend Codegen()
static EvalBackend CodegenNoGrad()
std::string name() const
Value value() const
static EvalBackend Cpu()
static Value toValue(std::string const &name)
static std::string toName(Value value)
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Holds the configuration parameters of the various numeric integrators used by RooRealIntegral.
static RooConstVar & value(double value)
Return a constant value object with given value.
Variable that can be changed from the outside.
Definition RooRealVar.h:37
Int_t number() const
Definition TColor.h:151
TH1 is the base class of all histogram classes in ROOT.
Definition TH1.h:125
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
Mother of all ROOT objects.
Definition TObject.h:42
A TTree represents a columnar dataset.
Definition TTree.h:95
RooCmdArg RecycleConflictNodes(bool flag=true)
RooCmdArg ScanNoCdf()
RooCmdArg AutoRange(const RooAbsData &data, double marginFactor=0.1)
RooCmdArg FitGauss(bool flag=true)
RooCmdArg FrameBins(Int_t nbins)
RooCmdArg ClassName(const char *name)
RooCmdArg FitModel(RooAbsPdf &pdf)
RooCmdArg LatexStyle(bool flag=true)
RooCmdArg VerbatimName(bool flag=true)
RooCmdArg IntegratedObservables(const RooArgSet &intObs)
RooCmdArg OutputStream(std::ostream &os)
RooCmdArg Topic(Int_t topic)
RooCmdArg Parameters(const RooArgSet &params)
RooCmdArg NumIntConfig(const RooNumIntConfig &cfg)
RooCmdArg ScanParameters(Int_t nbins, Int_t intOrder)
RooCmdArg Label(const char *str)
RooCmdArg Color(TColorNumber color)
RooCmdArg TagName(const char *name)
RooCmdArg MultiArg(const RooCmdArg &arg1, const RooCmdArg &arg2, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={}, const RooCmdArg &arg7={}, const RooCmdArg &arg8={})
RooCmdArg BaseClassName(const char *name)
RooCmdArg FitOptions(const RooCmdArg &arg1, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={})
RooCmdArg IntrinsicBinning(bool flag=true)
RooCmdArg Restrict(const char *catName, const char *stateNameList)
RooCmdArg TLatexStyle(bool flag=true)
RooCmdArg RenameAllVariables(const char *suffix)
RooCmdArg ShowConstants(bool flag=true)
RooCmdArg RenameVariable(const char *inputName, const char *outputName)
RooCmdArg Prefix(bool flag)
RooCmdArg FixedPrecision(Int_t ndigit=2)
RooCmdArg AutoPrecision(Int_t ndigit=2)
RooCmdArg Title(const char *name)
RooCmdArg RenameAllNodes(const char *suffix)
RooCmdArg ZVar(const RooAbsRealLValue &var, const RooCmdArg &arg={})
RooCmdArg SplitParam(const char *varname, const char *catname)
RooCmdArg Rename(const char *suffix)
RooCmdArg SupNormSet(const RooArgSet &nset)
RooCmdArg SelectVars(const RooArgSet &vars)
RooCmdArg AutoBinning(Int_t nbins=100, double marginFactor=0.1)
RooCmdArg Frame(const RooCmdArg &arg1, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={})
RooCmdArg YVar(const RooAbsRealLValue &var, const RooCmdArg &arg={})
RooCmdArg FrameRange(double xlo, double xhi)
RooCmdArg Conditional(const RooArgSet &pdfSet, const RooArgSet &depSet, bool depsAreCond=false)
RooCmdArg LatexTableStyle(bool flag=true)
RooCmdArg RenameAllVariablesExcept(const char *suffix, const char *exceptionList)
RooCmdArg Scaling(bool flag)
RooConstVar & RooConst(double val)
RooCmdArg Columns(Int_t ncol)
RooCmdArg EventRange(Int_t nStart, Int_t nStop)
RooCmdArg ScanAllCdf()
RooCmdArg ObjectName(const char *name)
RooCmdArg Format(const char *what, const RooCmdArg &arg1={}, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={}, const RooCmdArg &arg7={}, const RooCmdArg &arg8={})
RooCmdArg Silence(bool flag=true)
RooCmdArg NoRecursion(bool flag=true)
RooCmdArg AxisLabel(const char *name)
RooCmdArg Sibling(const RooAbsCollection &sibling)
RooCmdArg Binned(bool flag=true)
RooCmdArg SplitParamConstrained(const char *varname, const char *catname, const char *rsname)
RooCmdArg What(const char *str)
RooCmdArg RenameConflictNodes(const char *suffix, bool renameOrigNodes=false)
RooCmdArg AutoSymRange(const RooAbsData &data, double marginFactor=0.1)
RooCmdArg ScanNumCdf()
RooCmdArg Bins(Int_t nbin)
RooCmdArg Embedded(bool flag=true)
RooCmdArg OutputFile(const char *fileName)
RooCmdArg AutoSymBinning(Int_t nbins=100, double marginFactor=0.1)
RooCmdArg Layout(double xmin, double xmax=0.99, double ymin=0.95)
RooCmdArg OwnLinked()
RooCmdArg ImportFromFile(const char *fname, const char *tname)
RooCmdArg StoreAsymError(const RooArgSet &aset)
RooCmdArg Weight(double wgt)
RooCmdArg Index(RooCategory &icat)
RooCmdArg StoreError(const RooArgSet &aset)
RooCmdArg Link(const char *state, RooAbsData &data)
RooCmdArg WeightVar(const char *name="weight", bool reinterpretAsWeight=false)
RooCmdArg Import(const char *state, TH1 &histo)
RooCmdArg InitialHesse(bool flag=true)
RooCmdArg IntegrateBins(double precision)
Integrate the PDF over bins.
RooCmdArg MaxCalls(int n)
RooCmdArg SplitRange(bool flag=true)
RooCmdArg AsymptoticError(bool flag)
RooCmdArg PrefitDataFraction(double data_ratio=0.0)
RooCmdArg Offset(std::string const &mode)
RooCmdArg Constrain(const RooArgSet &params)
RooCmdArg GlobalObservablesTag(const char *tagName)
RooCmdArg Minimizer(const char *type, const char *alg=nullptr)
RooCmdArg Hesse(bool flag=true)
RooCmdArg Strategy(Int_t code)
RooCmdArg Save(bool flag=true)
RooCmdArg Integrate(bool flag)
RooCmdArg SumW2Error(bool flag)
RooCmdArg GlobalObservablesSource(const char *sourceName)
RooCmdArg SumCoefRange(const char *rangeName)
RooCmdArg PrintEvalErrors(Int_t numErrors)
RooCmdArg Optimize(Int_t flag=2)
RooCmdArg Parallelize(int nWorkers)
RooCmdArg EvalErrorWall(bool flag)
RooCmdArg Warnings(bool flag=true)
RooCmdArg ExternalConstraints(const RooArgSet &constraintPdfs)
RooCmdArg Minos(bool flag=true)
RooCmdArg ModularL(bool flag=false)
RooCmdArg PrintLevel(Int_t level)
RooCmdArg TimingAnalysis(bool flag)
RooCmdArg NumCPU(Int_t nCPU, Int_t interleave=0)
RooCmdArg DataError(Int_t)
RooCmdArg CloneData(bool flag)
RooCmdArg Timer(bool flag=true)
RooCmdArg RecoverFromUndefinedRegions(double strength)
When parameters are chosen such that a PDF is undefined, try to indicate to the minimiser how to leav...
RooCmdArg Verbose(bool flag=true)
RooCmdArg Extended(bool flag=true)
RooCmdArg AllBinned()
RooCmdArg AutoBinned(bool flag=true)
RooCmdArg Asimov(bool flag=true)
RooCmdArg NumEvents(Int_t numEvents)
RooCmdArg GenBinned(const char *tag)
RooCmdArg ProtoData(const RooAbsData &protoData, bool randomizeOrder=false, bool resample=false)
RooCmdArg ExpectedData(bool flag=true)
RooCmdArg RefreshNorm()
RooCmdArg Components(Args_t &&... argsOrArgSet)
RooCmdArg ProjectionRange(const char *rangeName)
RooCmdArg FillColor(TColorNumber color)
RooCmdArg Binning(const RooAbsBinning &binning)
RooCmdArg ProjWData(const RooAbsData &projData, bool binData=false)
RooCmdArg Precision(double prec)
RooCmdArg EvalErrorValue(double value)
RooCmdArg NormRange(const char *rangeNameList)
RooCmdArg ShowProgress()
RooCmdArg DrawOption(const char *opt)
RooCmdArg Project(const RooArgSet &projSet)
RooCmdArg LineColor(TColorNumber color)
RooCmdArg FillStyle(Style_t style)
RooCmdArg Range(const char *rangeName, bool adjustNorm=true)
RooCmdArg Invisible(bool inv=true)
RooCmdArg MarkerStyle(Style_t style)
RooCmdArg LineWidth(Width_t width)
RooCmdArg Normalization(double scaleFactor)
RooCmdArg VisualizeError(const RooDataSet &paramData, double Z=1)
RooCmdArg ShiftToZero()
RooCmdArg Slice(const RooArgSet &sliceSet)
RooCmdArg AddTo(const char *name, double wgtSel=1.0, double wgtOther=1.0)
RooCmdArg CutRange(const char *rangeName)
RooCmdArg XErrorSize(double width)
RooCmdArg MoveToBack()
RooCmdArg MarkerSize(Size_t size)
RooCmdArg MarkerColor(TColorNumber color)
RooCmdArg Rescale(double factor)
RooCmdArg Cut(const char *cutSpec)
RooCmdArg Efficiency(const RooCategory &cat)
RooCmdArg Name(const char *name)
RooCmdArg LineStyle(Style_t style)
RooCmdArg VLines()
RooCmdArg Asymmetry(const RooCategory &cat)
auto Map(Args &&... args)
Create new collection applying a callable to the elements of the input collection.
Definition RVec.hxx:2128
const Int_t n
Definition legend1.C:16
std::string getBatchComputeChoice()
void setBatchComputeChoice(std::string const &value)
RooConstVar & C(double value)
RooCmdArg LinkFlatMap(FlatMap< std::string, RooAbsData * > const &args)
RooCmdArg ImportFlatMap(FlatMap< std::string, RooDataHist * > const &args)
RooCmdArg SliceFlatMap(FlatMap< RooCategory *, std::string > const &args)
RooCmdArg ParallelGradientOptions(bool enable=true, int orderStrategy=0, int chainFactor=1)
Configuration options for parallel minimization with multiprocessing library.
RooCmdArg ParallelDescentOptions(bool enable=false, int splitStrategy=0, int numSplits=0)
void writeCodegenDebugMacro(RooAbsReal const &absReal, std::string const &name)
The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or othe...
Definition CodegenImpl.h:73
RooCmdArg BootStrapData(const RooDataSet &dset)
RooCmdArg ShowName(bool flag)
RooCmdArg ShowError(bool flag)
OffsetMode
For setting the offset mode with the Offset() command argument to RooAbsPdf::fitTo()
@ InputArguments
RooCmdArg ShowValue(bool flag)
void setBatchCompute(std::string const &value)
Globally select the RooBatchCompute CPU implementation that will be loaded in RooFit.
RooCmdArg ShowAsymError(bool flag)
RooCmdArg ShowUnit(bool flag)
std::string getBatchCompute()
Get the global choice for the RooBatchCompute library that RooFit will load.
static const char * what
Definition stlLoader.cc:5
Wrap an object into a TObject. Sometimes needed to avoid reinterpret_cast or enable RTTI.
Definition RooHelpers.h:57