Logo ROOT   6.12/07
Reference Guide
RooMomentMorphFunc.cxx
Go to the documentation of this file.
1 /*****************************************************************************
2  * Project: RooFit *
3  * *
4  * This code was autogenerated by RooClassFactory *
5  *****************************************************************************/
6 
7 // Your description goes here...
8 
9 #include "Riostream.h"
10 
11 #include "RooMomentMorphFunc.h"
12 #include "RooAbsCategory.h"
13 #include "RooRealIntegral.h"
14 #include "RooRealConstant.h"
15 #include "RooRealVar.h"
16 #include "RooFormulaVar.h"
17 #include "RooCustomizer.h"
18 #include "RooRealSumFunc.h"
19 #include "RooAddition.h"
20 #include "RooMoment.h"
21 #include "RooLinearVar.h"
22 #include "RooChangeTracker.h"
23 
24 #include "TMath.h"
25 #include "TH1.h"
26 
27 using namespace std;
28 
30 
31  //_____________________________________________________________________________
33  : _curNormSet(0), _mref(0), _M(0), _useHorizMorph(true)
34 {
35  // coverity[UNINIT_CTOR]
36  _varItr = _varList.createIterator();
37  _pdfItr = _pdfList.createIterator();
38 }
39 
40 //_____________________________________________________________________________
41 RooMomentMorphFunc::RooMomentMorphFunc(const char *name, const char *title, RooAbsReal &_m, const RooArgList &varList,
42  const RooArgList &pdfList, const TVectorD &mrefpoints, Setting setting)
43  : RooAbsReal(name, title), _cacheMgr(this, 10, kTRUE, kTRUE), m("m", "m", this, _m),
44  _varList("varList", "List of variables", this), _pdfList("pdfList", "List of pdfs", this), _setting(setting),
45  _useHorizMorph(true)
46 {
47  // CTOR
48 
49  // observables
50  TIterator *varItr = varList.createIterator();
51  RooAbsArg *var;
52  for (Int_t i = 0; (var = (RooAbsArg *)varItr->Next()); ++i) {
53  if (!dynamic_cast<RooAbsReal *>(var)) {
54  coutE(InputArguments) << "RooMomentMorphFunc::ctor(" << GetName() << ") ERROR: variable " << var->GetName()
55  << " is not of type RooAbsReal" << endl;
56  throw string("RooPolyMorh::ctor() ERROR variable is not of type RooAbsReal");
57  }
58  _varList.add(*var);
59  }
60  delete varItr;
61 
62  // reference p.d.f.s
63  TIterator *pdfItr = pdfList.createIterator();
64  RooAbsReal *pdf;
65  for (Int_t i = 0; (pdf = dynamic_cast<RooAbsReal *>(pdfItr->Next())); ++i) {
66  if (!pdf) {
67  coutE(InputArguments) << "RooMomentMorphFunc::ctor(" << GetName() << ") ERROR: func " << pdf->GetName()
68  << " is not of type RooAbsReal" << endl;
69  throw string("RooMomentMorhFunc::ctor() ERROR func is not of type RooAbsReal");
70  }
71  _pdfList.add(*pdf);
72  }
73  delete pdfItr;
74 
75  _mref = new TVectorD(mrefpoints);
78 
79  // initialization
80  initialize();
81 }
82 
83 //_____________________________________________________________________________
84 RooMomentMorphFunc::RooMomentMorphFunc(const char *name, const char *title, RooAbsReal &_m, const RooArgList &varList,
85  const RooArgList &pdfList, const RooArgList &mrefList, Setting setting)
86  : RooAbsReal(name, title), _cacheMgr(this, 10, kTRUE, kTRUE), m("m", "m", this, _m),
87  _varList("varList", "List of variables", this), _pdfList("pdfList", "List of pdfs", this), _setting(setting),
88  _useHorizMorph(true)
89 {
90  // CTOR
91 
92  // observables
93  TIterator *varItr = varList.createIterator();
94  RooAbsArg *var;
95  for (Int_t i = 0; (var = (RooAbsArg *)varItr->Next()); ++i) {
96  if (!dynamic_cast<RooAbsReal *>(var)) {
97  coutE(InputArguments) << "RooMomentMorphFunc::ctor(" << GetName() << ") ERROR: variable " << var->GetName()
98  << " is not of type RooAbsReal" << endl;
99  throw string("RooMomentMorh::ctor() ERROR variable is not of type RooAbsReal");
100  }
101  _varList.add(*var);
102  }
103  delete varItr;
104 
105  // reference p.d.f.s
106  TIterator *pdfItr = pdfList.createIterator();
107  RooAbsReal *pdf;
108  for (Int_t i = 0; (pdf = dynamic_cast<RooAbsReal *>(pdfItr->Next())); ++i) {
109  if (!pdf) {
110  coutE(InputArguments) << "RooMomentMorphFunc::ctor(" << GetName() << ") ERROR: function " << pdf->GetName()
111  << " is not of type RooAbsReal" << endl;
112  throw string("RooMomentMorh::ctor() ERROR function is not of type RooAbsReal");
113  }
114  _pdfList.add(*pdf);
115  }
116  delete pdfItr;
117 
118  // reference points in m
119  _mref = new TVectorD(mrefList.getSize());
120  TIterator *mrefItr = mrefList.createIterator();
121  RooAbsReal *mref;
122  for (Int_t i = 0; (mref = dynamic_cast<RooAbsReal *>(mrefItr->Next())); ++i) {
123  if (!mref) {
124  coutE(InputArguments) << "RooMomentMorphFunc::ctor(" << GetName() << ") ERROR: mref " << mref->GetName()
125  << " is not of type RooAbsReal" << endl;
126  throw string("RooPolyMorh::ctor() ERROR mref is not of type RooAbsReal");
127  }
128  if (!dynamic_cast<RooConstVar *>(mref)) {
129  coutW(InputArguments) << "RooMomentMorphFunc::ctor(" << GetName() << ") WARNING mref point " << i
130  << " is not a constant, taking a snapshot of its value" << endl;
131  }
132  (*_mref)[i] = mref->getVal();
133  }
134  delete mrefItr;
135 
138 
139  // initialization
140  initialize();
141 }
142 
143 //_____________________________________________________________________________
145  : RooAbsReal(other, name), _cacheMgr(other._cacheMgr, this), _curNormSet(0), m("m", this, other.m),
146  _varList("varList", this, other._varList), _pdfList("pdfList", this, other._pdfList), _setting(other._setting),
148 {
149  _mref = new TVectorD(*other._mref);
152 
153  // initialization
154  initialize();
155 }
156 
157 //_____________________________________________________________________________
159 {
160  if (_mref)
161  delete _mref;
162  if (_varItr)
163  delete _varItr;
164  if (_pdfItr)
165  delete _pdfItr;
166  if (_M)
167  delete _M;
168 }
169 
170 //_____________________________________________________________________________
172 {
173 
174  Int_t nPdf = _pdfList.getSize();
175 
176  // other quantities needed
177  if (nPdf != _mref->GetNrows()) {
178  coutE(InputArguments) << "RooMomentMorphFunc::initialize(" << GetName() << ") ERROR: nPdf != nRefPoints" << endl;
179  assert(0);
180  }
181 
182  TVectorD *dm = new TVectorD(nPdf);
183  _M = new TMatrixD(nPdf, nPdf);
184 
185  // transformation matrix for non-linear extrapolation, needed in evaluate()
186  TMatrixD M(nPdf, nPdf);
187  for (Int_t i = 0; i < _mref->GetNrows(); ++i) {
188  (*dm)[i] = (*_mref)[i] - (*_mref)[0];
189  M(i, 0) = 1.;
190  if (i > 0)
191  M(0, i) = 0.;
192  }
193  for (Int_t i = 1; i < _mref->GetNrows(); ++i) {
194  for (Int_t j = 1; j < _mref->GetNrows(); ++j) {
195  M(i, j) = TMath::Power((*dm)[i], (double)j);
196  }
197  }
198  (*_M) = M.Invert();
199 
200  delete dm;
201 }
202 
203 //_____________________________________________________________________________
205 {
206  CacheElem *cache = (CacheElem *)_cacheMgr.getObj(0, (RooArgSet *)0);
207  if (cache) {
208  return cache;
209  }
210  Int_t nVar = _varList.getSize();
211  Int_t nPdf = _pdfList.getSize();
212 
213  RooAbsReal *null = 0;
214  vector<RooAbsReal *> meanrv(nPdf * nVar, null);
215  vector<RooAbsReal *> sigmarv(nPdf * nVar, null);
216  vector<RooAbsReal *> myrms(nVar, null);
217  vector<RooAbsReal *> mypos(nVar, null);
218  vector<RooAbsReal *> slope(nPdf * nVar, null);
219  vector<RooAbsReal *> offs(nPdf * nVar, null);
220  vector<RooAbsReal *> transVar(nPdf * nVar, null);
221  vector<RooAbsReal *> transPdf(nPdf, null);
222 
223  RooArgSet ownedComps;
224 
225  RooArgList fracl;
226 
227  // fraction parameters
228  RooArgList coefList("coefList");
229  RooArgList coefList2("coefList2");
230  for (Int_t i = 0; i < 2 * nPdf; ++i) {
231  std::string fracName = Form("frac_%d", i);
232 
233  RooRealVar *frac = new RooRealVar(fracName.c_str(), fracName.c_str(), 1.);
234 
235  fracl.add(*frac); // to be set later
236  if (i < nPdf)
237  coefList.add(*(RooRealVar *)(fracl.at(i)));
238  else
239  coefList2.add(*(RooRealVar *)(fracl.at(i)));
240  ownedComps.add(*(RooRealVar *)(fracl.at(i)));
241  }
242 
243  RooRealSumFunc *theSumFunc = 0;
244  std::string sumfuncName = Form("%s_sumfunc", GetName());
245 
246  if (_useHorizMorph) {
247  // mean and sigma
248  RooArgList varList(_varList);
249  for (Int_t i = 0; i < nPdf; ++i) {
250  for (Int_t j = 0; j < nVar; ++j) {
251 
252  std::string meanName = Form("%s_mean_%d_%d", GetName(), i, j);
253  std::string sigmaName = Form("%s_sigma_%d_%d", GetName(), i, j);
254 
255  RooAbsMoment *mom = nVar == 1 ? ((RooAbsPdf *)_pdfList.at(i))->sigma((RooRealVar &)*varList.at(j))
256  : ((RooAbsPdf *)_pdfList.at(i))->sigma((RooRealVar &)*varList.at(j), varList);
257 
260 
261  sigmarv[ij(i, j)] = mom;
262  meanrv[ij(i, j)] = mom->mean();
263 
264  ownedComps.add(*sigmarv[ij(i, j)]);
265  }
266  }
267 
268  // slope and offset (to be set later, depend on m)
269  for (Int_t j = 0; j < nVar; ++j) {
270  RooArgList meanList("meanList");
271  RooArgList rmsList("rmsList");
272  for (Int_t i = 0; i < nPdf; ++i) {
273  meanList.add(*meanrv[ij(i, j)]);
274  rmsList.add(*sigmarv[ij(i, j)]);
275  }
276  std::string myrmsName = Form("%s_rms_%d", GetName(), j);
277  std::string myposName = Form("%s_pos_%d", GetName(), j);
278  myrms[j] = new RooAddition(myrmsName.c_str(), myrmsName.c_str(), rmsList, coefList2);
279  mypos[j] = new RooAddition(myposName.c_str(), myposName.c_str(), meanList, coefList2);
280  ownedComps.add(RooArgSet(*myrms[j], *mypos[j]));
281  }
282 
283  // construction of unit pdfs
284  _pdfItr->Reset();
285  RooAbsPdf *pdf;
286  RooArgList transPdfList;
287 
288  for (Int_t i = 0; i < nPdf; ++i) {
289  _varItr->Reset();
290  RooRealVar *var;
291 
292  pdf = (RooAbsPdf *)_pdfItr->Next();
293  std::string pdfName = Form("pdf_%d", i);
294  RooCustomizer cust(*pdf, pdfName.c_str());
295 
296  for (Int_t j = 0; j < nVar; ++j) {
297  // slope and offset formulas
298  std::string slopeName = Form("%s_slope_%d_%d", GetName(), i, j);
299  std::string offsetName = Form("%s_offset_%d_%d", GetName(), i, j);
300  slope[ij(i, j)] = new RooFormulaVar(slopeName.c_str(), "@0/@1", RooArgList(*sigmarv[ij(i, j)], *myrms[j]));
301  offs[ij(i, j)] = new RooFormulaVar(offsetName.c_str(), "@0-(@1*@2)",
302  RooArgList(*meanrv[ij(i, j)], *mypos[j], *slope[ij(i, j)]));
303  ownedComps.add(RooArgSet(*slope[ij(i, j)], *offs[ij(i, j)]));
304  // linear transformations, so pdf can be renormalized
305  var = (RooRealVar *)(_varItr->Next());
306  std::string transVarName = Form("%s_transVar_%d_%d", GetName(), i, j);
307  // transVar[ij(i,j)] = new
308  // RooFormulaVar(transVarName.c_str(),transVarName.c_str(),"@0*@1+@2",RooArgList(*var,*slope[ij(i,j)],*offs[ij(i,j)]));
309 
310  transVar[ij(i, j)] =
311  new RooLinearVar(transVarName.c_str(), transVarName.c_str(), *var, *slope[ij(i, j)], *offs[ij(i, j)]);
312 
313  // *** WVE this is important *** this declares that frac effectively depends on the morphing parameters
314  // This will prevent the likelihood optimizers from erroneously declaring terms constant
315  transVar[ij(i, j)]->addServer((RooAbsArg &)m.arg());
316 
317  ownedComps.add(*transVar[ij(i, j)]);
318  cust.replaceArg(*var, *transVar[ij(i, j)]);
319  }
320  transPdf[i] = (RooAbsPdf *)cust.build();
321  transPdfList.add(*transPdf[i]);
322  ownedComps.add(*transPdf[i]);
323  }
324  // sum pdf
325  theSumFunc = new RooRealSumFunc(sumfuncName.c_str(), sumfuncName.c_str(), transPdfList, coefList);
326  } else {
327  theSumFunc = new RooRealSumFunc(sumfuncName.c_str(), sumfuncName.c_str(), _pdfList, coefList);
328  }
329 
330  // *** WVE this is important *** this declares that frac effectively depends on the morphing parameters
331  // This will prevent the likelihood optimizers from erroneously declaring terms constant
332  theSumFunc->addServer((RooAbsArg &)m.arg());
333  theSumFunc->addOwnedComponents(ownedComps);
334 
335  // change tracker for fraction parameters
336  std::string trackerName = Form("%s_frac_tracker", GetName());
337  RooChangeTracker *tracker = new RooChangeTracker(trackerName.c_str(), trackerName.c_str(), m.arg(), kTRUE);
338 
339  // Store it in the cache
340  cache = new CacheElem(*theSumFunc, *tracker, fracl);
341  _cacheMgr.setObj(0, 0, cache, 0);
342 
343  return cache;
344 }
345 
346 //_____________________________________________________________________________
348 {
349  return RooArgList(*_sumFunc, *_tracker);
350 }
351 
352 //_____________________________________________________________________________
354 {
355  delete _sumFunc;
356  delete _tracker;
357 }
358 
359 //_____________________________________________________________________________
361 {
362  // Special version of getVal() overrides RooAbsReal::getVal() to save value of current normalization set
363  _curNormSet = set ? (RooArgSet *)set : (RooArgSet *)&_varList;
364  return RooAbsReal::getVal(set);
365 }
366 
367 //_____________________________________________________________________________
369 {
370  CacheElem *cache = getCache(nset ? nset : _curNormSet);
371 
372  if (cache->_tracker->hasChanged(kTRUE)) {
373  cache->calculateFractions(*this, kFALSE); // verbose turned off
374  }
375 
376  return cache->_sumFunc;
377 }
378 
379 //_____________________________________________________________________________
381 {
382  CacheElem *cache = getCache(nset ? nset : _curNormSet);
383 
384  if (cache->_tracker->hasChanged(kTRUE)) {
385  cache->calculateFractions(*this, kFALSE); // verbose turned off
386  }
387 
388  return cache->_sumFunc;
389 }
390 
391 //_____________________________________________________________________________
393 {
394  CacheElem *cache = getCache(_curNormSet);
395 
396  if (cache->_tracker->hasChanged(kTRUE)) {
397  cache->calculateFractions(*this, kFALSE); // verbose turned off
398  }
399 
400  Double_t ret = cache->_sumFunc->getVal(_pdfList.nset());
401  return ret;
402 }
403 
404 //_____________________________________________________________________________
406 {
407  return (RooRealVar *)(_frac.at(i));
408 }
409 
410 //_____________________________________________________________________________
412 {
413  return (RooRealVar *)(_frac.at(i));
414 }
415 
416 //_____________________________________________________________________________
418 {
419  Int_t nPdf = self._pdfList.getSize();
420 
421  Double_t dm = self.m - (*self._mref)[0];
422 
423  // fully non-linear
424  double sumposfrac = 0.;
425  for (Int_t i = 0; i < nPdf; ++i) {
426  double ffrac = 0.;
427  for (Int_t j = 0; j < nPdf; ++j) {
428  ffrac += (*self._M)(j, i) * (j == 0 ? 1. : TMath::Power(dm, (double)j));
429  }
430  if (ffrac >= 0)
431  sumposfrac += ffrac;
432  // fractions for pdf
433  ((RooRealVar *)frac(i))->setVal(ffrac);
434  // fractions for rms and mean
435  ((RooRealVar *)frac(nPdf + i))->setVal(ffrac);
436  if (verbose) {
437  cout << ffrac << endl;
438  }
439  }
440 
441  // various mode settings
442  int imin = self.idxmin(self.m);
443  int imax = self.idxmax(self.m);
444  double mfrac = (self.m - (*self._mref)[imin]) / ((*self._mref)[imax] - (*self._mref)[imin]);
445  switch (self._setting) {
446  case NonLinear:
447  // default already set above
448  break;
449 
450  case SineLinear:
451  mfrac =
452  TMath::Sin(TMath::PiOver2() * mfrac); // this gives a continuous differentiable transition between grid points.
453 
454  // now fall through to Linear case
455 
456  case Linear:
457  for (Int_t i = 0; i < 2 * nPdf; ++i) ((RooRealVar *)frac(i))->setVal(0.);
458  if (imax > imin) { // m in between mmin and mmax
459  ((RooRealVar *)frac(imin))->setVal(1. - mfrac);
460  ((RooRealVar *)frac(nPdf + imin))->setVal(1. - mfrac);
461  ((RooRealVar *)frac(imax))->setVal(mfrac);
462  ((RooRealVar *)frac(nPdf + imax))->setVal(mfrac);
463  } else if (imax == imin) { // m outside mmin and mmax
464  ((RooRealVar *)frac(imin))->setVal(1.);
465  ((RooRealVar *)frac(nPdf + imin))->setVal(1.);
466  }
467  break;
469  for (Int_t i = 0; i < nPdf; ++i) ((RooRealVar *)frac(i))->setVal(0.);
470  if (imax > imin) { // m in between mmin and mmax
471  ((RooRealVar *)frac(imin))->setVal(1. - mfrac);
472  ((RooRealVar *)frac(imax))->setVal(mfrac);
473  } else if (imax == imin) { // m outside mmin and mmax
474  ((RooRealVar *)frac(imin))->setVal(1.);
475  }
476  break;
478  for (Int_t i = 0; i < nPdf; ++i) {
479  if (((RooRealVar *)frac(i))->getVal() < 0)
480  ((RooRealVar *)frac(i))->setVal(0.);
481  ((RooRealVar *)frac(i))->setVal(((RooRealVar *)frac(i))->getVal() / sumposfrac);
482  }
483  break;
484  }
485 }
486 
487 //_____________________________________________________________________________
488 int RooMomentMorphFunc::idxmin(const double &mval) const
489 {
490  int imin(0);
491  Int_t nPdf = _pdfList.getSize();
492  double mmin = -DBL_MAX;
493  for (Int_t i = 0; i < nPdf; ++i)
494  if ((*_mref)[i] > mmin && (*_mref)[i] <= mval) {
495  mmin = (*_mref)[i];
496  imin = i;
497  }
498  return imin;
499 }
500 
501 //_____________________________________________________________________________
502 int RooMomentMorphFunc::idxmax(const double &mval) const
503 {
504  int imax(0);
505  Int_t nPdf = _pdfList.getSize();
506  double mmax = DBL_MAX;
507  for (Int_t i = 0; i < nPdf; ++i)
508  if ((*_mref)[i] < mmax && (*_mref)[i] >= mval) {
509  mmax = (*_mref)[i];
510  imax = i;
511  }
512  return imax;
513 }
514 
515 //_____________________________________________________________________________
516 std::list<Double_t> *RooMomentMorphFunc::plotSamplingHint(RooAbsRealLValue &obs, Double_t xlo, Double_t xhi) const
517 {
518  return sumFunc(0)->plotSamplingHint(obs, xlo, xhi);
519 }
520 
521 //_____________________________________________________________________________
522 std::list<Double_t> *RooMomentMorphFunc::binBoundaries(RooAbsRealLValue &obs, Double_t xlo, Double_t xhi) const
523 {
524  return sumFunc(0)->binBoundaries(obs, xlo, xhi);
525 }
526 
527 //_____________________________________________________________________________
529 {
530  return sumFunc(0)->isBinnedDistribution(obs);
531 }
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
RooAbsReal * mean()
Definition: RooAbsMoment.h:37
TIterator * createIterator(Bool_t dir=kIterForward) const
#define coutE(a)
Definition: RooMsgService.h:34
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
virtual Bool_t add(const RooAbsCollection &col, Bool_t silent=kFALSE)
Add a collection of arguments to this collection by calling add() for each element in the source coll...
Definition: RooArgSet.h:86
auto * m
Definition: textangle.C:8
virtual void Reset()=0
RooAbsReal * sumFunc(const RooArgSet *nset)
Double_t getVal(const RooArgSet *set=0) const
Definition: RooAbsReal.h:64
int idxmax(const double &m) const
virtual std::list< Double_t > * binBoundaries(RooAbsRealLValue &, Double_t, Double_t) const
Definition: RooAbsReal.h:278
Bool_t hasChanged(Bool_t clearState)
Returns true if state has changes since last call with clearState=kTRUE If clearState is true...
Int_t GetNrows() const
Definition: TVectorT.h:75
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
Bool_t addOwnedComponents(const RooArgSet &comps)
Take ownership of the contents of &#39;comps&#39;.
Definition: RooAbsArg.cxx:2278
STL namespace.
#define coutW(a)
Definition: RooMsgService.h:33
RooAbsMoment represents the first, second, or third order derivative of any RooAbsReal as calculated ...
Definition: RooAbsMoment.h:27
RooObjCacheManager _cacheMgr
Iterator abstract base class.
Definition: TIterator.h:30
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Definition: TMath.h:627
null_t< F > null()
T * getObj(const RooArgSet *nset, Int_t *sterileIndex=0, const TNamed *isetRangeName=0)
RooAbsMoment * sigma(RooRealVar &obs)
Definition: RooAbsReal.h:299
Bool_t isBinnedDistribution(const RooArgSet &obs) const
friend class RooArgSet
Definition: RooAbsArg.h:471
TVectorT< Double_t > TVectorD
Definition: TVectorDfwd.h:22
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Reimplementation of standard RooArgList::add()
friend class CacheElem
Current normalization set.
TMatrixT< Element > & Invert(Double_t *det=0)
Invert the matrix and calculate its determinant.
Definition: TMatrixT.cxx:1396
const RooArgSet * nset() const
Definition: RooAbsProxy.h:46
virtual std::list< Double_t > * plotSamplingHint(RooAbsRealLValue &obs, Double_t xlo, Double_t xhi) const
RooRealVar represents a fundamental (non-derived) real valued object.
Definition: RooRealVar.h:36
TMatrixT< Double_t > TMatrixD
Definition: TMatrixDfwd.h:22
int idxmin(const double &m) const
Int_t getSize() const
virtual Double_t getVal(const RooArgSet *set=0) const
friend class RooRealSumFunc
Definition: RooAbsReal.h:471
virtual RooArgList containedArgs(Action)
RooAbsArg * at(Int_t idx) const
Definition: RooArgList.h:84
char * Form(const char *fmt,...)
const Bool_t kFALSE
Definition: RtypesCore.h:88
Int_t ij(const Int_t &i, const Int_t &j) const
virtual Bool_t isBinnedDistribution(const RooArgSet &) const
Definition: RooAbsReal.h:277
#define ClassImp(name)
Definition: Rtypes.h:359
double Double_t
Definition: RtypesCore.h:55
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:53
virtual std::list< Double_t > * binBoundaries(RooAbsRealLValue &, Double_t, Double_t) const
CacheElem * getCache(const RooArgSet *nset) const
RooChangeTracker is a meta object that tracks value changes in a given set of RooAbsArgs by registeri...
virtual std::list< Double_t > * plotSamplingHint(RooAbsRealLValue &, Double_t, Double_t) const
Definition: RooAbsReal.h:279
RooAbsRealLValue is the common abstract base class for objects that represent a real value that may a...
RooAbsPdf is the abstract interface for all probability density functions The class provides hybrid a...
Definition: RooAbsPdf.h:41
RooArgSet * _curNormSet
The cache manager.
virtual TObject * Next()=0
Double_t Sin(Double_t)
Definition: TMath.h:547
Double_t evaluate() const
Int_t setObj(const RooArgSet *nset, T *obj, const TNamed *isetRangeName=0)
RooAddition calculates the sum of a set of RooAbsReal terms, or when constructed with two sets...
Definition: RooAddition.h:26
RooAbsArg is the common abstract base class for objects that represent a value (of arbitrary type) an...
Definition: RooAbsArg.h:66
void setLocalNoDirtyInhibit(Bool_t flag) const
Definition: RooAbsArg.h:564
TIterator * _pdfItr
do not persist
const RooAbsReal & arg() const
Definition: RooRealProxy.h:43
void addServer(RooAbsArg &server, Bool_t valueProp=kTRUE, Bool_t shapeProp=kFALSE)
Register another RooAbsArg as a server to us, ie, declare that we depend on it.
Definition: RooAbsArg.cxx:339
void calculateFractions(const RooMomentMorphFunc &self, Bool_t verbose=kTRUE) const
const Bool_t kTRUE
Definition: RtypesCore.h:87
constexpr Double_t PiOver2()
Definition: TMath.h:48
char name[80]
Definition: TGX11.cxx:109
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Overloaded RooArgSet::add() method inserts &#39;var&#39; into set and registers &#39;var&#39; as server to owner with...