Logo ROOT  
Reference Guide
RooChi2Var.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 /** \class RooChi2Var
18 RooChi2Var implements a simple \f$ \chi^2 \f$ calculation from a binned dataset
19 and a PDF. It calculates
20 
21 \f{align*}{
22  \chi^2 &= \sum_{\mathrm{bins}} \left( \frac{N_\mathrm{PDF,bin} - N_\mathrm{Data,bin}}{\Delta_\mathrm{bin}} \right)^2, \\
23  \text{where} \\
24  N_\mathrm{PDF,bin} &=
25  \begin{cases}
26  \mathrm{pdf}(\text{bin centre}) \cdot V_\mathrm{bin} \cdot N_\mathrm{Data,tot} &\text{if normal PDF}\\
27  \mathrm{pdf}(\text{bin centre}) \cdot V_\mathrm{bin} \cdot N_\mathrm{Data,expected} &\text{if extended PDF}
28  \end{cases} \\
29  \text{and} \\
30  \Delta_\mathrm{bin} &=
31  \begin{cases}
32  \sqrt{N_\mathrm{PDF,bin}} &\text{if } \mathtt{DataError == RooAbsData::Expected}\\
33  \mathtt{data{\rightarrow}weightError()} &\text{otherwise} \\
34  \end{cases}
35 \f}
36 
37 If the dataset doesn't have user-defined errors, errors are assumed to be \f$ \sqrt{N} \f$.
38 In extended PDF mode, N_tot (total number of data events) is substituted with N_expected, the
39 expected number of events that the PDF predicts.
40  *
41 \note If the dataset has errors stored, empty bins will prevent the calculation of \f$ \chi^2 \f$, because those have
42 zero error. This leads to messages like:
43 ```
44  [#0] ERROR:Eval -- RooChi2Var::RooChi2Var(chi2_GenPdf_data_hist) INFINITY ERROR: bin 2 has zero error
45 ```
46  *
47 \note In this case, one can use the expected errors of the PDF instead of the data errors:
48 ```{.cpp}
49 RooChi2Var chi2(..., ..., RooFit::DataError(RooAbsData::Expected), ...);
50 ```
51 
52  */
53 
54 #include "RooFit.h"
55 
56 #include "RooChi2Var.h"
57 #include "RooDataHist.h"
58 #include "RooAbsPdf.h"
59 #include "RooCmdConfig.h"
60 #include "RooMsgService.h"
61 
62 #include "Riostream.h"
63 #include "TClass.h"
64 
65 #include "RooRealVar.h"
66 #include "RooAbsDataStore.h"
67 
68 
69 using namespace std;
70 
71 namespace {
72  template<class ...Args>
73  RooAbsTestStatistic::Configuration makeRooAbsTestStatisticCfgForFunc(Args const& ... args) {
75  cfg.rangeName = RooCmdConfig::decodeStringOnTheFly("RooChi2Var::RooChi2Var","RangeWithName",0,"",args...);
76  cfg.nCPU = RooCmdConfig::decodeIntOnTheFly("RooChi2Var::RooChi2Var","NumCPU",0,1,args...);
78  cfg.verbose = static_cast<bool>(RooCmdConfig::decodeIntOnTheFly("RooChi2Var::RooChi2Var","Verbose",0,1,args...));
79  cfg.cloneInputData = false;
80  cfg.integrateOverBinsPrecision = RooCmdConfig::decodeDoubleOnTheFly("RooChi2Var::RooChi2Var", "IntegrateBins", 0, -1., {args...});
81  return cfg;
82  }
83 
84  template<class ...Args>
85  RooAbsTestStatistic::Configuration makeRooAbsTestStatisticCfgForPdf(Args const& ... args) {
86  auto cfg = makeRooAbsTestStatisticCfgForFunc(args...);
87  cfg.addCoefRangeName = RooCmdConfig::decodeStringOnTheFly("RooChi2Var::RooChi2Var","AddCoefRange",0,"",args...);
88  cfg.splitCutRange = static_cast<bool>(RooCmdConfig::decodeIntOnTheFly("RooChi2Var::RooChi2Var","SplitRange",0,0,args...));
89  return cfg;
90  }
91 }
92 
94 ;
95 
97 
98 
99 ////////////////////////////////////////////////////////////////////////////////
100 /// RooChi2Var constructor. Optional arguments are:
101 /// \param[in] name Name of the PDF
102 /// \param[in] title Title for plotting etc.
103 /// \param[in] func Function
104 /// \param[in] hdata Data histogram
105 /// \param[in] argX Optional arguments according to table below.
106 /// <table>
107 /// <tr><th> Argument <th> Effect
108 /// <tr><td>
109 /// DataError() <td> Choose between Poisson errors and Sum-of-weights errors
110 /// <tr><td>
111 /// NumCPU() <td> Activate parallel processing feature
112 /// <tr><td>
113 /// Range() <td> Fit only selected region
114 /// <tr><td>
115 /// Verbose() <td> Verbose output of GOF framework
116 /// <tr><td>
117 /// IntegrateBins() <td> Integrate PDF within each bin. This sets the desired precision. Only useful for binned fits.
118 
119 RooChi2Var::RooChi2Var(const char *name, const char* title, RooAbsReal& func, RooDataHist& hdata,
120  const RooCmdArg& arg1,const RooCmdArg& arg2,const RooCmdArg& arg3,
121  const RooCmdArg& arg4,const RooCmdArg& arg5,const RooCmdArg& arg6,
122  const RooCmdArg& arg7,const RooCmdArg& arg8,const RooCmdArg& arg9) :
123  RooAbsOptTestStatistic(name,title,func,hdata,_emptySet,
124  makeRooAbsTestStatisticCfgForFunc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9))
125 {
126  RooCmdConfig pc("RooChi2Var::RooChi2Var") ;
127  pc.defineInt("etype","DataError",0,(Int_t)RooDataHist::Auto) ;
128  pc.defineInt("extended","Extended",0,kFALSE) ;
129  pc.allowUndefined() ;
130 
131  pc.process(arg1) ; pc.process(arg2) ; pc.process(arg3) ;
132  pc.process(arg4) ; pc.process(arg5) ; pc.process(arg6) ;
133  pc.process(arg7) ; pc.process(arg8) ; pc.process(arg9) ;
134 
135  if (func.IsA()->InheritsFrom(RooAbsPdf::Class())) {
136  _funcMode = pc.getInt("extended") ? ExtendedPdf : Pdf ;
137  } else {
138  _funcMode = Function ;
139  }
140  _etype = (RooDataHist::ErrorType) pc.getInt("etype") ;
141 
142  if (_etype==RooAbsData::Auto) {
144  }
145 
146 }
147 
148 
149 
150 ////////////////////////////////////////////////////////////////////////////////
151 /// RooChi2Var constructor. Optional arguments taken
152 ///
153 /// \param[in] name Name of the PDF
154 /// \param[in] title Title for plotting etc.
155 /// \param[in] pdf PDF to fit
156 /// \param[in] hdata Data histogram
157 /// \param[in] argX Optional arguments according to table below.
158 /// <table>
159 /// <tr><th> Argument <th> Effect
160 /// <tr><td>
161 /// Extended() <td> Include extended term in calculation
162 /// <tr><td>
163 /// DataError() <td> Choose between Poisson errors and Sum-of-weights errors
164 /// <tr><td>
165 /// NumCPU() <td> Activate parallel processing feature
166 /// <tr><td>
167 /// Range() <td> Fit only selected region
168 /// <tr><td>
169 /// SumCoefRange() <td> Set the range in which to interpret the coefficients of RooAddPdf components
170 /// <tr><td>
171 /// SplitRange() <td> Fit range is split by index category of simultaneous PDF
172 /// <tr><td>
173 /// ConditionalObservables() <td> Define projected observables
174 /// <tr><td>
175 /// Verbose() <td> Verbose output of GOF framework
176 /// <tr><td>
177 /// IntegrateBins() <td> Integrate PDF within each bin. This sets the desired precision.
178 
179 RooChi2Var::RooChi2Var(const char *name, const char* title, RooAbsPdf& pdf, RooDataHist& hdata,
180  const RooCmdArg& arg1,const RooCmdArg& arg2,const RooCmdArg& arg3,
181  const RooCmdArg& arg4,const RooCmdArg& arg5,const RooCmdArg& arg6,
182  const RooCmdArg& arg7,const RooCmdArg& arg8,const RooCmdArg& arg9) :
183  RooAbsOptTestStatistic(name,title,pdf,hdata,
184  *static_cast<const RooArgSet*>(RooCmdConfig::decodeObjOnTheFly("RooChi2Var::RooChi2Var","ProjectedObservables",0,&_emptySet,
185  arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9)),
186  makeRooAbsTestStatisticCfgForPdf(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9))
187 {
188  RooCmdConfig pc("RooChi2Var::RooChi2Var") ;
189  pc.defineInt("extended","Extended",0,kFALSE) ;
190  pc.defineInt("etype","DataError",0,(Int_t)RooDataHist::Auto) ;
191  pc.allowUndefined() ;
192 
193  pc.process(arg1) ; pc.process(arg2) ; pc.process(arg3) ;
194  pc.process(arg4) ; pc.process(arg5) ; pc.process(arg6) ;
195  pc.process(arg7) ; pc.process(arg8) ; pc.process(arg9) ;
196 
197  _funcMode = pc.getInt("extended") ? ExtendedPdf : Pdf ;
198  _etype = (RooDataHist::ErrorType) pc.getInt("etype") ;
199  if (_etype==RooAbsData::Auto) {
201  }
202 }
203 
204 
205 
206 ////////////////////////////////////////////////////////////////////////////////
207 /// Constructor of a chi2 for given p.d.f. with respect given binned
208 /// dataset. If cutRange is specified the calculation of the chi2 is
209 /// restricted to that named range. If addCoefRange is specified, the
210 /// interpretation of fractions for all component RooAddPdfs that do
211 /// not have a frozen range interpretation is set to chosen range
212 /// name. If nCPU is greater than one the chi^2 calculation is
213 /// parallelized over the specified number of processors. If
214 /// interleave is true the partitioning of event over processors
215 /// follows a (i % n == i_set) strategy rather than a bulk
216 /// partitioning strategy which may result in unequal load balancing
217 /// in binned datasets with many (adjacent) zero bins. If
218 /// splitCutRange is true the cutRange is used to construct an
219 /// individual cutRange for each RooSimultaneous index category state
220 /// name cutRange_{indexStateName}.
221 
222 RooChi2Var::RooChi2Var(const char *name, const char *title, RooAbsPdf& pdf, RooDataHist& hdata,
223  RooAbsTestStatistic::Configuration const& cfg, bool extended, RooDataHist::ErrorType etype) :
224  RooAbsOptTestStatistic(name,title,pdf,hdata,RooArgSet(), cfg),
225  _etype(etype), _funcMode(extended?ExtendedPdf:Pdf)
226 {
227 }
228 
229 
230 
231 ////////////////////////////////////////////////////////////////////////////////
232 /// Constructor of a chi2 for given p.d.f. with respect given binned
233 /// dataset taking the observables specified in projDeps as projected
234 /// observables. If cutRange is specified the calculation of the chi2
235 /// is restricted to that named range. If addCoefRange is specified,
236 /// the interpretation of fractions for all component RooAddPdfs that
237 /// do not have a frozen range interpretation is set to chosen range
238 /// name. If nCPU is greater than one the chi^2 calculation is
239 /// parallelized over the specified number of processors. If
240 /// interleave is true the partitioning of event over processors
241 /// follows a (i % n == i_set) strategy rather than a bulk
242 /// partitioning strategy which may result in unequal load balancing
243 /// in binned datasets with many (adjacent) zero bins. If
244 /// splitCutRange is true the cutRange is used to construct an
245 /// individual cutRange for each RooSimultaneous index category state
246 /// name cutRange_{indexStateName}.
247 
248 RooChi2Var::RooChi2Var(const char *name, const char *title, RooAbsReal& func, RooDataHist& hdata,
249  const RooArgSet& projDeps, RooChi2Var::FuncMode fmode,
251  RooDataHist::ErrorType etype) :
252  RooAbsOptTestStatistic(name,title,func,hdata,projDeps,cfg),
253  _etype(etype), _funcMode(fmode)
254 {
255 }
256 
257 
258 
259 ////////////////////////////////////////////////////////////////////////////////
260 /// Copy constructor
261 
262 RooChi2Var::RooChi2Var(const RooChi2Var& other, const char* name) :
264  _etype(other._etype),
265  _funcMode(other._funcMode)
266 {
267 }
268 
269 
270 
271 ////////////////////////////////////////////////////////////////////////////////
272 /// Destructor
273 
275 {
276 }
277 
278 
279 
280 ////////////////////////////////////////////////////////////////////////////////
281 /// Calculate chi^2 in partition from firstEvent to lastEvent using given stepSize
282 /// Throughout the calculation, we use Kahan's algorithm for summing to
283 /// prevent loss of precision - this is a factor four more expensive than
284 /// straight addition, but since evaluating the PDF is usually much more
285 /// expensive than that, we tolerate the additional cost...
286 
287 Double_t RooChi2Var::evaluatePartition(std::size_t firstEvent, std::size_t lastEvent, std::size_t stepSize) const
288 {
289 
290  Double_t result(0), carry(0);
291 
292  _dataClone->store()->recalculateCache( _projDeps, firstEvent, lastEvent, stepSize, kFALSE) ;
293 
294 
295  // Determine normalization factor depending on type of input function
296  Double_t normFactor(1) ;
297  switch (_funcMode) {
298  case Function: normFactor=1 ; break ;
299  case Pdf: normFactor = _dataClone->sumEntries() ; break ;
300  case ExtendedPdf: normFactor = ((RooAbsPdf*)_funcClone)->expectedEvents(_dataClone->get()) ; break ;
301  }
302 
303  // Loop over bins of dataset
304  RooDataHist* hdata = (RooDataHist*) _dataClone ;
305  for (auto i=firstEvent ; i<lastEvent ; i+=stepSize) {
306 
307  // get the data values for this event
308  hdata->get(i);
309 
310  if (!hdata->valid()) continue;
311 
312  const Double_t nData = hdata->weight() ;
313 
314  const Double_t nPdf = _funcClone->getVal(_normSet) * normFactor * hdata->binVolume() ;
315 
316  const Double_t eExt = nPdf-nData ;
317 
318 
319  Double_t eInt ;
320  if (_etype != RooAbsData::Expected) {
321  Double_t eIntLo,eIntHi ;
322  hdata->weightError(eIntLo,eIntHi,_etype) ;
323  eInt = (eExt>0) ? eIntHi : eIntLo ;
324  } else {
325  eInt = sqrt(nPdf) ;
326  }
327 
328  // Skip cases where pdf=0 and there is no data
329  if (0. == eInt * eInt && 0. == nData * nData && 0. == nPdf * nPdf) continue ;
330 
331  // Return 0 if eInt=0, special handling in MINUIT will follow
332  if (0. == eInt * eInt) {
333  coutE(Eval) << "RooChi2Var::RooChi2Var(" << GetName() << ") INFINITY ERROR: bin " << i
334  << " has zero error" << endl ;
335  return 0.;
336  }
337 
338 // cout << "Chi2Var[" << i << "] nData = " << nData << " nPdf = " << nPdf << " errorExt = " << eExt << " errorInt = " << eInt << " contrib = " << eExt*eExt/(eInt*eInt) << endl ;
339 
340  Double_t term = eExt*eExt/(eInt*eInt) ;
341  Double_t y = term - carry;
342  Double_t t = result + y;
343  carry = (t - result) - y;
344  result = t;
345  }
346 
347  _evalCarry = carry;
348  return result ;
349 }
RooChi2Var::RooChi2Var
RooChi2Var(const char *name, const char *title, RooAbsReal &func, RooDataHist &data, 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(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none(), const RooCmdArg &arg9=RooCmdArg::none())
RooChi2Var::_emptySet
static RooArgSet _emptySet
Definition: RooChi2Var.h:68
RooCmdArg
RooCmdArg is a named container for two doubles, two integers two object points and three string point...
Definition: RooCmdArg.h:27
RooCmdConfig.h
RooMsgService.h
RooChi2Var::FuncMode
FuncMode
Definition: RooChi2Var.h:39
RooDataHist::weight
double weight(std::size_t i) const
Return weight of i-th bin.
Definition: RooDataHist.h:102
RooAbsData::SumW2
@ SumW2
Definition: RooAbsData.h:99
RooFit.h
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
RooAbsTestStatistic::Configuration::cloneInputData
bool cloneInputData
Definition: RooAbsTestStatistic.h:51
RooAbsOptTestStatistic::_funcClone
RooAbsReal * _funcClone
Definition: RooAbsOptTestStatistic.h:81
coutE
#define coutE(a)
Definition: RooMsgService.h:33
RooAbsData::Auto
@ Auto
Definition: RooAbsData.h:99
RooAbsReal::getVal
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:91
RooAbsTestStatistic::Configuration::rangeName
std::string rangeName
Stores the configuration parameters for RooAbsTestStatistic.
Definition: RooAbsTestStatistic.h:45
RooChi2Var
Definition: RooChi2Var.h:25
RooChi2Var::Function
@ Function
Definition: RooChi2Var.h:39
RooAbsTestStatistic::Configuration::verbose
bool verbose
Definition: RooAbsTestStatistic.h:49
TGeant4Unit::pc
static constexpr double pc
Definition: TGeant4SystemOfUnits.h:130
RooChi2Var::evaluatePartition
virtual Double_t evaluatePartition(std::size_t firstEvent, std::size_t lastEvent, std::size_t stepSize) const
RooAbsData::store
RooAbsDataStore * store()
Definition: RooAbsData.h:68
TClass.h
RooAbsReal
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:61
RooAbsOptTestStatistic::_dataClone
RooAbsData * _dataClone
Definition: RooAbsOptTestStatistic.h:80
Function
Double_t(* Function)(Double_t)
Definition: Functor.C:4
RooDataHist::weightError
void weightError(Double_t &lo, Double_t &hi, ErrorType etype=Poisson) const override
Return the error of current weight.
Definition: RooDataHist.cxx:1244
RooAbsTestStatistic::_evalCarry
Double_t _evalCarry
Offset as KahanSum to avoid loss of precision.
Definition: RooAbsTestStatistic.h:159
RooAbsData::ErrorType
ErrorType
Definition: RooAbsData.h:99
TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:445
RooAbsData::sumEntries
virtual Double_t sumEntries() const =0
Return effective number of entries in dataset, i.e., sum all weights.
RooChi2Var.h
RooAbsTestStatistic::Configuration::addCoefRangeName
std::string addCoefRangeName
Definition: RooAbsTestStatistic.h:46
RooCmdConfig
Class RooCmdConfig is a configurable parser for RooCmdArg named arguments.
Definition: RooCmdConfig.h:27
RooAbsData::Expected
@ Expected
Definition: RooAbsData.h:99
RooAbsTestStatistic::Configuration::interleave
RooFit::MPSplit interleave
Definition: RooAbsTestStatistic.h:48
RooDataHist
The RooDataHist is a container class to hold N-dimensional binned data.
Definition: RooDataHist.h:37
RooDataHist::get
const RooArgSet * get() const override
Get bin centre of current bin.
Definition: RooDataHist.h:74
RooCmdConfig::decodeDoubleOnTheFly
static double decodeDoubleOnTheFly(const char *callerID, const char *cmdArgName, int idx, double defVal, std::initializer_list< std::reference_wrapper< const RooCmdArg >> args)
Find a given double in a list of RooCmdArg.
Definition: RooCmdConfig.cxx:897
RooFit::Interleave
@ Interleave
Definition: RooGlobalFunc.h:63
RooAbsPdf.h
RooAbsOptTestStatistic::_projDeps
RooArgSet * _projDeps
Definition: RooAbsOptTestStatistic.h:82
RooAbsDataStore::recalculateCache
virtual void recalculateCache(const RooArgSet *, Int_t, Int_t, Int_t, Bool_t)
Definition: RooAbsDataStore.h:111
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:101
RooDataHist.h
RooAbsData::get
virtual const RooArgSet * get() const
Definition: RooAbsData.h:92
RooChi2Var::_etype
RooDataHist::ErrorType _etype
Definition: RooChi2Var.h:70
RooAbsTestStatistic::Configuration
Definition: RooAbsTestStatistic.h:43
y
Double_t y[n]
Definition: legend1.C:17
sqrt
double sqrt(double)
RooDataHist::isNonPoissonWeighted
Bool_t isNonPoissonWeighted() const override
Returns true if dataset contains entries with a non-integer weight.
Definition: RooDataHist.cxx:2023
RooRealVar.h
RooDataHist::valid
bool valid(std::size_t i) const
Return true if bin i is considered valid within the current range definitions of all observables.
Definition: RooDataHist.h:111
RooChi2Var::~RooChi2Var
virtual ~RooChi2Var()
RooAbsDataStore.h
RooDataHist::binVolume
double binVolume(std::size_t i) const
Return bin volume of i-th bin.
Definition: RooDataHist.h:108
RooCmdConfig::decodeStringOnTheFly
static std::string decodeStringOnTheFly(const char *callerID, const char *cmdArgName, Int_t intIdx, const char *defVal, const RooCmdArg &arg1, const RooCmdArg &arg2=RooCmdArg(), const RooCmdArg &arg3=RooCmdArg(), const RooCmdArg &arg4=RooCmdArg(), const RooCmdArg &arg5=RooCmdArg(), const RooCmdArg &arg6=RooCmdArg(), const RooCmdArg &arg7=RooCmdArg(), const RooCmdArg &arg8=RooCmdArg(), const RooCmdArg &arg9=RooCmdArg())
Static decoder function allows to retrieve string property from set of RooCmdArgs For use in base mem...
Definition: RooCmdConfig.cxx:854
Double_t
double Double_t
Definition: RtypesCore.h:59
RooAbsTestStatistic::Configuration::nCPU
int nCPU
Definition: RooAbsTestStatistic.h:47
RooAbsOptTestStatistic
RooAbsOptTestStatistic is the abstract base class for test statistics objects that evaluate a functio...
Definition: RooAbsOptTestStatistic.h:28
RooCmdConfig::decodeIntOnTheFly
static Int_t decodeIntOnTheFly(const char *callerID, const char *cmdArgName, Int_t intIdx, Int_t defVal, const RooCmdArg &arg1, const RooCmdArg &arg2=RooCmdArg(), const RooCmdArg &arg3=RooCmdArg(), const RooCmdArg &arg4=RooCmdArg(), const RooCmdArg &arg5=RooCmdArg(), const RooCmdArg &arg6=RooCmdArg(), const RooCmdArg &arg7=RooCmdArg(), const RooCmdArg &arg8=RooCmdArg(), const RooCmdArg &arg9=RooCmdArg())
Static decoder function allows to retrieve integer property from set of RooCmdArgs For use in base me...
Definition: RooCmdConfig.cxx:834
name
char name[80]
Definition: TGX11.cxx:110
RooAbsTestStatistic::Configuration::integrateOverBinsPrecision
double integrateOverBinsPrecision
Definition: RooAbsTestStatistic.h:52
RooAbsPdf
Definition: RooAbsPdf.h:41
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
RooAbsOptTestStatistic::_normSet
RooArgSet * _normSet
Definition: RooAbsOptTestStatistic.h:78
Class
void Class()
Definition: Class.C:29
Rgl::Mc::eInt
const UInt_t eInt[256]
Definition: TGLMarchingCubes.cxx:33
RooAbsTestStatistic::Configuration::splitCutRange
bool splitCutRange
Definition: RooAbsTestStatistic.h:50
RooFit::Eval
@ Eval
Definition: RooGlobalFunc.h:61
RooChi2Var::Pdf
@ Pdf
Definition: RooChi2Var.h:39
Riostream.h
RooChi2Var::ExtendedPdf
@ ExtendedPdf
Definition: RooChi2Var.h:39
RooChi2Var::_funcMode
FuncMode _funcMode
Definition: RooChi2Var.h:71
RooArgSet
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:33
int