Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooGlobalFunc.h
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * File: $Id: RooGlobalFunc.h,v 1.14 2007/07/16 21:04:28 wouter Exp $
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#ifndef ROO_GLOBAL_FUNC
17#define ROO_GLOBAL_FUNC
18
19#include "RooCmdArg.h"
20#include "RooLinkedList.h"
21#include "RooArgSet.h"
22
23#include "ROOT/RConfig.hxx"
24#include <TColor.h>
25
26#include <map>
27#include <string>
28
29class RooDataHist ;
30class RooDataSet ;
31class RooFitResult ;
32class RooAbsPdf ;
33class RooAbsRealLValue ;
34class RooRealConstant ;
35class RooMsgService ;
36class RooFormulaVar ;
37class RooAbsData ;
38class RooCategory ;
39class RooAbsReal ;
40class RooAbsBinning ;
41class RooAbsCollection ;
42class RooAbsPdf ;
43class RooConstVar ;
44class RooRealVar ;
45class RooAbsCategory ;
46class RooNumIntConfig ;
47
48class TH1 ;
49class TTree ;
50
51/*! \namespace RooFit
52The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs
53(or other types of arguments).
54
55These switches are documented with the relevant functions, e.g. RooAbsPdf::fitTo().
56For an introduction to RooFit (not the namespace), check the [user's guides](https://root.cern/root-user-guides-and-manuals),
57[courses](https://root.cern/learn/courses) or [the RooFit chapter of the Manual](https://root.cern/manual/roofit/).
58*/
59namespace RooFit {
60
61/// Verbosity level for RooMsgService::StreamConfig in RooMsgService
62enum MsgLevel { DEBUG=0, INFO=1, PROGRESS=2, WARNING=3, ERROR=4, FATAL=5 } ;
63/// Topics for a RooMsgService::StreamConfig in RooMsgService
66 Contents=4096, DataHandling=8192, NumericIntegration=16384, FastEvaluations=1<<15, HistFactory=1<<16, IO=1<<17 };
68
69/// Alias of MsgLevel::NumericIntegration for backwards compatibility.
70/// \see https://github.com/root-project/root/issues/19422
71constexpr static auto NumIntegration = NumericIntegration;
72
73/// For setting the offset mode with the Offset() command argument to
74/// RooAbsPdf::fitTo()
75enum class OffsetMode { None, Initial, Bin };
76
77namespace Experimental {
78
79/// Configuration options for parallel minimization with multiprocessing library
82
83void writeCodegenDebugMacro(RooAbsReal const &absReal, std::string const &name);
84inline void writeCodegenDebugMacro(std::unique_ptr<RooAbsReal> const &absReal, std::string const &name)
85{
87}
88
89} // Experimental
90
91std::string getBatchCompute();
92void setBatchCompute(std::string const &value);
93
94/**
95 * \defgroup CmdArgs RooFit command arguments
96 * These arguments can be passed to functions of RooFit objects.
97 * \ingroup Roofitmain
98 * @{
99 */
100
101/**
102 * \defgroup Plotting Arguments for plotOn functions
103 * @{
104 */
105RooCmdArg DrawOption(const char* opt) ;
106RooCmdArg Normalization(double scaleFactor) ;
108RooCmdArg Slice(RooCategory& cat, const char* label) ;
109RooCmdArg Slice(std::map<RooCategory*, std::string> const&) ;
110RooCmdArg Project(const RooArgSet& projSet) ;
111RooCmdArg ProjWData(const RooAbsData& projData, bool binData=false) ;
112RooCmdArg ProjWData(const RooArgSet& projSet, const RooAbsData& projData, bool binData=false) ;
113RooCmdArg Asymmetry(const RooCategory& cat) ;
114RooCmdArg Precision(double prec) ;
116RooCmdArg Range(const char* rangeName, bool adjustNorm=true) ;
117RooCmdArg Range(double lo, double hi, bool adjustNorm=true) ;
118RooCmdArg NormRange(const char* rangeNameList) ;
122RooCmdArg LineStyle(std::string const &style) ;
126RooCmdArg FillStyle(std::string const &style) ;
128RooCmdArg Name(const char* name) ;
129RooCmdArg Invisible(bool inv=true) ;
130RooCmdArg AddTo(const char* name, double wgtSel=1.0, double wgtOther=1.0) ;
133RooCmdArg VisualizeError(const RooDataSet& paramData, double Z=1) ;
134RooCmdArg VisualizeError(const RooFitResult& fitres, double Z=1, bool linearMethod=true) ;
135RooCmdArg VisualizeError(const RooFitResult& fitres, const RooArgSet& param, double Z=1, bool linearMethod=true) ;
137
138// RooAbsPdf::plotOn arguments
139RooCmdArg Normalization(double scaleFactor, Int_t scaleType) ;
140template<class... Args_t>
142 RooCmdArg out{"SelectCompSet",0};
143 out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
144 return out;
145}
146RooCmdArg Components(const char* compSpec) ;
147
148// RooAbsData::plotOn arguments
149RooCmdArg Cut(const char* cutSpec) ;
151RooCmdArg Binning(const RooAbsBinning& binning) ;
152RooCmdArg Binning(const char* binningName) ;
153RooCmdArg Binning(int nBins, double xlo=0.0, double xhi=0.0) ;
155RooCmdArg MarkerStyle(std::string const &style) ;
158RooCmdArg CutRange(const char* rangeName) ;
159RooCmdArg XErrorSize(double width) ;
161RooCmdArg Efficiency(const RooCategory& cat) ;
162RooCmdArg Rescale(double factor) ;
163
164/** @} */
165
166/**
167 * \defgroup ConstructorArgs Arguments for various constructors
168 * @{
169 */
170// RooDataHist::ctor arguments
171RooCmdArg Weight(double wgt) ;
173RooCmdArg Import(const char* state, TH1& histo) ;
174RooCmdArg Import(const std::map<std::string,TH1*>&) ;
175RooCmdArg Import(const char* state, RooDataHist& dhist) ;
176RooCmdArg Import(const std::map<std::string,RooDataHist*>&) ;
177RooCmdArg Import(TH1& histo, bool importDensity=false) ;
178
179// RooDataSet::ctor arguments
180RooCmdArg WeightVar(const char* name="weight", bool reinterpretAsWeight=false) ;
181RooCmdArg WeightVar(const RooRealVar& arg, bool reinterpretAsWeight=false) ;
182RooCmdArg Import(const char* state, RooAbsData& data) ;
183RooCmdArg Import(const std::map<std::string,RooDataSet*>& ) ;
184template<class DataPtr_t>
185RooCmdArg Import(std::map<std::string,DataPtr_t> const& map) {
186 RooCmdArg container("ImportDataSliceMany",0,0,0,0,nullptr,nullptr,nullptr,nullptr) ;
187 for (auto const& item : map) {
188 container.addArg(Import(item.first.c_str(), *item.second)) ;
189 }
190 container.setProcessRecArgs(true,false) ;
191 return container ;
192}
193
194RooCmdArg Link(const char* state, RooAbsData& data) ;
195RooCmdArg Link(const std::map<std::string,RooAbsData*>&) ;
197RooCmdArg Import(TTree& tree) ;
198RooCmdArg ImportFromFile(const char* fname, const char* tname) ;
202
203/** @} */
204
205// RooAbsPdf::printLatex arguments
207RooCmdArg OutputFile(const char* fileName) ;
208RooCmdArg Format(const char* what, const RooCmdArg& arg1={}, const RooCmdArg& arg2={},
209 const RooCmdArg& arg3={},const RooCmdArg& arg4={},
210 const RooCmdArg& arg5={},const RooCmdArg& arg6={},
211 const RooCmdArg& arg7={},const RooCmdArg& arg8={}) ;
213
214// RooAbsRealLValue::frame arguments
215RooCmdArg Title(const char* name) ;
218RooCmdArg AutoRange(const RooAbsData& data, double marginFactor=0.1) ;
219
220// RooAbsData::createHistogram arguments
221RooCmdArg AutoSymBinning(Int_t nbins=100, double marginFactor=0.1) ;
222RooCmdArg AutoBinning(Int_t nbins=100, double marginFactor=0.1) ;
223
224// RooAbsReal::fillHistogram arguments
226
227// RooAbsData::reduce arguments
228RooCmdArg SelectVars(const RooArgSet& vars) ;
230
231
232/**
233 * \defgroup Fitting Arguments for fitting
234 * @{
235 */
236// RooChi2Var::ctor / RooNLLVar arguments
237RooCmdArg Extended(bool flag=true) ;
239RooCmdArg DataError(std::string const&) ;
240RooCmdArg NumCPU(Int_t nCPU, Int_t interleave=0) ;
242RooCmdArg ModularL(bool flag=false) ;
243RooCmdArg TimingAnalysis(bool timingAnalysis) ;
244
245//RooCmdArg BatchMode(std::string const& batchMode="cpu");
246//// The const char * overload is necessary, otherwise the compiler will cast a
247//// C-Style string to a bool and choose the BatchMode(bool) overload if one
248//// calls for example BatchMode("off").
249//inline RooCmdArg BatchMode(const char * batchMode) { return BatchMode(std::string(batchMode)); }
250//inline RooCmdArg BatchMode(bool batchModeOn) { return BatchMode(batchModeOn ? "cpu" : "off"); }
251
252RooCmdArg IntegrateBins(double precision);
253
254// RooAbsPdf::fitTo arguments
257
258class EvalBackend : public RooCmdArg {
259public:
261
263
264 EvalBackend(std::string const &name);
265
266 static EvalBackend Legacy();
267 static EvalBackend Cpu();
268 static EvalBackend Cuda();
269 static EvalBackend Codegen();
270 static EvalBackend CodegenNoGrad();
271
272 Value value() const { return static_cast<Value>(getInt(0)); }
273
274 bool operator==(EvalBackend const &other) const { return value() == other.value(); }
275
276 bool operator!=(EvalBackend const &other) const { return value() != other.value(); }
277
278 std::string name() const;
279
280 static Value &defaultValue();
281private:
282 static Value toValue(std::string const& name);
283 static std::string toName(Value value);
284};
285
286////////////////////////////////////////////////////////////////////////////////
287/// Create a RooCmdArg to declare conditional observables.
288/// \param[in] argsOrArgSet Can either be one or more RooRealVar with the
289// observables or a single RooArgSet containing them.
290template<class... Args_t>
292 RooCmdArg out{"ProjectedObservables",0};
293 out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
294 return out;
295}
296
297// obsolete, for backward compatibility
298template<class... Args_t>
300 return ConditionalObservables(std::forward<Args_t>(argsOrArgSet)...);
301}
302
303RooCmdArg Verbose(bool flag=true) ;
304RooCmdArg Save(bool flag=true) ;
305RooCmdArg Timer(bool flag=true) ;
307RooCmdArg Warnings(bool flag=true) ;
309RooCmdArg InitialHesse(bool flag=true) ;
310RooCmdArg Hesse(bool flag=true) ;
311RooCmdArg Minos(bool flag=true) ;
313RooCmdArg SplitRange(bool flag=true) ;
314RooCmdArg SumCoefRange(const char* rangeName) ;
315RooCmdArg Constrain(const RooArgSet& params) ;
316RooCmdArg MaxCalls(int n) ;
317
318template<class... Args_t>
320 RooCmdArg out{"GlobalObservables",0};
321 out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
322 return out;
323}
325RooCmdArg GlobalObservablesTag(const char* tagName) ;
333RooCmdArg Minimizer(const char* type, const char* alg=nullptr) ;
334RooCmdArg Offset(std::string const& mode);
335// The const char * overload is necessary, otherwise the compiler will cast a
336// C-Style string to a bool and choose the Offset(bool) overload if one
337// calls for example Offset("off").
338inline RooCmdArg Offset(const char * mode) { return Offset(std::string(mode)); }
339// For backwards compatibility
340inline RooCmdArg Offset(bool flag=true) { return flag ? Offset("initial") : Offset("off"); }
342/** @} */
343
344// RooAbsPdf::paramOn arguments
345RooCmdArg Label(const char* str) ;
346RooCmdArg Layout(double xmin, double xmax=0.99, double ymin=0.95) ;
347RooCmdArg Parameters(const RooArgSet& params) ;
348RooCmdArg ShowConstants(bool flag=true) ;
349
350// RooTreeData::statOn arguments
351RooCmdArg What(const char* str) ;
352
353// RooProdPdf::ctor arguments
355
356/**
357 * \defgroup Generating Arguments for generating data
358 * @{
359 */
360// RooAbsPdf::generate arguments
361RooCmdArg ProtoData(const RooDataSet& protoData, bool randomizeOrder=false, bool resample=false) ;
364RooCmdArg AutoBinned(bool flag=true) ;
365RooCmdArg GenBinned(const char* tag) ;
367RooCmdArg ExpectedData(bool flag=true) ;
368RooCmdArg Asimov(bool flag=true) ;
369
370/** @} */
371
372// RooAbsRealLValue::createHistogram arguments
373RooCmdArg YVar(const RooAbsRealLValue& var, const RooCmdArg& arg={}) ;
374RooCmdArg ZVar(const RooAbsRealLValue& var, const RooCmdArg& arg={}) ;
375RooCmdArg AxisLabel(const char* name) ;
376RooCmdArg Scaling(bool flag) ;
377
378
379// RooAbsReal::createHistogram arguments
381
382// RooAbsReal::createIntegral arguments
383template<class... Args_t>
385 RooCmdArg out{"NormSet",0};
386 out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
387 return out;
388}
390
391// RooMCStudy::ctor arguments
392RooCmdArg Silence(bool flag=true) ;
395 const RooCmdArg& arg3={},const RooCmdArg& arg4={},
396 const RooCmdArg& arg5={},const RooCmdArg& arg6={}) ;
397RooCmdArg Binned(bool flag=true) ;
398
399// RooMCStudy::plot* arguments
400RooCmdArg Frame(const RooCmdArg& arg1 ,const RooCmdArg& arg2={},
401 const RooCmdArg& arg3={},const RooCmdArg& arg4={},
402 const RooCmdArg& arg5={},const RooCmdArg& arg6={}) ;
404RooCmdArg FrameRange(double xlo, double xhi) ;
405RooCmdArg FitGauss(bool flag=true) ;
406
407// RooRealVar::format arguments
410RooCmdArg TLatexStyle(bool flag=true) ;
411RooCmdArg LatexStyle(bool flag=true) ;
412RooCmdArg LatexTableStyle(bool flag=true) ;
413RooCmdArg VerbatimName(bool flag=true) ;
414
415// RooMsgService::addReportingStream arguments
416RooCmdArg Topic(Int_t topic) ;
417RooCmdArg ObjectName(const char* name) ;
418RooCmdArg ClassName(const char* name) ;
419RooCmdArg BaseClassName(const char* name) ;
420RooCmdArg TagName(const char* name) ;
421RooCmdArg OutputStream(std::ostream& os) ;
422RooCmdArg Prefix(bool flag) ;
424
425// RooWorkspace::import() arguments
426RooCmdArg RenameConflictNodes(const char* suffix, bool renameOrigNodes=false) ;
427RooCmdArg RenameAllNodes(const char* suffix) ;
430RooCmdArg RenameVariable(const char* inputName, const char* outputName) ;
431RooCmdArg Rename(const char* suffix) ;
433RooCmdArg Embedded(bool flag=true) ;
434RooCmdArg NoRecursion(bool flag=true) ;
435
436// RooSimCloneTool::build() arguments
437RooCmdArg SplitParam(const char* varname, const char* catname) ;
438RooCmdArg SplitParam(const RooRealVar& var, const RooAbsCategory& cat) ;
439RooCmdArg SplitParamConstrained(const char* varname, const char* catname, const char* rsname) ;
440RooCmdArg SplitParamConstrained(const RooRealVar& var, const RooAbsCategory& cat, const char* rsname) ;
441RooCmdArg Restrict(const char* catName, const char* stateNameList) ;
442
443// RooAbsPdf::createCdf() arguments
444RooCmdArg SupNormSet(const RooArgSet& nset) ;
449
450// Generic container arguments (to be able to supply more command line arguments)
452 const RooCmdArg& arg3={},const RooCmdArg& arg4={},
453 const RooCmdArg& arg5={},const RooCmdArg& arg6={},
454 const RooCmdArg& arg7={},const RooCmdArg& arg8={}) ;
455
456RooConstVar& RooConst(double val) ;
457
458// End group CmdArgs:
459/**
460 * @}
461 */
462
463namespace Detail {
464
465// Function to pack an arbitrary number of RooCmdArgs into a RooLinkedList. Implementation detail of many high-level RooFit functions.
466template <typename... Args>
467inline std::unique_ptr<RooLinkedList> createCmdList(RooCmdArg const* arg1, Args &&...args)
468{
469 auto cmdList = std::make_unique<RooLinkedList>();
470 for (auto &arg : {arg1, static_cast<RooCmdArg const *>(args)...}) {
471 cmdList->Add(const_cast<RooCmdArg *>(arg));
472 }
473 return cmdList;
474}
475
476inline std::unique_ptr<RooLinkedList> createCmdList()
477{
478 return std::make_unique<RooLinkedList>();
479}
480
481inline std::unique_ptr<RooLinkedList> createCmdList(RooLinkedList const *cmdList)
482{
483 auto cmdListCopy = std::make_unique<RooLinkedList>();
484 for (auto *arg : *cmdList) {
485 cmdListCopy->Add(arg);
486 }
487 return cmdListCopy;
488}
489
490// RooFit-internal helper struct to build a map object that only uses
491// std::vector, which can be implicitly converted to std::map in C++. Used to
492// avoid std::map in pythonizations.
493template <class Key_t, class Val_t>
494struct FlatMap {
495 std::vector<Key_t> keys;
496 std::vector<Val_t> vals;
497};
498
499template <class Key_t, class Val_t>
501 std::map<Key_t, Val_t> out;
502 for (std::size_t i = 0; i < flatMap.keys.size(); ++i) {
503 out[flatMap.keys[i]] = flatMap.vals[i];
504 }
505 return out;
506}
507
508// Internal variant of Slice(), Import(), and Link(), that take flat maps instead of std::map.
514
515} // namespace Detail
516
517} // namespace RooFit
518
519namespace RooFitShortHand {
520
521RooConstVar& C(double value);
522
523} // namespace RooFitShortHand
524
525#endif
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
short Style_t
Style number (short)
Definition RtypesCore.h:96
float Size_t
Attribute size (float)
Definition RtypesCore.h:103
short Width_t
Line width (short)
Definition RtypesCore.h:98
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
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:110
float xmin
#define hi
float ymin
float xmax
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:57
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
Int_t getInt(Int_t idx) const
Definition RooCmdArg.h:87
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()
bool operator!=(EvalBackend const &other) const
EvalBackend(Value value)
static EvalBackend Legacy()
std::string name() const
Value value() const
static EvalBackend Cpu()
static Value toValue(std::string const &name)
static std::string toName(Value value)
bool operator==(EvalBackend const &other) const
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Collection class for internal use, storing a collection of RooAbsArg pointers in a doubly linked list...
Singleton class that organizes messages generated in RooFit.
Holds the configuration parameters of the various numeric integrators used by RooRealIntegral.
Provides static functions to create and keep track of RooRealVar constants.
Variable that can be changed from the outside.
Definition RooRealVar.h:37
TH1 is the base class of all histogram classes in ROOT.
Definition TH1.h:109
A TTree represents a columnar dataset.
Definition TTree.h:89
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 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 NormSet(Args_t &&... argsOrArgSet)
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 ProjectedObservables(Args_t &&... argsOrArgSet)
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 GlobalObservables(Args_t &&... argsOrArgSet)
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 TimingAnalysis(bool timingAnalysis)
RooCmdArg PrintLevel(Int_t code)
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 ConditionalObservables(Args_t &&... argsOrArgSet)
Create a RooCmdArg to declare conditional observables.
RooCmdArg Extended(bool flag=true)
RooCmdArg ProtoData(const RooDataSet &protoData, bool randomizeOrder=false, bool resample=false)
RooCmdArg AllBinned()
RooCmdArg AutoBinned(bool flag=true)
RooCmdArg Asimov(bool flag=true)
RooCmdArg NumEvents(Int_t numEvents)
RooCmdArg GenBinned(const char *tag)
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)
const Int_t n
Definition legend1.C:16
RooConstVar & C(double value)
RooCmdArg LinkFlatMap(FlatMap< std::string, RooAbsData * > const &args)
auto flatMapToStdMap(FlatMap< Key_t, Val_t > const &flatMap)
RooCmdArg ImportFlatMap(FlatMap< std::string, RooDataHist * > const &args)
RooCmdArg SliceFlatMap(FlatMap< RooCategory *, std::string > const &args)
std::unique_ptr< RooLinkedList > createCmdList()
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=4)
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:67
static constexpr auto NumIntegration
Alias of MsgLevel::NumericIntegration for backwards compatibility.
MsgLevel
Verbosity level for RooMsgService::StreamConfig in RooMsgService.
@ SimComponents
@ BulkPartition
OffsetMode
For setting the offset mode with the Offset() command argument to RooAbsPdf::fitTo()
MsgTopic
Topics for a RooMsgService::StreamConfig in RooMsgService.
@ NumericIntegration
@ FastEvaluations
@ InputArguments
@ ObjectHandling
@ LinkStateMgmt
void setBatchCompute(std::string const &value)
Globally select the RooBatchCompute CPU implementation that will be loaded in RooFit.
std::string getBatchCompute()
Get the global choice for the RooBatchCompute library that RooFit will load.
void inv(rsa_NUMBER *, rsa_NUMBER *, rsa_NUMBER *)
Definition rsaaux.cxx:949
static const char * what
Definition stlLoader.cc:5
std::vector< Key_t > keys
std::vector< Val_t > vals
static int Prefix[4096]
Definition gifdecode.c:12