Logo ROOT   6.10/09
Reference Guide
RooAbsSelfCachedPdf.cxx
Go to the documentation of this file.
1  /*****************************************************************************
2  * Project: RooFit *
3  * *
4  * Copyright (c) 2000-2005, Regents of the University of California *
5  * and Stanford University. All rights reserved. *
6  * *
7  * Redistribution and use in source and binary forms, *
8  * with or without modification, are permitted according to the terms *
9  * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
10  *****************************************************************************/
11 
12 /**
13 \file RooAbsSelfCachedPdf.cxx
14 \class RooAbsSelfCachedPdf
15 \ingroup Roofitcore
16 
17 RooAbsSelfCachedPdf is an abstract base class for probability
18 density functions whose output is cached in terms of a histogram in
19 all observables between getVal() and evaluate(). For certain
20 p.d.f.s that are very expensive to calculate it may be beneficial
21 to implement them as a RooAbsSelfCachedPdf rather than a
22 RooAbsPdf. Class RooAbsSelfCachedPdf is designed to have its
23 interface identical to that of RooAbsPdf, so any p.d.f can make use
24 of its caching functionality by merely switching its base class.
25 Existing RooAbsPdf objects can also be cached a posteriori with the
26 RooCachedPdf wrapper p.d.f. that takes any RooAbsPdf object as
27 input.
28 **/
29 
30 #include "Riostream.h"
31 
32 #include "RooFit.h"
33 #include "RooAbsSelfCachedPdf.h"
34 #include "RooAbsReal.h"
35 #include "RooMsgService.h"
36 #include "RooDataHist.h"
37 #include "RooHistPdf.h"
38 
39 using namespace std ;
40 
42 
43 
44 
45 ////////////////////////////////////////////////////////////////////////////////
46 /// Constructor
47 
48 RooAbsSelfCachedPdf::RooAbsSelfCachedPdf(const char *name, const char *title, Int_t ipOrder) :
49  RooAbsCachedPdf(name,title,ipOrder)
50  {
51  }
52 
53 
54 
55 ////////////////////////////////////////////////////////////////////////////////
56 /// Copy constructor
57 
59  RooAbsCachedPdf(other,name)
60  {
61  }
62 
63 
64 
65 ////////////////////////////////////////////////////////////////////////////////
66 /// Destructor
67 
69 {
70 }
71 
72 
73 
74 ////////////////////////////////////////////////////////////////////////////////
75 /// Fill cache with sampling of p.d.f as defined by the evaluate() implementation
76 
78 {
79  RooDataHist& cacheHist = *cache.hist() ;
80 
81  // Make deep clone of self in non-caching mde and attach to dataset observables
82  RooArgSet* cloneSet = (RooArgSet*) RooArgSet(*this).snapshot(kTRUE) ;
83  RooAbsSelfCachedPdf* clone2 = (RooAbsSelfCachedPdf*) cloneSet->find(GetName()) ;
84  clone2->disableCache(kTRUE) ;
85  clone2->attachDataSet(cacheHist) ;
86 
87  // Iterator over all bins of RooDataHist and fill weights
88  for (Int_t i=0 ; i<cacheHist.numEntries() ; i++) {
89  const RooArgSet* obs = cacheHist.get(i) ;
90  Double_t wgt = clone2->getVal(obs) ;
91  cacheHist.set(wgt) ;
92  }
93 
94  cache.pdf()->setUnitNorm(kTRUE) ;
95 
96  delete cloneSet ;
97 }
98 
99 
100 
101 ////////////////////////////////////////////////////////////////////////////////
102 /// Defines observables to be cached, given a set of user defined observables
103 /// Returns the subset of nset that are observables this p.d.f
104 
106 {
107  // Make list of servers
108  RooArgSet servers ;
109 
110  TIterator* siter = serverIterator() ;
111  siter->Reset() ;
112  RooAbsArg* server ;
113  while((server=(RooAbsArg*)siter->Next())) {
114  servers.add(*server) ;
115  }
116 
117  // Return servers that are in common with given normalization set
118  return new RooArgSet(servers) ;
119  //return (RooArgSet*) servers.selectCommon(nset) ;
120 
121 }
122 
123 
124 
125 ////////////////////////////////////////////////////////////////////////////////
126 /// Defines parameters on which cache contents depends. Returns
127 /// subset of variables of self that is not contained in the
128 /// supplied nset
129 
131 {
132  RooArgSet *servers = new RooArgSet ;
133 
134  TIterator* siter = serverIterator() ;
135  siter->Reset() ;
136  RooAbsArg* server ;
137  while((server=(RooAbsArg*)siter->Next())) {
138  servers->add(*server) ;
139  }
140 
141  // Remove all given observables from server list
142  servers->remove(nset,kTRUE,kTRUE) ;
143 
144  return servers ;
145 }
146 
147 
148 
149 
150 
151 
152 
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
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 const RooArgSet * get() const
Definition: RooDataHist.h:77
virtual void Reset()=0
Double_t getVal(const RooArgSet *set=0) const
Definition: RooAbsReal.h:64
void set(Double_t weight, Double_t wgtErr=-1)
Increment the weight of the bin enclosing the coordinates given by &#39;row&#39; by the specified amount...
int Int_t
Definition: RtypesCore.h:41
STL namespace.
void attachDataSet(const RooAbsData &set)
Replace server nodes with names matching the dataset variable names with those data set variables...
Definition: RooAbsArg.cxx:1497
Iterator abstract base class.
Definition: TIterator.h:30
virtual void fillCacheObject(PdfCacheElem &cache) const
Fill cache with sampling of p.d.f as defined by the evaluate() implementation.
RooDataSet is a container class to hold N-dimensional binned data.
Definition: RooDataHist.h:40
friend class RooArgSet
Definition: RooAbsArg.h:469
virtual RooArgSet * actualParameters(const RooArgSet &nset) const
Defines parameters on which cache contents depends.
TIterator * serverIterator() const
Definition: RooAbsArg.h:112
RooAbsCachedPdf is the abstract base class for p.d.f.s that need or want to cache their evaluate() ou...
#define ClassImp(name)
Definition: Rtypes.h:336
virtual ~RooAbsSelfCachedPdf()
Destructor.
RooAbsArg * find(const char *name) const
Find object with given name in list.
virtual Int_t numEntries() const
Return the number of bins.
double Double_t
Definition: RtypesCore.h:55
virtual RooArgSet * actualObservables(const RooArgSet &nset) const
Defines observables to be cached, given a set of user defined observables Returns the subset of nset ...
virtual Bool_t remove(const RooAbsArg &var, Bool_t silent=kFALSE, Bool_t matchByNameOnly=kFALSE)
Remove the specified argument from our list.
void setUnitNorm(Bool_t flag)
Definition: RooHistPdf.h:67
virtual TObject * Next()=0
void disableCache(Bool_t flag)
RooAbsSelfCachedPdf is an abstract base class for probability density functions whose output is cache...
RooAbsArg is the common abstract base class for objects that represent a value (of arbitrary type) an...
Definition: RooAbsArg.h:66
const Bool_t kTRUE
Definition: RtypesCore.h:91