Logo ROOT   6.10/09
Reference Guide
RooProduct.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  * GR, Gerhard Raven, VU Amsterdan, graven@nikhef.nl *
8  * *
9  * Copyright (c) 2000-2007, 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 /**
18 \file RooProduct.cxx
19 \class RooProduct
20 \ingroup Roofitcore
21 
22 
23 RooProduct a RooAbsReal implementation that represent the product
24 of a given set of other RooAbsReal objects
25 
26 **/
27 
28 
29 #include <cmath>
30 #include <vector>
31 #include <utility>
32 #include <memory>
33 #include <algorithm>
34 
35 #include "RooProduct.h"
36 #include "RooNameReg.h"
37 #include "RooAbsReal.h"
38 #include "RooAbsCategory.h"
39 #include "RooErrorHandler.h"
40 #include "RooMsgService.h"
41 #include "RooTrace.h"
42 
43 using namespace std ;
44 
46 ;
47 
48 class RooProduct::ProdMap : public std::vector<std::pair<RooArgSet*,RooArgList*> > {} ;
49 
50 // Namespace with helper functions that have STL stuff that we don't want to expose to CINT
51 namespace {
52  typedef RooProduct::ProdMap::iterator RPPMIter ;
53  std::pair<RPPMIter,RPPMIter> findOverlap2nd(RPPMIter i, RPPMIter end) ;
54  void dump_map(ostream& os, RPPMIter i, RPPMIter end) ;
55 }
56 
57 
58 
59 ////////////////////////////////////////////////////////////////////////////////
60 /// Default constructor
61 
63 {
65 }
66 
67 
68 
69 ////////////////////////////////////////////////////////////////////////////////
70 /// Destructor
71 
73 {
75 }
76 
77 
78 
79 ////////////////////////////////////////////////////////////////////////////////
80 /// Construct function representing the product of functions in prodSet
81 
82 RooProduct::RooProduct(const char* name, const char* title, const RooArgList& prodSet) :
83  RooAbsReal(name, title),
84  _compRSet("!compRSet","Set of real product components",this),
85  _compCSet("!compCSet","Set of category product components",this),
86  _cacheMgr(this,10)
87 {
88  RooAbsArg* comp ;
89  RooFIter compIter = prodSet.fwdIterator();
90  while((comp = (RooAbsArg*)compIter.next())) {
91  if (dynamic_cast<RooAbsReal*>(comp)) {
92  _compRSet.add(*comp) ;
93  } else if (dynamic_cast<RooAbsCategory*>(comp)) {
94  _compCSet.add(*comp) ;
95  } else {
96  coutE(InputArguments) << "RooProduct::ctor(" << GetName() << ") ERROR: component " << comp->GetName()
97  << " is not of type RooAbsReal or RooAbsCategory" << endl ;
99  }
100  }
102 }
103 
104 
105 
106 ////////////////////////////////////////////////////////////////////////////////
107 /// Copy constructor
108 
109 RooProduct::RooProduct(const RooProduct& other, const char* name) :
110  RooAbsReal(other, name),
111  _compRSet("!compRSet",this,other._compRSet),
112  _compCSet("!compCSet",this,other._compCSet),
113  _cacheMgr(other._cacheMgr,this)
114 {
116 }
117 
118 
119 
120 ////////////////////////////////////////////////////////////////////////////////
121 /// Force internal handling of integration of given observable if any
122 /// of the product terms depend on it.
123 
125 {
126  // Force internal handling of integration of given observable if any
127  // of the product terms depend on it.
128 
129  RooFIter compRIter = _compRSet.fwdIterator() ;
130  RooAbsReal* rcomp ;
131  Bool_t depends(kFALSE);
132  while((rcomp=(RooAbsReal*)compRIter.next())&&!depends) {
133  depends = rcomp->dependsOn(dep);
134  }
135  return depends ;
136 }
137 
138 
139 
140 ////////////////////////////////////////////////////////////////////////////////
141 /// Group observables into subsets in which the product factorizes
142 /// and that can thus be integrated separately
143 
144 RooProduct::ProdMap* RooProduct::groupProductTerms(const RooArgSet& allVars) const
145 {
146  ProdMap* map = new ProdMap ;
147 
148  // Do we have any terms which do not depend on the
149  // on the variables we integrate over?
150  RooAbsReal* rcomp ;
151  RooFIter compRIter = _compRSet.fwdIterator() ;
152  RooArgList *indep = new RooArgList();
153  while((rcomp=(RooAbsReal*) compRIter.next())) {
154  if( !rcomp->dependsOn(allVars) ) indep->add(*rcomp);
155  }
156  if (indep->getSize()!=0) {
157  map->push_back( std::make_pair(new RooArgSet(),indep) );
158  }
159 
160  // Map observables -> functions ; start with individual observables
161  RooFIter allVarsIter = allVars.fwdIterator() ;
162  RooAbsReal* var ;
163  while((var=(RooAbsReal*)allVarsIter.next())) {
164  RooArgSet *vars = new RooArgSet(); vars->add(*var);
165  RooArgList *comps = new RooArgList();
166  RooAbsReal* rcomp2 ;
167 
168  compRIter = _compRSet.fwdIterator() ;
169  while((rcomp2=(RooAbsReal*) compRIter.next())) {
170  if( rcomp2->dependsOn(*var) ) comps->add(*rcomp2);
171  }
172  map->push_back( std::make_pair(vars,comps) );
173  }
174 
175  // Merge groups with overlapping dependents
176  Bool_t overlap;
177  do {
178  std::pair<ProdMap::iterator,ProdMap::iterator> i = findOverlap2nd(map->begin(),map->end());
179  overlap = (i.first!=i.second);
180  if (overlap) {
181  i.first->first->add(*i.second->first);
182 
183  // In the merging step, make sure not to duplicate
184  RooFIter it = i.second->second->fwdIterator() ;
185  RooAbsArg* targ ;
186  while ((targ = it.next())) {
187  if (!i.first->second->find(*targ)) {
188  i.first->second->add(*targ) ;
189  }
190  }
191  //i.first->second->add(*i.second->second);
192 
193  delete i.second->first;
194  delete i.second->second;
195  map->erase(i.second);
196  }
197  } while (overlap);
198 
199  // check that we have all variables to be integrated over on the LHS
200  // of the map, and all terms in the product do appear on the RHS
201  int nVar=0; int nFunc=0;
202  for (ProdMap::iterator i = map->begin();i!=map->end();++i) {
203  nVar+=i->first->getSize();
204  nFunc+=i->second->getSize();
205  }
206  assert(nVar==allVars.getSize());
207  assert(nFunc==_compRSet.getSize());
208  return map;
209 }
210 
211 
212 
213 ////////////////////////////////////////////////////////////////////////////////
214 /// Return list of (partial) integrals whose product defines the integral of this
215 /// RooProduct over the observables in iset in range isetRange. If no such list
216 /// exists, create it now and store it in the cache for future use.
217 
218 Int_t RooProduct::getPartIntList(const RooArgSet* iset, const char *isetRange) const
219 {
220 
221  // check if we already have integrals for this combination of factors
222  Int_t sterileIndex(-1);
223  CacheElem* cache = (CacheElem*) _cacheMgr.getObj(iset,iset,&sterileIndex,RooNameReg::ptr(isetRange));
224  if (cache!=0) {
225  Int_t code = _cacheMgr.lastIndex();
226  return code;
227  }
228 
229  ProdMap* map = groupProductTerms(*iset);
230 
231  cxcoutD(Integration) << "RooProduct::getPartIntList(" << GetName() << ") groupProductTerms returned map" ;
232  if (dologD(Integration)) {
233  dump_map(ccoutD(Integration),map->begin(),map->end());
234  ccoutD(Integration) << endl;
235  }
236 
237  // did we find any factorizable terms?
238  if (map->size()<2) {
239 
240  for (ProdMap::iterator iter = map->begin() ; iter != map->end() ; ++iter) {
241  delete iter->first ;
242  delete iter->second ;
243  }
244 
245  delete map ;
246  return -1; // RRI caller will zero analVars if return code = 0....
247  }
248  cache = new CacheElem();
249 
250  for (ProdMap::const_iterator i = map->begin();i!=map->end();++i) {
251  RooAbsReal *term(0);
252  if (i->second->getSize()>1) { // create a RooProd for this subexpression
253  const char *name = makeFPName("SUBPROD_",*i->second);
254  term = new RooProduct(name,name,*i->second);
255  cache->_ownedList.addOwned(*term);
256  cxcoutD(Integration) << "RooProduct::getPartIntList(" << GetName() << ") created subexpression " << term->GetName() << endl;
257  } else {
258  assert(i->second->getSize()==1);
259  RooFIter j = i->second->fwdIterator();
260  term = (RooAbsReal*)j.next();
261  }
262  assert(term!=0);
263  if (i->first->getSize()==0) { // check whether we need to integrate over this term or not...
264  cache->_prodList.add(*term);
265  cxcoutD(Integration) << "RooProduct::getPartIntList(" << GetName() << ") adding simple factor " << term->GetName() << endl;
266  } else {
267  RooAbsReal *integral = term->createIntegral(*i->first,isetRange);
268  cache->_prodList.add(*integral);
269  cache->_ownedList.addOwned(*integral);
270  cxcoutD(Integration) << "RooProduct::getPartIntList(" << GetName() << ") adding integral for " << term->GetName() << " : " << integral->GetName() << endl;
271  }
272  }
273  // add current set-up to cache, and return index..
274  Int_t code = _cacheMgr.setObj(iset,iset,(RooAbsCacheElement*)cache,RooNameReg::ptr(isetRange));
275 
276  cxcoutD(Integration) << "RooProduct::getPartIntList(" << GetName() << ") created list " << cache->_prodList << " with code " << code+1 << endl
277  << " for iset=" << *iset << " @" << iset << " range: " << (isetRange?isetRange:"<none>") << endl ;
278 
279  for (ProdMap::iterator iter = map->begin() ; iter != map->end() ; ++iter) {
280  delete iter->first ;
281  delete iter->second ;
282  }
283  delete map ;
284  return code;
285 }
286 
287 
288 ////////////////////////////////////////////////////////////////////////////////
289 /// Declare that we handle all integrations internally
290 
292  const RooArgSet* /*normSet*/,
293  const char* rangeName) const
294 {
295  if (_forceNumInt) return 0 ;
296 
297  // Declare that we can analytically integrate all requested observables
298  // (basically, we will take care of the problem, and delegate where required)
299  //assert(normSet==0);
300  assert(analVars.getSize()==0);
301  analVars.add(allVars) ;
302  Int_t code = getPartIntList(&analVars,rangeName)+1;
303  return code ;
304 }
305 
306 
307 ////////////////////////////////////////////////////////////////////////////////
308 /// Calculate integral internally from appropriate partial integral cache
309 
310 Double_t RooProduct::analyticalIntegral(Int_t code, const char* rangeName) const
311 {
312  // note: rangeName implicit encoded in code: see _cacheMgr.setObj in getPartIntList...
313  CacheElem *cache = (CacheElem*) _cacheMgr.getObjByIndex(code-1);
314  if (cache==0) {
315  // cache got sterilized, trigger repopulation of this slot, then try again...
316  std::unique_ptr<RooArgSet> vars( getParameters(RooArgSet()) );
317  std::unique_ptr<RooArgSet> iset( _cacheMgr.nameSet2ByIndex(code-1)->select(*vars) );
318  Int_t code2 = getPartIntList(iset.get(),rangeName)+1;
319  assert(code==code2); // must have revived the right (sterilized) slot...
320  return analyticalIntegral(code2,rangeName);
321  }
322  assert(cache!=0);
323 
324  return calculate(cache->_prodList);
325 }
326 
327 
328 ////////////////////////////////////////////////////////////////////////////////
329 /// Calculate and return product of partial terms in partIntList
330 
331 Double_t RooProduct::calculate(const RooArgList& partIntList) const
332 {
333  RooAbsReal *term(0);
334  Double_t val=1;
335  RooFIter i = partIntList.fwdIterator() ;
336  while((term=(RooAbsReal*)i.next())) {
337  double x = term->getVal();
338  val*= x;
339  }
340  return val;
341 }
342 
343 
344 ////////////////////////////////////////////////////////////////////////////////
345 /// Construct automatic name for internal product terms
346 
347 const char* RooProduct::makeFPName(const char *pfx,const RooArgSet& terms) const
348 {
349  static TString pname;
350  pname = pfx;
351  RooFIter i = terms.fwdIterator();
352  RooAbsArg *arg;
353  Bool_t first(kTRUE);
354  while((arg=(RooAbsArg*)i.next())) {
355  if (first) { first=kFALSE;}
356  else pname.Append("_X_");
357  pname.Append(arg->GetName());
358  }
359  return pname.Data();
360 }
361 
362 
363 
364 ////////////////////////////////////////////////////////////////////////////////
365 /// Evaluate product of input functions
366 
368 {
369  Double_t prod(1) ;
370 
371  RooFIter compRIter = _compRSet.fwdIterator() ;
372  RooAbsReal* rcomp ;
373  const RooArgSet* nset = _compRSet.nset() ;
374  while((rcomp=(RooAbsReal*)compRIter.next())) {
375  prod *= rcomp->getVal(nset) ;
376  }
377 
378  RooFIter compCIter = _compCSet.fwdIterator() ;
379  RooAbsCategory* ccomp ;
380  while((ccomp=(RooAbsCategory*)compCIter.next())) {
381  prod *= ccomp->getIndex() ;
382  }
383 
384  return prod ;
385 }
386 
387 
388 
389 ////////////////////////////////////////////////////////////////////////////////
390 /// Forward the plot sampling hint from the p.d.f. that defines the observable obs
391 
392 std::list<Double_t>* RooProduct::binBoundaries(RooAbsRealLValue& obs, Double_t xlo, Double_t xhi) const
393 {
394  RooFIter iter = _compRSet.fwdIterator() ;
395  RooAbsReal* func ;
396  while((func=(RooAbsReal*)iter.next())) {
397  list<Double_t>* binb = func->binBoundaries(obs,xlo,xhi) ;
398  if (binb) {
399  return binb ;
400  }
401  }
402 
403  return 0 ;
404 }
405 
406 
407 //_____________________________________________________________________________B
409 {
410  // If all components that depend on obs are binned that so is the product
411 
412  RooFIter iter = _compRSet.fwdIterator() ;
413  RooAbsReal* func ;
414  while((func=(RooAbsReal*)iter.next())) {
415  if (func->dependsOn(obs) && !func->isBinnedDistribution(obs)) {
416  return kFALSE ;
417  }
418  }
419 
420  return kTRUE ;
421 }
422 
423 
424 
425 ////////////////////////////////////////////////////////////////////////////////
426 /// Forward the plot sampling hint from the p.d.f. that defines the observable obs
427 
428 std::list<Double_t>* RooProduct::plotSamplingHint(RooAbsRealLValue& obs, Double_t xlo, Double_t xhi) const
429 {
430  RooFIter iter = _compRSet.fwdIterator() ;
431  RooAbsReal* func ;
432  while((func=(RooAbsReal*)iter.next())) {
433  list<Double_t>* hint = func->plotSamplingHint(obs,xlo,xhi) ;
434  if (hint) {
435  return hint ;
436  }
437  }
438 
439  return 0 ;
440 }
441 
442 
443 
444 ////////////////////////////////////////////////////////////////////////////////
445 /// Destructor
446 
448 {
449 }
450 
451 
452 ////////////////////////////////////////////////////////////////////////////////
453 /// Return list of all RooAbsArgs in cache element
454 
456 {
457  RooArgList ret(_ownedList) ;
458  return ret ;
459 }
460 
461 
462 
463 
464 ////////////////////////////////////////////////////////////////////////////////
465 /// Label OK'ed components of a RooProduct with cache-and-track
466 
468 {
469  RooArgSet comp(components()) ;
470  RooFIter piter = comp.fwdIterator() ;
471  RooAbsArg* parg ;
472  while ((parg=piter.next())) {
473  if (parg->isDerived()) {
474  if (parg->canNodeBeCached()==Always) {
475  trackNodes.add(*parg) ;
476  //cout << "tracking node RooProduct component " << parg->IsA()->GetName() << "::" << parg->GetName() << endl ;
477  }
478  }
479  }
480 }
481 
482 
483 
484 
485 
486 ////////////////////////////////////////////////////////////////////////////////
487 /// Customized printing of arguments of a RooProduct to more intuitively reflect the contents of the
488 /// product operator construction
489 
490 void RooProduct::printMetaArgs(ostream& os) const
491 {
492  Bool_t first(kTRUE) ;
493 
494  RooFIter compRIter = _compRSet.fwdIterator();
495  RooAbsReal* rcomp ;
496  while((rcomp=(RooAbsReal*) compRIter.next())) {
497  if (!first) { os << " * " ; } else { first = kFALSE ; }
498  os << rcomp->GetName() ;
499  }
500 
501  RooFIter compCIter = _compCSet.fwdIterator() ;
502  RooAbsCategory* ccomp ;
503  while((ccomp=(RooAbsCategory*) compCIter.next())) {
504  if (!first) { os << " * " ; } else { first = kFALSE ; }
505  os << ccomp->GetName() ;
506  }
507 
508  os << " " ;
509 }
510 
511 
512 
513 
514 
515 namespace {
516 
517 std::pair<RPPMIter,RPPMIter> findOverlap2nd(RPPMIter i, RPPMIter end)
518 {
519  // Utility function finding pairs of overlapping input functions
520  for (; i!=end; ++i) for ( RPPMIter j(i+1); j!=end; ++j) {
521  if (i->second->overlaps(*j->second)) {
522  return std::make_pair(i,j);
523  }
524  }
525  return std::make_pair(end,end);
526 }
527 
528 
529 void dump_map(ostream& os, RPPMIter i, RPPMIter end)
530 {
531  // Utility dump function for debugging
532  Bool_t first(kTRUE);
533  os << " [ " ;
534  for(; i!=end;++i) {
535  if (first) { first=kFALSE; }
536  else { os << " , " ; }
537  os << *(i->first) << " -> " << *(i->second) ;
538  }
539  os << " ] " ;
540 }
541 
542 }
543 
544 
545 
546 
RooListProxy _compRSet
Definition: RooProduct.h:64
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
virtual std::list< Double_t > * plotSamplingHint(RooAbsRealLValue &, Double_t, Double_t) const
Forward the plot sampling hint from the p.d.f. that defines the observable obs.
Definition: RooProduct.cxx:428
virtual ~CacheElem()
Destructor.
Definition: RooProduct.cxx:447
#define coutE(a)
Definition: RooMsgService.h:34
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
static void softAbort()
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
Bool_t dependsOn(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg=0, Bool_t valueOnly=kFALSE) const
Test whether we depend on (ie, are served by) any object in the specified collection.
Definition: RooAbsArg.cxx:744
virtual std::list< Double_t > * binBoundaries(RooAbsRealLValue &, Double_t, Double_t) const
Forward the plot sampling hint from the p.d.f. that defines the observable obs.
Definition: RooProduct.cxx:392
virtual Bool_t addOwned(RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
Double_t getVal(const RooArgSet *set=0) const
Definition: RooAbsReal.h:64
#define cxcoutD(a)
Definition: RooMsgService.h:79
const char * makeFPName(const char *pfx, const RooArgSet &terms) const
Construct automatic name for internal product terms.
Definition: RooProduct.cxx:347
virtual std::list< Double_t > * binBoundaries(RooAbsRealLValue &, Double_t, Double_t) const
Definition: RooAbsReal.h:278
virtual RooArgList containedArgs(Action)
Return list of all RooAbsArgs in cache element.
Definition: RooProduct.cxx:455
ProdMap * groupProductTerms(const RooArgSet &) const
Group observables into subsets in which the product factorizes and that can thus be integrated separa...
Definition: RooProduct.cxx:144
Int_t getPartIntList(const RooArgSet *iset, const char *rangeName=0) const
Return list of (partial) integrals whose product defines the integral of this RooProduct over the obs...
Definition: RooProduct.cxx:218
T * getObjByIndex(Int_t index) const
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
virtual Int_t getIndex() const
Return index number of current state.
STL namespace.
virtual Bool_t forceAnalyticalInt(const RooAbsArg &dep) const
Force internal handling of integration of given observable if any of the product terms depend on it...
Definition: RooProduct.cxx:124
#define TRACE_CREATE
Definition: RooTrace.h:22
Double_t x[n]
Definition: legend1.C:17
Double_t evaluate() const
Evaluate product of input functions.
Definition: RooProduct.cxx:367
T * getObj(const RooArgSet *nset, Int_t *sterileIndex=0, const TNamed *isetRangeName=0)
friend class RooArgSet
Definition: RooAbsArg.h:469
RooListProxy _compCSet
Definition: RooProduct.h:65
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Reimplementation of standard RooArgList::add()
const RooArgSet * nset() const
Definition: RooAbsProxy.h:46
Int_t getSize() const
RooAbsReal * createIntegral(const RooArgSet &iset, 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
Create an object that represents the integral of the function over one or more observables listed in ...
Definition: RooAbsReal.cxx:501
Bool_t _forceNumInt
Definition: RooAbsReal.h:392
RooAbsArg * first() const
static const TNamed * ptr(const char *stringPtr)
Return a unique TNamed pointer for given C++ string.
Definition: RooNameReg.cxx:125
virtual Bool_t isBinnedDistribution(const RooArgSet &obs) const
Definition: RooProduct.cxx:408
RooAbsCacheElement is the abstract base class for objects to be stored in RooAbsCache cache manager o...
Int_t lastIndex() const
RooProduct()
Default constructor.
Definition: RooProduct.cxx:62
virtual ~RooProduct()
Destructor.
Definition: RooProduct.cxx:72
RooProduct a RooAbsReal implementation that represent the product of a given set of other RooAbsReal ...
Definition: RooProduct.h:32
RooAbsArg * next()
const Bool_t kFALSE
Definition: RtypesCore.h:92
virtual Bool_t isBinnedDistribution(const RooArgSet &) const
Definition: RooAbsReal.h:277
const RooNameSet * nameSet2ByIndex(Int_t index) const
#define ClassImp(name)
Definition: Rtypes.h:336
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
RooFIter fwdIterator() const
RooArgSet * getParameters(const RooAbsData *data, Bool_t stripDisconnected=kTRUE) const
Create a list of leaf nodes in the arg tree starting with ourself as top node that don&#39;t match any of...
Definition: RooAbsArg.cxx:560
double func(double *x, double *p)
Definition: stressTF1.cxx:213
#define TRACE_DESTROY
Definition: RooTrace.h:23
RooArgSet * select(const RooArgSet &list) const
Construct a RooArgSet of objects in input &#39;list&#39; whose names match to those in the internal name list...
Definition: RooNameSet.cxx:189
virtual std::list< Double_t > * plotSamplingHint(RooAbsRealLValue &, Double_t, Double_t) const
Definition: RooAbsReal.h:279
#define dologD(a)
Definition: RooMsgService.h:63
Double_t calculate(const RooArgList &partIntList) const
Calculate and return product of partial terms in partIntList.
Definition: RooProduct.cxx:331
RooAbsRealLValue is the common abstract base class for objects that represent a real value that may a...
virtual Bool_t isDerived() const
Definition: RooAbsArg.h:81
RooArgList _prodList
Definition: RooProduct.h:71
void printMetaArgs(std::ostream &os) const
Customized printing of arguments of a RooProduct to more intuitively reflect the contents of the prod...
Definition: RooProduct.cxx:490
RooAbsCategory is the common abstract base class for objects that represent a discrete value with a f...
virtual Int_t getAnalyticalIntegralWN(RooArgSet &allVars, RooArgSet &analVars, const RooArgSet *normSet, const char *rangeName=0) const
Declare that we handle all integrations internally.
Definition: RooProduct.cxx:291
RooObjCacheManager _cacheMgr
Definition: RooProduct.h:75
RooArgList _ownedList
Definition: RooProduct.h:72
virtual Double_t analyticalIntegral(Int_t code, const char *rangeName=0) const
Calculate integral internally from appropriate partial integral cache.
Definition: RooProduct.cxx:310
Int_t setObj(const RooArgSet *nset, T *obj, const TNamed *isetRangeName=0)
Definition: first.py:1
RooAbsArg is the common abstract base class for objects that represent a value (of arbitrary type) an...
Definition: RooAbsArg.h:66
#define ccoutD(a)
Definition: RooMsgService.h:37
const Bool_t kTRUE
Definition: RtypesCore.h:91
RooArgList components()
Definition: RooProduct.h:47
virtual void setCacheAndTrackHints(RooArgSet &)
Label OK&#39;ed components of a RooProduct with cache-and-track.
Definition: RooProduct.cxx:467
virtual CacheMode canNodeBeCached() const
Definition: RooAbsArg.h:317