Logo ROOT  
Reference Guide
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 "RooCategory.h"
22#include "RooRealConstant.h"
23#include "RooDataSet.h"
24#include "RooDataHist.h"
25#include "RooNumIntConfig.h"
26#include "RooRealVar.h"
27#include "RooFitResult.h"
28#include "RooAbsPdf.h"
29#include "RooFormulaVar.h"
30#include "RooHelpers.h"
31#include "RooMsgService.h"
32#include "TH1.h"
33
34#include <algorithm>
35
36using namespace std;
37
38namespace RooFit {
39
40 // anonymous namespace for helper functions for the implementation of the global functions
41 namespace {
42
43 template<class T>
44 RooCmdArg processImportItem(std::pair<std::string const, T*> const& item) {
45 return Import(item.first.c_str(), *item.second) ;
46 }
47
48 template<class T>
49 RooCmdArg processLinkItem(std::pair<std::string const, T*> const& item) {
50 return Link(item.first.c_str(), *item.second) ;
51 }
52
53 RooCmdArg processSliceItem(std::pair<RooCategory * const, std::string> const& item) {
54 return Slice(*item.first, item.second.c_str());
55 }
56
57 template<class Map_t, class Func_t>
58 RooCmdArg processMap(const char* name, Func_t func, Map_t const& map) {
59 RooCmdArg container(name,0,0,0,0,0,0,0,0) ;
60 for (auto const& item : map) {
61 container.addArg(func(item)) ;
62 }
63 container.setProcessRecArgs(true,false) ;
64 return container ;
65 }
66
67 } // namespace
68
69 namespace Experimental {
70
71 std::string& defaultBatchMode() {
72 static std::string batchMode = "off";
73 return batchMode;
74 }
75
76 RooCmdArg ParallelGradientOptions(bool enable, int orderStrategy, int chainFactor) {
77 return RooCmdArg("ParallelGradientOptions",enable,chainFactor,orderStrategy,0,0,0,0,0) ;}
78 RooCmdArg ParallelDescentOptions(bool enable, int splitStrategy, int numSplits) {
79 return RooCmdArg("ParallelDescentOptions",enable,numSplits,splitStrategy,0,0,0,0,0) ;}
80
81 }
82
83 // RooAbsReal::plotOn arguments
84 RooCmdArg DrawOption(const char* opt) { return RooCmdArg("DrawOption",0,0,0,0,opt,0,0,0) ; }
85 RooCmdArg Slice(const RooArgSet& sliceSet) {
86 RooCmdArg out{"SliceVars",0};
87 out.setSet(0, sliceSet);
88 return out;
89 }
90 RooCmdArg Slice(RooCategory& cat, const char* label) { return RooCmdArg("SliceCat",0,0,0,0,label,0,&cat,0) ; }
91 RooCmdArg Slice(std::map<RooCategory*, std::string> const& arg) {
92 return processMap("SliceCatMany", processSliceItem, arg);
93 }
94
95 RooCmdArg Project(const RooArgSet& projSet) {
96 RooCmdArg out{"Project",0};
97 out.setSet(0, projSet);
98 return out;
99 }
101 const RooAbsData& projData,
102 bool binData) {
103 RooCmdArg out{"ProjData",binData,0,0,0,0,0,nullptr,&projData};
104 out.setSet(0, projSet);
105 return out;
106 }
108 bool binData) { return RooCmdArg("ProjData",binData,0,0,0,0,0,0,&projData) ; }
109 RooCmdArg Asymmetry(const RooCategory& cat) { return RooCmdArg("Asymmetry",0,0,0,0,0,0,&cat,0) ; }
110 RooCmdArg Precision(double prec) { return RooCmdArg("Precision",0,0,prec,0,0,0,0,0) ; }
111 RooCmdArg ShiftToZero() { return RooCmdArg("ShiftToZero",1) ; }
112 RooCmdArg Normalization(double scaleFactor) { return RooCmdArg("Normalization",RooAbsReal::Relative,0,scaleFactor,0,0,0,0,0) ; }
113 RooCmdArg Range(const char* rangeName, bool adjustNorm) { return RooCmdArg("RangeWithName",adjustNorm,0,0,0,rangeName,0,0,0) ; }
114 RooCmdArg Range(double lo, double hi, bool adjustNorm){ return RooCmdArg("Range",adjustNorm,0,lo,hi,0,0,0,0) ; }
115 RooCmdArg NormRange(const char* rangeNameList) { return RooCmdArg("NormRange",0,0,0,0,rangeNameList,0,0,0) ; }
116 RooCmdArg VLines() { return RooCmdArg("VLines",1,0,0,0,0,0,0,0) ; }
117 RooCmdArg LineColor(Color_t color) { return RooCmdArg("LineColor",color) ; }
118 RooCmdArg LineStyle(Style_t style) { return RooCmdArg("LineStyle",style) ; }
119 RooCmdArg LineWidth(Width_t width) { return RooCmdArg("LineWidth",width) ; }
120 RooCmdArg FillColor(Color_t color) { return RooCmdArg("FillColor",color) ; }
121 RooCmdArg FillStyle(Style_t style) { return RooCmdArg("FillStyle",style) ; }
122 RooCmdArg ProjectionRange(const char* rangeName) { return RooCmdArg("ProjectionRange",0,0,0,0,rangeName,0,0,0) ; }
123 RooCmdArg Name(const char* name) { return RooCmdArg("Name",0,0,0,0,name,0,0,0) ; }
124 RooCmdArg Invisible(bool inv) { return RooCmdArg("Invisible",inv,0,0,0,0,0,0,0) ; }
125 RooCmdArg AddTo(const char* name, double wgtSel, double wgtOther) { return RooCmdArg("AddTo",0,0,wgtSel,wgtOther,name,0,0,0) ; }
126 RooCmdArg EvalErrorValue(double val) { return RooCmdArg("EvalErrorValue",1,0,val,0,0,0,0,0) ; }
127 RooCmdArg MoveToBack() { return RooCmdArg("MoveToBack",1,0,0,0,0,0,0,0) ; }
128 RooCmdArg VisualizeError(const RooFitResult& fitres, double Z, bool EVmethod) { return RooCmdArg("VisualizeError",EVmethod,0,Z,0,0,0,&fitres,0) ; }
129 RooCmdArg VisualizeError(const RooFitResult& fitres, const RooArgSet& param, double Z, bool EVmethod)
130 { return RooCmdArg("VisualizeError",EVmethod,0,Z,0,0,0,&fitres,0,0,0,&param) ; }
131 RooCmdArg VisualizeError(const RooDataSet& paramData, double Z) { return RooCmdArg("VisualizeErrorData",0,0,Z,0,0,0,&paramData,0) ; }
132 RooCmdArg ShowProgress() { return RooCmdArg("ShowProgress",1,0,0,0,0,0,0,0) ; }
133
134 // RooAbsPdf::plotOn arguments
135 RooCmdArg Components(const char* compSpec) { return RooCmdArg("SelectCompSpec",0,0,0,0,compSpec,0,0,0) ; }
136 RooCmdArg Normalization(double scaleFactor, Int_t scaleType)
137 { return RooCmdArg("Normalization",scaleType,0,scaleFactor,0,0,0,0,0) ; }
138
139 // RooAbsData::plotOn arguments
140 RooCmdArg Cut(const char* cutSpec) { return RooCmdArg("CutSpec",0,0,0,0,cutSpec,0,0,0) ; }
141 RooCmdArg Cut(const RooFormulaVar& cutVar) { return RooCmdArg("CutVar",0,0,0,0,0,0,&cutVar,0) ; }
142 RooCmdArg Binning(const RooAbsBinning& binning) { return RooCmdArg("Binning",0,0,0,0,0,0,&binning,0) ;}
143 RooCmdArg Binning(const char* binningName) { return RooCmdArg("BinningName",0,0,0,0,binningName,0,0,0) ;}
144 RooCmdArg Binning(int nBins, double xlo, double xhi) { return RooCmdArg("BinningSpec",nBins,0,xlo,xhi,0,0,0,0) ;}
145 RooCmdArg MarkerStyle(Style_t style) { return RooCmdArg("MarkerStyle",style,0,0,0,0,0,0,0) ; }
146 RooCmdArg MarkerSize(Size_t size) { return RooCmdArg("MarkerSize",0,0,size,0,0,0,0,0) ; }
147 RooCmdArg MarkerColor(Color_t color) { return RooCmdArg("MarkerColor",color,0,0,0,0,0,0,0) ; }
148 RooCmdArg CutRange(const char* rangeName) { return RooCmdArg("CutRange",0,0,0,0,rangeName,0,0,0) ; }
149 RooCmdArg XErrorSize(double width) { return RooCmdArg("XErrorSize",0,0,width,0,0,0,0,0) ; }
150 RooCmdArg RefreshNorm() { return RooCmdArg("RefreshNorm",1,0,0,0,0,0,0,0) ; }
151 RooCmdArg Efficiency(const RooCategory& cat) { return RooCmdArg("Efficiency",0,0,0,0,0,0,&cat,0) ; }
152 RooCmdArg Rescale(double factor) { return RooCmdArg("Rescale",0,0,factor,0,0,0,0,0) ; }
153
154 // RooDataHist::ctor arguments
155 RooCmdArg Weight(double wgt) { return RooCmdArg("Weight",0,0,wgt,0,0,0,0,0) ; }
156 RooCmdArg Index(RooCategory& icat) { return RooCmdArg("IndexCat",0,0,0,0,0,0,&icat,0) ; }
157 RooCmdArg Import(const char* state, TH1& histo) { return RooCmdArg("ImportHistoSlice",0,0,0,0,state,0,&histo,0) ; }
158 RooCmdArg Import(const char* state, RooDataHist& dhist) { return RooCmdArg("ImportDataHistSlice",0,0,0,0,state,0,&dhist,0) ; }
159 RooCmdArg Import(TH1& histo, bool importDensity) { return RooCmdArg("ImportHisto",importDensity,0,0,0,0,0,&histo,0) ; }
160
161 RooCmdArg Import(const std::map<std::string,RooDataHist*>& arg) {
162 return processMap("ImportDataHistSliceMany", processImportItem<RooDataHist>, arg);
163 }
164 RooCmdArg Import(const std::map<std::string,TH1*>& arg) {
165 return processMap("ImportHistoSliceMany", processImportItem<TH1>, arg);
166 }
167
168
169 // RooDataSet::ctor arguments
170 RooCmdArg WeightVar(const char* name, bool reinterpretAsWeight) { return RooCmdArg("WeightVarName",reinterpretAsWeight,0,0,0,name,0,0,0) ; }
171 RooCmdArg WeightVar(const RooRealVar& arg, bool reinterpretAsWeight) { return RooCmdArg("WeightVar",reinterpretAsWeight,0,0,0,0,0,&arg,0) ; }
172 RooCmdArg Link(const char* state, RooAbsData& data) { return RooCmdArg("LinkDataSlice",0,0,0,0,state,0,&data,0) ;}
173 RooCmdArg Import(const char* state, RooDataSet& data) { return RooCmdArg("ImportDataSlice",0,0,0,0,state,0,&data,0) ; }
174 RooCmdArg Import(RooDataSet& data) { return RooCmdArg("ImportData",0,0,0,0,0,0,&data,0) ; }
175 RooCmdArg Import(TTree& tree) { return RooCmdArg("ImportTree",0,0,0,0,0,0,reinterpret_cast<TObject*>(&tree),0) ; }
176 RooCmdArg ImportFromFile(const char* fname, const char* tname){ return RooCmdArg("ImportFromFile",0,0,0,0,fname,tname,0,0) ; }
177 RooCmdArg StoreError(const RooArgSet& aset) { return RooCmdArg("StoreError",0,0,0,0,0,0,0,0,0,0,&aset) ; }
178 RooCmdArg StoreAsymError(const RooArgSet& aset) { return RooCmdArg("StoreAsymError",0,0,0,0,0,0,0,0,0,0,&aset) ; }
179 RooCmdArg OwnLinked() { return RooCmdArg("OwnLinked",1,0,0,0,0,0,0,0,0,0,0) ; }
180
181 RooCmdArg Import(const std::map<std::string,RooDataSet*>& arg) {
182 return processMap("ImportDataSliceMany", processImportItem<RooDataSet>, arg);
183 }
184 RooCmdArg Link(const std::map<std::string,RooAbsData*>& arg) {
185 return processMap("LinkDataSliceMany", processLinkItem<RooAbsData>, arg);
186 }
187
188
189 // RooChi2Var::ctor / RooNLLVar arguments
190 RooCmdArg Extended(bool flag) { return RooCmdArg("Extended",flag,0,0,0,0,0,0,0) ; }
191 RooCmdArg DataError(Int_t etype) { return RooCmdArg("DataError",(Int_t)etype,0,0,0,0,0,0,0) ; }
192 RooCmdArg NumCPU(Int_t nCPU, Int_t interleave) { return RooCmdArg("NumCPU",nCPU,interleave,0,0,0,0,0,0) ; }
193 RooCmdArg ModularL(bool flag) { return RooCmdArg("ModularL",flag,0,0,0,0,0,0) ; }
194 RooCmdArg Parallelize(Int_t nWorkers) { return RooCmdArg("Parallelize",nWorkers,0,0,0,0,0,0,0) ; }
195 RooCmdArg TimingAnalysis(bool flag) { return RooCmdArg("TimingAnalysis",flag,0,0,0,0,0,0) ; }
196 RooCmdArg BatchMode(std::string const& batchMode) {
197 std::string lower = batchMode;
198 std::transform(lower.begin(), lower.end(), lower.begin(), [](unsigned char c){ return std::tolower(c); });
200 if(lower == "off") mode = BatchModeOption::Off;
201 else if(lower == "cpu") mode = BatchModeOption::Cpu;
202 else if(lower == "cuda") mode = BatchModeOption::Cuda;
203 else if(lower == "old") mode = BatchModeOption::Old;
204 // Note that the "old" argument is undocumented, because accessing the
205 // old batch mode is an advanced developer feature.
206 else throw std::runtime_error("Only supported string values for BatchMode() are \"off\", \"cpu\", or \"cuda\".");
207 return RooCmdArg("BatchMode", static_cast<int>(mode));
208 }
209 /// Integrate the PDF over bins. Improves accuracy for binned fits. Switch off using `0.` as argument. \see RooAbsPdf::fitTo().
210 RooCmdArg IntegrateBins(double precision) { return RooCmdArg("IntegrateBins", 0, 0, precision); }
211
212 // RooAbsCollection::printLatex arguments
213 RooCmdArg Columns(Int_t ncol) { return RooCmdArg("Columns",ncol,0,0,0,0,0,0,0) ; }
214 RooCmdArg OutputFile(const char* fileName) { return RooCmdArg("OutputFile",0,0,0,0,fileName,0,0,0) ; }
215 RooCmdArg Sibling(const RooAbsCollection& sibling) { return RooCmdArg("Sibling",0,0,0,0,0,0,&sibling,0) ; }
216 RooCmdArg Format(const char* format, Int_t sigDigit) { return RooCmdArg("Format",sigDigit,0,0,0,format,0,0,0) ; }
217 RooCmdArg Format(const char* what, const RooCmdArg& arg1,const RooCmdArg& arg2,const RooCmdArg& arg3,const RooCmdArg& arg4,
218 const RooCmdArg& arg5,const RooCmdArg& arg6,const RooCmdArg& arg7,const RooCmdArg& arg8) {
219 RooCmdArg ret("FormatArgs",0,0,0,0,what,0,0,0) ; ret.addArg(arg1) ; ret.addArg(arg2) ;
220 ret.addArg(arg3) ; ret.addArg(arg4) ; ret.addArg(arg5) ; ret.addArg(arg6) ; ret.addArg(arg7) ; ret.addArg(arg8) ;
221 ret.setProcessRecArgs(false) ; return ret ;
222 }
223
224 // RooAbsRealLValue::frame arguments
225 RooCmdArg Title(const char* name) { return RooCmdArg("Title",0,0,0,0,name,0,0,0) ; }
226 RooCmdArg Bins(Int_t nbin) { return RooCmdArg("Bins",nbin,0,0,0,0,0,0,0) ; }
227 RooCmdArg AutoSymRange(const RooAbsData& data, double marginFactor) { return RooCmdArg("AutoRange",1,0,marginFactor,0,0,0,&data,0) ; }
228 RooCmdArg AutoRange(const RooAbsData& data, double marginFactor) { return RooCmdArg("AutoRange",0,0,marginFactor,0,0,0,&data,0) ; }
229
230 // RooAbsData::reduce arguments
232 RooCmdArg out{"SelectVars",0};
233 out.setSet(0, vars);
234 return out;
235 }
236 RooCmdArg EventRange(Int_t nStart, Int_t nStop) { return RooCmdArg("EventRange",nStart,nStop,0,0,0,0,0,0) ; }
237
238 // RooAbsPdf::fitTo arguments
239 RooCmdArg PrefitDataFraction(double data_ratio) { return RooCmdArg("Prefit",0,0,data_ratio,0,nullptr,nullptr,nullptr,nullptr) ; }
240 RooCmdArg Optimize(Int_t flag) { return RooCmdArg("Optimize",flag) ; }
241 RooCmdArg Verbose(bool flag) { return RooCmdArg("Verbose",flag) ; }
242 RooCmdArg Save(bool flag) { return RooCmdArg("Save",flag) ; }
243 RooCmdArg Timer(bool flag) { return RooCmdArg("Timer",flag) ; }
244 RooCmdArg PrintLevel(Int_t level) { return RooCmdArg("PrintLevel",level) ; }
245 RooCmdArg MaxCalls(int n) { return RooCmdArg("MaxCalls",n) ; }
246 RooCmdArg Warnings(bool flag) { return RooCmdArg("Warnings",flag) ; }
247 RooCmdArg Strategy(Int_t code) { return RooCmdArg("Strategy",code) ; }
248 RooCmdArg InitialHesse(bool flag) { return RooCmdArg("InitialHesse",flag) ; }
249 RooCmdArg Hesse(bool flag) { return RooCmdArg("Hesse",flag) ; }
250 RooCmdArg Minos(bool flag) { return RooCmdArg("Minos",flag) ; }
251 RooCmdArg Minos(const RooArgSet& minosArgs) {
252 RooCmdArg out{"Minos",1};
253 out.setSet(0, minosArgs);
254 return out;
255 }
256 RooCmdArg SplitRange(bool flag) { return RooCmdArg("SplitRange",flag,0,0,0,0,0,0,0) ; }
257 RooCmdArg SumCoefRange(const char* rangeName) { return RooCmdArg("SumCoefRange",0,0,0,0,rangeName,0,0,0) ; }
259 for(RooAbsArg * param : params) {
260 if(!dynamic_cast<RooRealVar*>(param)) {
261 std::stringstream errorMsg;
262 errorMsg << "RooFit::Constrain(): you passed the argument \"" << param->GetName()
263 << "\", but it's not a RooRealVar!"
264 << " You can only constrain parameters, which must be RooRealVars.";
265 oocoutE(nullptr, InputArguments) << errorMsg.str() << std::endl;
266 throw std::invalid_argument(errorMsg.str().c_str());
267 }
268 }
269 return RooCmdArg("Constrain",0,0,0,0,0,0,0,0,0,0,&params);
270 }
271 RooCmdArg GlobalObservablesSource(const char* sourceName) { return {"GlobalObservablesSource",0,0,0,0,sourceName,0,0,0}; }
272 RooCmdArg GlobalObservablesTag(const char* tagName) { return RooCmdArg("GlobalObservablesTag",0,0,0,0,tagName,0,0,0) ; }
273 RooCmdArg ExternalConstraints(const RooArgSet& cpdfs) { return RooCmdArg("ExternalConstraints",0,0,0,0,0,0,nullptr,nullptr,0,0,&cpdfs) ; }
274 RooCmdArg PrintEvalErrors(Int_t numErrors) { return RooCmdArg("PrintEvalErrors",numErrors,0,0,0,0,0,0,0) ; }
275 RooCmdArg EvalErrorWall(bool flag) { return RooCmdArg("EvalErrorWall",flag,0,0,0,0,0,0,0) ; }
276 RooCmdArg SumW2Error(bool flag) { return RooCmdArg("SumW2Error",flag,0,0,0,0,0,0,0) ; }
277 RooCmdArg AsymptoticError(bool flag) { return RooCmdArg("AsymptoticError",flag,0,0,0,0,0,0,0) ; }
278 RooCmdArg CloneData(bool flag) { return RooCmdArg("CloneData",flag,0,0,0,0,0,0,0) ; }
279 RooCmdArg Integrate(bool flag) { return RooCmdArg("Integrate",flag,0,0,0,0,0,0,0) ; }
280 RooCmdArg Minimizer(const char* type, const char* alg) { return RooCmdArg("Minimizer",0,0,0,0,type,alg,0,0) ; }
281
282 RooCmdArg Offset(std::string const& mode) {
283 std::string lower = mode;
284 std::transform(lower.begin(), lower.end(), lower.begin(), [](unsigned char c){ return std::tolower(c); });
286 if(lower == "none") modeVal = OffsetMode::None;
287 else if(lower == "initial") modeVal = OffsetMode::Initial;
288 else if(lower == "bin") modeVal = OffsetMode::Bin;
289 return RooCmdArg("OffsetLikelihood", static_cast<int>(modeVal));
290 }
291
292 /// When parameters are chosen such that a PDF is undefined, try to indicate to the minimiser how to leave this region.
293 /// \param strength Strength of hints for minimiser. Set to zero to switch off.
294 RooCmdArg RecoverFromUndefinedRegions(double strength) { return RooCmdArg("RecoverFromUndefinedRegions",0,0,strength,0,0,0,0,0) ; }
295
296
297 // RooAbsPdf::paramOn arguments
298 RooCmdArg Label(const char* str) { return RooCmdArg("Label",0,0,0,0,str,0,0,0) ; }
299 RooCmdArg Layout(double xmin, double xmax, double ymin) { return RooCmdArg("Layout",Int_t(ymin*10000),0,xmin,xmax,0,0,0,0) ; }
301 RooCmdArg out{"Parameters",0};
302 out.setSet(0, params);
303 return out;
304 }
305 RooCmdArg ShowConstants(bool flag) { return RooCmdArg("ShowConstants",flag,0,0,0,0,0,0,0) ; }
306
307 // RooTreeData::statOn arguments
308 RooCmdArg What(const char* str) { return RooCmdArg("What",0,0,0,0,str,0,0,0) ; }
309
310 // RooProdPdf::ctor arguments
311 RooCmdArg Conditional(const RooArgSet& pdfSet, const RooArgSet& depSet, bool depsAreCond) { return RooCmdArg("Conditional",depsAreCond,0,0,0,0,0,0,0,0,0,&pdfSet,&depSet) ; } ;
312
313 // RooAbsPdf::generate arguments
314 RooCmdArg ProtoData(const RooDataSet& protoData, bool randomizeOrder, bool resample)
315 { return RooCmdArg("PrototypeData",randomizeOrder,resample,0,0,0,0,&protoData,0) ; }
316 RooCmdArg NumEvents(Int_t numEvents) { return RooCmdArg("NumEvents",numEvents,0,0,0,0,0,0,0) ; }
317 RooCmdArg NumEvents(double numEvents) { return RooCmdArg("NumEventsD",0,0,numEvents,0,0,0,0,0) ; }
318 RooCmdArg ExpectedData(bool flag) { return RooCmdArg("ExpectedData",flag,0,0,0,0,0,0,0) ; }
319 RooCmdArg Asimov(bool flag) { return ExpectedData(flag) ; }
320 RooCmdArg AutoBinned(bool flag) { return RooCmdArg("AutoBinned",flag,0,0,0,0,0,0,0) ; }
321 RooCmdArg GenBinned(const char* tag) { return RooCmdArg("GenBinned",0,0,0,0,tag,0,0,0) ; }
322 RooCmdArg AllBinned() { return RooCmdArg("GenBinned",0,0,0,0,"*",0,0,0) ; }
323
324
325 // RooAbsRealLValue::createHistogram arguments
326 RooCmdArg YVar(const RooAbsRealLValue& var, const RooCmdArg& arg) { return RooCmdArg("YVar",0,0,0,0,0,0,&var,0,&arg) ; }
327 RooCmdArg ZVar(const RooAbsRealLValue& var, const RooCmdArg& arg) { return RooCmdArg("ZVar",0,0,0,0,0,0,&var,0,&arg) ; }
328 RooCmdArg AxisLabel(const char* name) { return RooCmdArg("AxisLabel",0,0,0,0,name,0,0,0) ; }
329 RooCmdArg Scaling(bool flag) { return RooCmdArg("Scaling",flag,0,0,0,0,0,0,0) ; }
330
331 // RooAbsReal::createHistogram arguments
332 RooCmdArg IntrinsicBinning(bool flag) { return RooCmdArg("IntrinsicBinning",flag,0,0,0,0,0,0,0) ; }
333
334 // RooAbsData::createHistogram arguments
335 RooCmdArg AutoSymBinning(Int_t nbins, double marginFactor) { return RooCmdArg("AutoRangeData",1,nbins,marginFactor,0,0,0,0,0) ; }
336 RooCmdArg AutoBinning(Int_t nbins, double marginFactor) { return RooCmdArg("AutoRangeData",0,nbins,marginFactor,0,0,0,0,0) ; }
337
338 // RooAbsReal::fillHistogram arguments
339 RooCmdArg IntegratedObservables(const RooArgSet& intObs) { return RooCmdArg("IntObs",0,0,0,0,0,0,0,0,0,0,&intObs,0) ; } ;
340
341 // RooAbsReal::createIntegral arguments
342 RooCmdArg NumIntConfig(const RooNumIntConfig& cfg) { return RooCmdArg("NumIntConfig",0,0,0,0,0,0,&cfg,0) ; }
343
344 // RooMCStudy::ctor arguments
345 RooCmdArg Silence(bool flag) { return RooCmdArg("Silence",flag,0,0,0,0,0,0,0) ; }
346 RooCmdArg FitModel(RooAbsPdf& pdf) { return RooCmdArg("FitModel",0,0,0,0,0,0,&pdf,0) ; }
347 RooCmdArg FitOptions(const RooCmdArg& arg1 ,const RooCmdArg& arg2, const RooCmdArg& arg3,
348 const RooCmdArg& arg4, const RooCmdArg& arg5, const RooCmdArg& arg6) {
349 RooCmdArg ret("FitOptArgs",0,0,0,0,0,0,0,0) ; ret.addArg(arg1) ; ret.addArg(arg2) ;
350 ret.addArg(arg3) ; ret.addArg(arg4) ; ret.addArg(arg5) ; ret.addArg(arg6) ;
351 ret.setProcessRecArgs(false) ; return ret ;
352 }
353 RooCmdArg Binned(bool flag) { return RooCmdArg("Binned",flag,0,0,0,0,0,0,0) ; }
354 RooCmdArg BootStrapData(const RooDataSet& dset) { return RooCmdArg("BootStrapData",0,0,0,0,0,0,&dset,0) ; }
355
356
357 // RooMCStudy::plot* arguments
358 RooCmdArg Frame(const RooCmdArg& arg1,const RooCmdArg& arg2,
359 const RooCmdArg& arg3,const RooCmdArg& arg4,
360 const RooCmdArg& arg5,const RooCmdArg& arg6) {
361 RooCmdArg ret("FrameArgs",0,0,0,0,0,0,0,0) ; ret.addArg(arg1) ; ret.addArg(arg2) ;
362 ret.addArg(arg3) ; ret.addArg(arg4) ; ret.addArg(arg5) ; ret.addArg(arg6) ;
363 ret.setProcessRecArgs(false) ; return ret ;
364 }
365 RooCmdArg FrameBins(Int_t nbins) { return RooCmdArg("Bins",nbins,0,0,0,0,0,0,0) ; }
366 RooCmdArg FrameRange(double xlo, double xhi) { return RooCmdArg("Range",0,0,xlo,xhi,0,0,0,0) ; }
367 RooCmdArg FitGauss(bool flag) { return RooCmdArg("FitGauss",flag,0,0,0,0,0,0,0) ; }
368
369 // RooRealVar::format arguments
370 RooCmdArg ShowName(bool flag) { return RooCmdArg("ShowName",flag,0,0,0,0,0,0,0) ; }
371 RooCmdArg ShowValue(bool flag) { return RooCmdArg("ShowValue",flag,0,0,0,0,0,0,0) ; }
372 RooCmdArg ShowError(bool flag) { return RooCmdArg("ShowError",flag,0,0,0,0,0,0,0) ; }
373 RooCmdArg ShowAsymError(bool flag) { return RooCmdArg("ShowAsymError",flag,0,0,0,0,0,0,0) ; }
374 RooCmdArg ShowUnit(bool flag) { return RooCmdArg("ShowUnit",flag,0,0,0,0,0,0,0) ; }
375 RooCmdArg AutoPrecision(Int_t ndigit) { return RooCmdArg("AutoPrecision",ndigit,0,0,0,0,0,0,0) ; }
376 RooCmdArg FixedPrecision(Int_t ndigit) { return RooCmdArg("FixedPrecision",ndigit,0,0,0,0,0,0,0) ; }
377 RooCmdArg TLatexStyle(bool flag) { return RooCmdArg("TLatexStyle",flag,0,0,0,0,0,0,0) ; }
378 RooCmdArg LatexStyle(bool flag) { return RooCmdArg("LatexStyle",flag,0,0,0,0,0,0,0) ; }
379 RooCmdArg LatexTableStyle(bool flag) { return RooCmdArg("LatexTableStyle",flag,0,0,0,0,0,0,0) ; }
380 RooCmdArg VerbatimName(bool flag) { return RooCmdArg("VerbatimName",flag,0,0,0,0,0,0,0) ; }
381
382 // RooMsgService::addReportingStream arguments
383 RooCmdArg Topic(Int_t topic) { return RooCmdArg("Topic",topic,0,0,0,0,0,0,0) ; }
384 RooCmdArg ObjectName(const char* name) { return RooCmdArg("ObjectName",0,0,0,0,name,0,0,0) ; }
385 RooCmdArg ClassName(const char* name) { return RooCmdArg("ClassName",0,0,0,0,name,0,0,0) ; }
386 RooCmdArg BaseClassName(const char* name) { return RooCmdArg("BaseClassName",0,0,0,0,name,0,0,0) ; }
387 RooCmdArg TagName(const char* name) { return RooCmdArg("LabelName",0,0,0,0,name,0,0,0) ; }
388 RooCmdArg OutputStream(ostream& os) { return RooCmdArg("OutputStream",0,0,0,0,0,0,new RooHelpers::WrapIntoTObject<ostream>(os),0) ; }
389 RooCmdArg Prefix(bool flag) { return RooCmdArg("Prefix",flag,0,0,0,0,0,0,0) ; }
390 RooCmdArg Color(Color_t color) { return RooCmdArg("Color",color,0,0,0,0,0,0,0) ; }
391
392
393 // RooWorkspace::import() arguments
394 RooCmdArg RenameConflictNodes(const char* suffix, bool ro) { return RooCmdArg("RenameConflictNodes",ro,0,0,0,suffix,0,0,0) ; }
395 RooCmdArg RecycleConflictNodes(bool flag) { return RooCmdArg("RecycleConflictNodes",flag,0,0,0,0,0,0,0) ; }
396 RooCmdArg RenameAllNodes(const char* suffix) { return RooCmdArg("RenameAllNodes",0,0,0,0,suffix,0,0,0) ; }
397 RooCmdArg RenameAllVariables(const char* suffix) { return RooCmdArg("RenameAllVariables",0,0,0,0,suffix,0,0,0) ; }
398 RooCmdArg RenameAllVariablesExcept(const char* suffix, const char* except) { return RooCmdArg("RenameAllVariables",0,0,0,0,suffix,except,0,0) ; }
399 RooCmdArg RenameVariable(const char* in, const char* out) { return RooCmdArg("RenameVar",0,0,0,0,in,out,0,0) ; }
400 RooCmdArg Rename(const char* suffix) { return RooCmdArg("Rename",0,0,0,0,suffix,0,0,0) ; }
401 RooCmdArg Embedded(bool flag) { return RooCmdArg("Embedded",flag,0,0,0,0,0,0,0) ; }
402 RooCmdArg NoRecursion(bool flag) { return RooCmdArg("NoRecursion",flag,0,0,0,0,0,0,0) ; }
403
404 // RooSimCloneTool::build() arguments
405 RooCmdArg SplitParam(const char* varname, const char* catname) { return RooCmdArg("SplitParam",0,0,0,0,varname,catname,0,0) ; }
406 RooCmdArg SplitParam(const RooRealVar& var, const RooAbsCategory& cat) { return RooCmdArg("SplitParam",0,0,0,0,var.GetName(),cat.GetName(),0,0) ; }
407 RooCmdArg SplitParamConstrained(const char* varname, const char* catname, const char* rsname) { return RooCmdArg("SplitParamConstrained",0,0,0,0,varname,catname,0,0,0,rsname) ; }
408 RooCmdArg SplitParamConstrained(const RooRealVar& var, const RooAbsCategory& cat, const char* rsname) { return RooCmdArg("SplitParamConstrained",0,0,0,0,var.GetName(),cat.GetName(),0,0,0,rsname) ; }
409 RooCmdArg Restrict(const char* catName, const char* stateNameList) { return RooCmdArg("Restrict",0,0,0,0,catName,stateNameList,0,0) ; }
410
411 // RooAbsPdf::createCdf() arguments
413 RooCmdArg out{"SupNormSet",0};
414 out.setSet(0, nset);
415 return out;
416 }
417 RooCmdArg ScanParameters(Int_t nbins,Int_t intOrder) { return RooCmdArg("ScanParameters",nbins,intOrder,0,0,0,0,0,0) ; }
418 RooCmdArg ScanNumCdf() { return RooCmdArg("ScanNumCdf",1,0,0,0,0,0,0,0) ; }
419 RooCmdArg ScanAllCdf() { return RooCmdArg("ScanAllCdf",1,0,0,0,0,0,0,0) ; }
420 RooCmdArg ScanNoCdf() { return RooCmdArg("ScanNoCdf",1,0,0,0,0,0,0,0) ; }
421
422
423 RooCmdArg MultiArg(const RooCmdArg& arg1,const RooCmdArg& arg2,const RooCmdArg& arg3,const RooCmdArg& arg4,
424 const RooCmdArg& arg5,const RooCmdArg& arg6,const RooCmdArg& arg7,const RooCmdArg& arg8) {
425 RooCmdArg ret("MultiArg",0,0,0,0,0,0,0,0) ; ret.addArg(arg1) ; ret.addArg(arg2) ;
426 ret.addArg(arg3) ; ret.addArg(arg4) ; ret.addArg(arg5) ; ret.addArg(arg6) ; ret.addArg(arg7) ; ret.addArg(arg8) ;
427 ret.setProcessRecArgs(true,false) ; return ret ;
428 }
429
430 RooConstVar& RooConst(double val) { return RooRealConstant::value(val) ; }
431
432
433} // End namespace RooFit
434
435namespace RooFitShortHand {
436
438
439} // 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)
Definition: RooMsgService.h:52
short Style_t
Definition: RtypesCore.h:89
int Int_t
Definition: RtypesCore.h:45
short Color_t
Definition: RtypesCore.h:92
float Size_t
Definition: RtypesCore.h:96
short Width_t
Definition: RtypesCore.h:91
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 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 format
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
Definition: THbookFile.cxx:95
#define hi
Definition: THbookFile.cxx:128
float ymin
Definition: THbookFile.cxx:95
float xmax
Definition: THbookFile.cxx:95
void(* Func_t)()
Definition: TSystem.h:238
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooAbsBinning is the abstract base class for RooRealVar binning definitions.
Definition: RooAbsBinning.h:25
A space to attach TBranches.
RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects.
RooAbsData is the common abstract base class for binned and unbinned datasets.
Definition: RooAbsData.h:61
RooAbsRealLValue is the common abstract base class for objects that represent a real value that may a...
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:56
RooCategory is an object to represent discrete states.
Definition: RooCategory.h:28
RooCmdArg is a named container for two doubles, two integers two object points and three string point...
Definition: RooCmdArg.h:26
void addArg(const RooCmdArg &arg)
Utility function to add nested RooCmdArg to payload of this RooCmdArg.
Definition: RooCmdArg.cxx:189
void setSet(Int_t idx, const RooArgSet &set)
Definition: RooCmdArg.cxx:207
void setProcessRecArgs(bool flag, bool prefix=true)
Definition: RooCmdArg.h:45
RooConstVar represent a constant real-valued object.
Definition: RooConstVar.h:26
The RooDataHist is a container class to hold N-dimensional binned data.
Definition: RooDataHist.h:39
RooDataSet is a container class to hold unbinned data.
Definition: RooDataSet.h:55
RooFitResult is a container class to hold the input and output of a PDF fit to a dataset.
Definition: RooFitResult.h:40
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Definition: RooFormulaVar.h:30
RooNumIntConfig holds the configuration parameters of the various numeric integrators used by RooReal...
static RooConstVar & value(double value)
Return a constant value object with given value.
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:40
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
const char * GetName() const override
Returns name of object.
Definition: TNamed.h:47
Mother of all ROOT objects.
Definition: TObject.h:41
A TTree represents a columnar dataset.
Definition: TTree.h:79
RooCmdArg RecycleConflictNodes(bool flag=true)
RooCmdArg ScanNoCdf()
RooCmdArg AutoRange(const RooAbsData &data, double marginFactor=0.1)
RooCmdArg YVar(const RooAbsRealLValue &var, const RooCmdArg &arg=RooCmdArg::none())
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 ZVar(const RooAbsRealLValue &var, const RooCmdArg &arg=RooCmdArg::none())
RooCmdArg FitOptions(const RooCmdArg &arg1, const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none())
RooCmdArg TagName(const char *name)
RooCmdArg BaseClassName(const char *name)
RooCmdArg IntrinsicBinning(bool flag=true)
RooCmdArg Restrict(const char *catName, const char *stateNameList)
RooCmdArg TLatexStyle(bool flag=true)
RooCmdArg MultiArg(const RooCmdArg &arg1, const RooCmdArg &arg2, const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none())
RooCmdArg RenameAllVariables(const char *suffix)
RooCmdArg ShowConstants(bool flag=true)
RooCmdArg RenameVariable(const char *inputName, const char *outputName)
RooCmdArg Color(Color_t color)
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 SplitParam(const char *varname, const char *catname)
RooCmdArg Rename(const char *suffix)
RooCmdArg Format(const char *format, Int_t sigDigit)
RooCmdArg SupNormSet(const RooArgSet &nset)
RooCmdArg SelectVars(const RooArgSet &vars)
RooCmdArg AutoBinning(Int_t nbins=100, double marginFactor=0.1)
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 Frame(const RooCmdArg &arg1, const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none())
RooCmdArg ObjectName(const char *name)
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 Import(const char *state, TH1 &histo)
RooCmdArg WeightVar(const char *name, bool reinterpretAsWeight=false)
RooCmdArg InitialHesse(bool flag=true)
RooCmdArg IntegrateBins(double precision)
Integrate the PDF over bins. Improves accuracy for binned fits. Switch off using 0....
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 DataError(Int_t)
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 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 BatchMode(std::string const &batchMode="cpu")
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 MarkerColor(Color_t color)
RooCmdArg RefreshNorm()
RooCmdArg Components(Args_t &&... argsOrArgSet)
RooCmdArg ProjectionRange(const char *rangeName)
RooCmdArg FillColor(Color_t 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 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 Rescale(double factor)
RooCmdArg Cut(const char *cutSpec)
RooCmdArg Efficiency(const RooCategory &cat)
RooCmdArg LineColor(Color_t color)
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 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)
std::string & defaultBatchMode()
Get a handle on the default BatchMode option that is used when creating likelihoods.
The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or othe...
Definition: Common.h:18
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()
Definition: RooGlobalFunc.h:73
BatchModeOption
For setting the batch mode flag with the BatchMode() command argument to RooAbsPdf::fitTo()
Definition: RooGlobalFunc.h:69
@ InputArguments
Definition: RooGlobalFunc.h:63
RooCmdArg ShowValue(bool flag)
RooCmdArg ShowAsymError(bool flag)
RooCmdArg ShowUnit(bool flag)
Definition: tree.py:1
void inv(rsa_NUMBER *, rsa_NUMBER *, rsa_NUMBER *)
Definition: rsaaux.cxx:949
static const char * what
Definition: stlLoader.cc:6
Wrap an object into a TObject. Sometimes needed to avoid reinterpret_cast or enable RTTI.
Definition: RooHelpers.h:65