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