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, NumIntegration=16384, FastEvaluations=1<<15, HistFactory=1<<16, IO=1<<17 };
68
69/// For setting the offset mode with the Offset() command argument to
70/// RooAbsPdf::fitTo()
71enum class OffsetMode { None, Initial, Bin };
72
73namespace Experimental {
74
75/// Configuration options for parallel minimization with multiprocessing library
78
79} // Experimental
80
81std::string getBatchCompute();
82void setBatchCompute(std::string const &value);
83
84/**
85 * \defgroup CmdArgs RooFit command arguments
86 * These arguments can be passed to functions of RooFit objects.
87 * \ingroup Roofitmain
88 * @{
89 */
90
91/**
92 * \defgroup Plotting Arguments for plotOn functions
93 * @{
94 */
95RooCmdArg DrawOption(const char* opt) ;
96RooCmdArg Normalization(double scaleFactor) ;
98RooCmdArg Slice(RooCategory& cat, const char* label) ;
99RooCmdArg Slice(std::map<RooCategory*, std::string> const&) ;
100RooCmdArg Project(const RooArgSet& projSet) ;
101RooCmdArg ProjWData(const RooAbsData& projData, bool binData=false) ;
102RooCmdArg ProjWData(const RooArgSet& projSet, const RooAbsData& projData, bool binData=false) ;
103RooCmdArg Asymmetry(const RooCategory& cat) ;
104RooCmdArg Precision(double prec) ;
106RooCmdArg Range(const char* rangeName, bool adjustNorm=true) ;
107RooCmdArg Range(double lo, double hi, bool adjustNorm=true) ;
108RooCmdArg NormRange(const char* rangeNameList) ;
112RooCmdArg LineStyle(std::string const &style) ;
116RooCmdArg FillStyle(std::string const &style) ;
118RooCmdArg Name(const char* name) ;
119RooCmdArg Invisible(bool inv=true) ;
120RooCmdArg AddTo(const char* name, double wgtSel=1.0, double wgtOther=1.0) ;
123RooCmdArg VisualizeError(const RooDataSet& paramData, double Z=1) ;
124RooCmdArg VisualizeError(const RooFitResult& fitres, double Z=1, bool linearMethod=true) ;
125RooCmdArg VisualizeError(const RooFitResult& fitres, const RooArgSet& param, double Z=1, bool linearMethod=true) ;
127
128// RooAbsPdf::plotOn arguments
129RooCmdArg Normalization(double scaleFactor, Int_t scaleType) ;
130template<class... Args_t>
132 RooCmdArg out{"SelectCompSet",0};
133 out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
134 return out;
135}
136RooCmdArg Components(const char* compSpec) ;
137
138// RooAbsData::plotOn arguments
139RooCmdArg Cut(const char* cutSpec) ;
141RooCmdArg Binning(const RooAbsBinning& binning) ;
142RooCmdArg Binning(const char* binningName) ;
143RooCmdArg Binning(int nBins, double xlo=0.0, double xhi=0.0) ;
145RooCmdArg MarkerStyle(std::string const &style) ;
148RooCmdArg CutRange(const char* rangeName) ;
149RooCmdArg XErrorSize(double width) ;
151RooCmdArg Efficiency(const RooCategory& cat) ;
152RooCmdArg Rescale(double factor) ;
153
154/** @} */
155
156/**
157 * \defgroup ConstructorArgs Arguments for various constructors
158 * @{
159 */
160// RooDataHist::ctor arguments
161RooCmdArg Weight(double wgt) ;
163RooCmdArg Import(const char* state, TH1& histo) ;
164RooCmdArg Import(const std::map<std::string,TH1*>&) ;
165RooCmdArg Import(const char* state, RooDataHist& dhist) ;
166RooCmdArg Import(const std::map<std::string,RooDataHist*>&) ;
167RooCmdArg Import(TH1& histo, bool importDensity=false) ;
168
169// RooDataSet::ctor arguments
170RooCmdArg WeightVar(const char* name="weight", bool reinterpretAsWeight=false) ;
171RooCmdArg WeightVar(const RooRealVar& arg, bool reinterpretAsWeight=false) ;
172RooCmdArg Import(const char* state, RooAbsData& data) ;
173RooCmdArg Import(const std::map<std::string,RooDataSet*>& ) ;
174template<class DataPtr_t>
175RooCmdArg Import(std::map<std::string,DataPtr_t> const& map) {
176 RooCmdArg container("ImportDataSliceMany",0,0,0,0,nullptr,nullptr,nullptr,nullptr) ;
177 for (auto const& item : map) {
178 container.addArg(Import(item.first.c_str(), *item.second)) ;
179 }
180 container.setProcessRecArgs(true,false) ;
181 return container ;
182}
183
184RooCmdArg Link(const char* state, RooAbsData& data) ;
185RooCmdArg Link(const std::map<std::string,RooAbsData*>&) ;
187RooCmdArg Import(TTree& tree) ;
188RooCmdArg ImportFromFile(const char* fname, const char* tname) ;
192
193/** @} */
194
195// RooAbsPdf::printLatex arguments
197RooCmdArg OutputFile(const char* fileName) ;
198RooCmdArg Format(const char* what, const RooCmdArg& arg1={}, const RooCmdArg& arg2={},
199 const RooCmdArg& arg3={},const RooCmdArg& arg4={},
200 const RooCmdArg& arg5={},const RooCmdArg& arg6={},
201 const RooCmdArg& arg7={},const RooCmdArg& arg8={}) ;
203
204// RooAbsRealLValue::frame arguments
205RooCmdArg Title(const char* name) ;
208RooCmdArg AutoRange(const RooAbsData& data, double marginFactor=0.1) ;
209
210// RooAbsData::createHistogram arguments
211RooCmdArg AutoSymBinning(Int_t nbins=100, double marginFactor=0.1) ;
212RooCmdArg AutoBinning(Int_t nbins=100, double marginFactor=0.1) ;
213
214// RooAbsReal::fillHistogram arguments
216
217// RooAbsData::reduce arguments
218RooCmdArg SelectVars(const RooArgSet& vars) ;
220
221
222/**
223 * \defgroup Fitting Arguments for fitting
224 * @{
225 */
226// RooChi2Var::ctor / RooNLLVar arguments
227RooCmdArg Extended(bool flag=true) ;
229RooCmdArg DataError(std::string const&) ;
230RooCmdArg NumCPU(Int_t nCPU, Int_t interleave=0) ;
232RooCmdArg ModularL(bool flag=false) ;
233RooCmdArg TimingAnalysis(bool timingAnalysis) ;
234
235//RooCmdArg BatchMode(std::string const& batchMode="cpu");
236//// The const char * overload is necessary, otherwise the compiler will cast a
237//// C-Style string to a bool and choose the BatchMode(bool) overload if one
238//// calls for example BatchMode("off").
239//inline RooCmdArg BatchMode(const char * batchMode) { return BatchMode(std::string(batchMode)); }
240//inline RooCmdArg BatchMode(bool batchModeOn) { return BatchMode(batchModeOn ? "cpu" : "off"); }
241
242RooCmdArg IntegrateBins(double precision);
243
244// RooAbsPdf::fitTo arguments
247
248class EvalBackend : public RooCmdArg {
249public:
251
253
254 EvalBackend(std::string const &name);
255
256 static EvalBackend Legacy();
257 static EvalBackend Cpu();
258 static EvalBackend Cuda();
259 static EvalBackend Codegen();
260 static EvalBackend CodegenNoGrad();
261
262 Value value() const { return static_cast<Value>(getInt(0)); }
263
264 bool operator==(EvalBackend const &other) const { return value() == other.value(); }
265
266 bool operator!=(EvalBackend const &other) const { return value() != other.value(); }
267
268 std::string name() const;
269
270 static Value &defaultValue();
271private:
272 static Value toValue(std::string const& name);
273 static std::string toName(Value value);
274};
275
276////////////////////////////////////////////////////////////////////////////////
277/// Create a RooCmdArg to declare conditional observables.
278/// \param[in] argsOrArgSet Can either be one or more RooRealVar with the
279// observables or a single RooArgSet containing them.
280template<class... Args_t>
282 RooCmdArg out{"ProjectedObservables",0};
283 out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
284 return out;
285}
286
287// obsolete, for backward compatibility
288template<class... Args_t>
290 return ConditionalObservables(std::forward<Args_t>(argsOrArgSet)...);
291}
292
293RooCmdArg Verbose(bool flag=true) ;
294RooCmdArg Save(bool flag=true) ;
295RooCmdArg Timer(bool flag=true) ;
297RooCmdArg Warnings(bool flag=true) ;
299RooCmdArg InitialHesse(bool flag=true) ;
300RooCmdArg Hesse(bool flag=true) ;
301RooCmdArg Minos(bool flag=true) ;
303RooCmdArg SplitRange(bool flag=true) ;
304RooCmdArg SumCoefRange(const char* rangeName) ;
305RooCmdArg Constrain(const RooArgSet& params) ;
306RooCmdArg MaxCalls(int n) ;
307
308template<class... Args_t>
310 RooCmdArg out{"GlobalObservables",0};
311 out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
312 return out;
313}
315RooCmdArg GlobalObservablesTag(const char* tagName) ;
323RooCmdArg Minimizer(const char* type, const char* alg=nullptr) ;
324RooCmdArg Offset(std::string const& mode);
325// The const char * overload is necessary, otherwise the compiler will cast a
326// C-Style string to a bool and choose the Offset(bool) overload if one
327// calls for example Offset("off").
328inline RooCmdArg Offset(const char * mode) { return Offset(std::string(mode)); }
329// For backwards compatibility
330inline RooCmdArg Offset(bool flag=true) { return flag ? Offset("initial") : Offset("off"); }
332/** @} */
333
334// RooAbsPdf::paramOn arguments
335RooCmdArg Label(const char* str) ;
336RooCmdArg Layout(double xmin, double xmax=0.99, double ymin=0.95) ;
337RooCmdArg Parameters(const RooArgSet& params) ;
338RooCmdArg ShowConstants(bool flag=true) ;
339
340// RooTreeData::statOn arguments
341RooCmdArg What(const char* str) ;
342
343// RooProdPdf::ctor arguments
345
346/**
347 * \defgroup Generating Arguments for generating data
348 * @{
349 */
350// RooAbsPdf::generate arguments
351RooCmdArg ProtoData(const RooDataSet& protoData, bool randomizeOrder=false, bool resample=false) ;
354RooCmdArg AutoBinned(bool flag=true) ;
355RooCmdArg GenBinned(const char* tag) ;
357RooCmdArg ExpectedData(bool flag=true) ;
358RooCmdArg Asimov(bool flag=true) ;
359
360/** @} */
361
362// RooAbsRealLValue::createHistogram arguments
363RooCmdArg YVar(const RooAbsRealLValue& var, const RooCmdArg& arg={}) ;
364RooCmdArg ZVar(const RooAbsRealLValue& var, const RooCmdArg& arg={}) ;
365RooCmdArg AxisLabel(const char* name) ;
366RooCmdArg Scaling(bool flag) ;
367
368
369// RooAbsReal::createHistogram arguments
371
372// RooAbsReal::createIntegral arguments
373template<class... Args_t>
375 RooCmdArg out{"NormSet",0};
376 out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
377 return out;
378}
380
381// RooMCStudy::ctor arguments
382RooCmdArg Silence(bool flag=true) ;
385 const RooCmdArg& arg3={},const RooCmdArg& arg4={},
386 const RooCmdArg& arg5={},const RooCmdArg& arg6={}) ;
387RooCmdArg Binned(bool flag=true) ;
388
389// RooMCStudy::plot* arguments
390RooCmdArg Frame(const RooCmdArg& arg1 ,const RooCmdArg& arg2={},
391 const RooCmdArg& arg3={},const RooCmdArg& arg4={},
392 const RooCmdArg& arg5={},const RooCmdArg& arg6={}) ;
394RooCmdArg FrameRange(double xlo, double xhi) ;
395RooCmdArg FitGauss(bool flag=true) ;
396
397// RooRealVar::format arguments
400RooCmdArg TLatexStyle(bool flag=true) ;
401RooCmdArg LatexStyle(bool flag=true) ;
402RooCmdArg LatexTableStyle(bool flag=true) ;
403RooCmdArg VerbatimName(bool flag=true) ;
404
405// RooMsgService::addReportingStream arguments
406RooCmdArg Topic(Int_t topic) ;
407RooCmdArg ObjectName(const char* name) ;
408RooCmdArg ClassName(const char* name) ;
409RooCmdArg BaseClassName(const char* name) ;
410RooCmdArg TagName(const char* name) ;
411RooCmdArg OutputStream(std::ostream& os) ;
412RooCmdArg Prefix(bool flag) ;
414
415// RooWorkspace::import() arguments
416RooCmdArg RenameConflictNodes(const char* suffix, bool renameOrigNodes=false) ;
417RooCmdArg RenameAllNodes(const char* suffix) ;
420RooCmdArg RenameVariable(const char* inputName, const char* outputName) ;
421RooCmdArg Rename(const char* suffix) ;
423RooCmdArg Embedded(bool flag=true) ;
424RooCmdArg NoRecursion(bool flag=true) ;
425
426// RooSimCloneTool::build() arguments
427RooCmdArg SplitParam(const char* varname, const char* catname) ;
428RooCmdArg SplitParam(const RooRealVar& var, const RooAbsCategory& cat) ;
429RooCmdArg SplitParamConstrained(const char* varname, const char* catname, const char* rsname) ;
430RooCmdArg SplitParamConstrained(const RooRealVar& var, const RooAbsCategory& cat, const char* rsname) ;
431RooCmdArg Restrict(const char* catName, const char* stateNameList) ;
432
433// RooAbsPdf::createCdf() arguments
434RooCmdArg SupNormSet(const RooArgSet& nset) ;
439
440// Generic container arguments (to be able to supply more command line arguments)
442 const RooCmdArg& arg3={},const RooCmdArg& arg4={},
443 const RooCmdArg& arg5={},const RooCmdArg& arg6={},
444 const RooCmdArg& arg7={},const RooCmdArg& arg8={}) ;
445
446RooConstVar& RooConst(double val) ;
447
448// End group CmdArgs:
449/**
450 * @}
451 */
452
453namespace Detail {
454
455// Function to pack an arbitrary number of RooCmdArgs into a RooLinkedList. Implementation detail of many high-level RooFit functions.
456template <typename... Args>
457inline std::unique_ptr<RooLinkedList> createCmdList(RooCmdArg const* arg1, Args &&...args)
458{
459 auto cmdList = std::make_unique<RooLinkedList>();
460 for (auto &arg : {arg1, static_cast<RooCmdArg const *>(args)...}) {
461 cmdList->Add(const_cast<RooCmdArg *>(arg));
462 }
463 return cmdList;
464}
465
466inline std::unique_ptr<RooLinkedList> createCmdList()
467{
468 return std::make_unique<RooLinkedList>();
469}
470
471inline std::unique_ptr<RooLinkedList> createCmdList(RooLinkedList const *cmdList)
472{
473 auto cmdListCopy = std::make_unique<RooLinkedList>();
474 for (auto *arg : *cmdList) {
475 cmdListCopy->Add(arg);
476 }
477 return cmdListCopy;
478}
479
480// RooFit-internal helper struct to build a map object that only uses
481// std::vector, which can be implicitly converted to std::map in C++. Used to
482// avoid std::map in pythonizations.
483template <class Key_t, class Val_t>
484struct FlatMap {
485 std::vector<Key_t> keys;
486 std::vector<Val_t> vals;
487};
488
489template <class Key_t, class Val_t>
491 std::map<Key_t, Val_t> out;
492 for (std::size_t i = 0; i < flatMap.keys.size(); ++i) {
493 out[flatMap.keys[i]] = flatMap.vals[i];
494 }
495 return out;
496}
497
498// Internal variant of Slice(), Import(), and Link(), that take flat maps instead of std::map.
504
505} // namespace Detail
506
507} // namespace RooFit
508
509namespace RooFitShortHand {
510
511RooConstVar& C(double value);
512
513} // namespace RooFitShortHand
514
515#endif
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
short Style_t
Definition RtypesCore.h:82
float Size_t
Definition RtypesCore.h:89
short Width_t
Definition RtypesCore.h:84
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:40
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:59
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:108
A TTree represents a columnar dataset.
Definition TTree.h:84
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)
The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or othe...
Definition CodegenImpl.h:65
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.
@ FastEvaluations
@ NumIntegration
@ 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