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