Logo ROOT  
Reference Guide
RooProjectedPdf.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 RooProjectedPdf.cxx
14\class RooProjectedPdf
15\ingroup Roofitcore
16
17Class RooProjectedPdf is a RooAbsPdf implementation that represent a projection
18of a given input p.d.f and the object returned by RooAbsPdf::createProjection.
19The actual projection integral for it value and normalization are
20calculated on the fly in getVal() once the normalization observables are known.
21Class RooProjectedPdf can cache projected p.d.f.s for multiple normalization
22observables simultaneously.
23The createProjection() method of RooProjectedPdf is overloaded and will
24return a new RooProjectedPdf that performs the projection of itself
25and the requested additional projections in one integration step
26The performance of <pre>f->createProjection(x)->createProjection(y)</pre>
27is therefore identical to that of <pre>f->createProjection(RooArgSet(x,y))</pre>
28**/
29
30#include "Riostream.h"
31
32#include "RooFit.h"
33#include "RooProjectedPdf.h"
34#include "RooMsgService.h"
35#include "RooAbsReal.h"
36#include "RooRealVar.h"
37#include "RooNameReg.h"
38
39using namespace std;
40
42 ;
43
44
45////////////////////////////////////////////////////////////////////////////////
46/// Default constructor
47
49{
50}
51
52
53
54////////////////////////////////////////////////////////////////////////////////
55/// Construct projection of input pdf '_intpdf' over observables 'intObs'
56
57 RooProjectedPdf::RooProjectedPdf(const char *name, const char *title, RooAbsReal& _intpdf, const RooArgSet& intObs) :
58 RooAbsPdf(name,title),
59 intpdf("!IntegratedPdf","intpdf",this,_intpdf,kFALSE,kFALSE),
60 intobs("!IntegrationObservables","intobs",this,kFALSE,kFALSE),
61 deps("!Dependents","deps",this,kTRUE,kTRUE),
62 _cacheMgr(this,10)
63 {
64 intobs.add(intObs) ;
65
66 // Add all other dependens of projected p.d.f. directly
67 RooArgSet* tmpdeps = _intpdf.getParameters(intObs) ;
68 deps.add(*tmpdeps) ;
69 delete tmpdeps ;
70 }
71
72
73
74////////////////////////////////////////////////////////////////////////////////
75/// Copy constructor
76
78 RooAbsPdf(other,name),
79 intpdf("!IntegratedPdf",this,other.intpdf),
80 intobs("!IntegrationObservable",this,other.intobs),
81 deps("!Dependents",this,other.deps),
82 _cacheMgr(other._cacheMgr,this)
83{
84 }
85
86
87
88////////////////////////////////////////////////////////////////////////////////
89/// Evaluate projected p.d.f
90
92{
93 // Calculate current unnormalized value of object
94 int code ;
95 const RooAbsReal* proj = getProjection(&intobs, _normSet, 0, code);
96
97 return proj->getVal() ;
98}
99
100
101
102////////////////////////////////////////////////////////////////////////////////
103/// Retrieve object representing projection integral of input p.d.f
104/// over observables iset, while normalizing over observables
105/// nset. The code argument returned by reference is the unique code
106/// defining this particular projection configuration
107
108const RooAbsReal* RooProjectedPdf::getProjection(const RooArgSet* iset, const RooArgSet* nset, const char* rangeName, int& code) const
109{
110
111 // Check if this configuration was created before
112 Int_t sterileIdx(-1) ;
113 CacheElem* cache = (CacheElem*) _cacheMgr.getObj(iset,nset,&sterileIdx,RooNameReg::ptr(rangeName)) ;
114 if (cache) {
115 code = _cacheMgr.lastIndex() ;
116 return static_cast<const RooAbsReal*>(cache->_projection);
117 }
118
119 RooArgSet* nset2 = intpdf.arg().getObservables(*nset) ;
120
121 if (iset) {
122 nset2->add(*iset) ;
123 }
124 RooAbsReal* proj = intpdf.arg().createIntegral(iset?*iset:RooArgSet(),nset2,0,rangeName) ;
125 delete nset2 ;
126
127 cache = new CacheElem ;
128 cache->_projection = proj ;
129
130 code = _cacheMgr.setObj(iset,nset,(RooAbsCacheElement*)cache,RooNameReg::ptr(rangeName)) ;
131
132 coutI(Integration) << "RooProjectedPdf::getProjection(" << GetName() << ") creating new projection " << proj->GetName() << " with code " << code << endl ;
133
134 return proj ;
135}
136
137
138
139////////////////////////////////////////////////////////////////////////////////
140/// Special version of RooAbsReal::createProjection that deals with
141/// projections of projections. Instead of integrating twice, a new
142/// RooProjectedPdf is returned that is configured to perform the
143/// complete integration in one step
144
146{
147 RooArgSet combiset(iset) ;
148 combiset.add(intobs) ;
149 return static_cast<RooAbsPdf&>( const_cast<RooAbsReal&>(intpdf.arg()) ).createProjection(combiset) ;
150}
151
152
153
154////////////////////////////////////////////////////////////////////////////////
155/// Force RooRealIntegral to relegate integration of all observables to internal logic
156
158{
159 return kTRUE ;
160}
161
162
163
164////////////////////////////////////////////////////////////////////////////////
165/// Mark all requested variables as internally integrated
166
167Int_t RooProjectedPdf::getAnalyticalIntegralWN(RooArgSet& allVars, RooArgSet& analVars, const RooArgSet* normSet, const char* rangeName) const
168{
169 analVars.add(allVars) ;
170
171 // Create the appropriate integral
172 int code ;
173 RooArgSet allVars2(allVars) ;
174 allVars2.add(intobs) ;
175 getProjection(&allVars2,normSet,rangeName,code) ;
176
177 return code+1 ;
178}
179
180
181
182////////////////////////////////////////////////////////////////////////////////
183/// Return analytical integral represent by appropriate element of projection cache
184
185Double_t RooProjectedPdf::analyticalIntegralWN(Int_t code, const RooArgSet* /*normSet*/, const char* rangeName) const
186{
187 CacheElem *cache = (CacheElem*) _cacheMgr.getObjByIndex(code-1) ;
188
189 if (cache) {
190 return cache->_projection->getVal() ;
191 } else {
192
193 std::unique_ptr<RooArgSet> vars{getParameters(RooArgSet())} ;
194 vars->add(intobs) ;
195 RooArgSet iset = _cacheMgr.selectFromSet1(*vars, code-1) ;
196 RooArgSet nset = _cacheMgr.selectFromSet2(*vars, code-1) ;
197
198 int code2 = -1 ;
199
200 return getProjection(&iset,&nset,rangeName,code2)->getVal() ;
201 }
202
203}
204
205
206
207////////////////////////////////////////////////////////////////////////////////
208/// No internal generator is implemented
209
210Int_t RooProjectedPdf::getGenerator(const RooArgSet& /*directVars*/, RooArgSet& /*generateVars*/, Bool_t /*staticInitOK*/) const
211 {
212 return 0 ;
213 }
214
215
216
217////////////////////////////////////////////////////////////////////////////////
218/// No internal generator is implemented
219
221 {
222 return;
223 }
224
225
226
227////////////////////////////////////////////////////////////////////////////////
228/// Intercept a server redirection all and update list of dependents if necessary
229/// Specifically update the set proxy 'deps' which introduces the dependency
230/// on server value dirty flags of ourselves
231
232Bool_t RooProjectedPdf::redirectServersHook(const RooAbsCollection& newServerList, Bool_t /*mustReplaceAll*/,
233 Bool_t /*nameChange*/, Bool_t /*isRecursive*/)
234{
235 // Redetermine explicit list of dependents if intPdf is being replaced
236 RooAbsArg* newPdf = newServerList.find(intpdf.arg().GetName()) ;
237 if (newPdf) {
238
239 // Determine if set of dependens of new p.d.f is different from old p.d.f.
240 RooArgSet olddeps(deps) ;
241 RooArgSet* newdeps = newPdf->getParameters(intobs) ;
242 RooArgSet* common = (RooArgSet*) newdeps->selectCommon(deps) ;
243 newdeps->remove(*common,kTRUE,kTRUE) ;
244 olddeps.remove(*common,kTRUE,kTRUE) ;
245
246 // If so, adjust composition of deps Listproxy
247 if (newdeps->getSize()>0) {
248 deps.add(*newdeps) ;
249 }
250 if (olddeps.getSize()>0) {
251 deps.remove(olddeps,kTRUE,kTRUE) ;
252 }
253
254 delete common ;
255 delete newdeps ;
256 }
257
258 return kFALSE ;
259}
260
261
262
263////////////////////////////////////////////////////////////////////////////////
264/// Return RooAbsArg elements contained in projection cache element.
265
267{
268 RooArgList ret(*_projection) ;
269 return ret ;
270}
271
272
273
274////////////////////////////////////////////////////////////////////////////////
275/// Customized printing of arguments of a RooRealIntegral to more intuitively reflect the contents of the
276/// integration operation
277
278void RooProjectedPdf::printMetaArgs(ostream& os) const
279{
280 os << "Int " << intpdf.arg().GetName() ;
281
282 os << " d" ;
283 os << intobs ;
284 os << " " ;
285
286}
287
288
289
290
291////////////////////////////////////////////////////////////////////////////////
292/// Print contents of cache when printing self as part of object tree
293
294void RooProjectedPdf::CacheElem::printCompactTreeHook(ostream& os, const char* indent, Int_t curElem, Int_t maxElem)
295{
296 if (curElem==0) {
297 os << indent << "RooProjectedPdf begin projection cache" << endl ;
298 }
299
300 TString indent2(indent) ;
301 indent2 += Form("[%d] ",curElem) ;
302
303 _projection->printCompactTree(os,indent2) ;
304
305 if(curElem==maxElem) {
306 os << indent << "RooProjectedPdf end projection cache" << endl ;
307 }
308}
309
310
#define coutI(a)
Definition: RooMsgService.h:30
int Int_t
Definition: RtypesCore.h:45
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
#define ClassImp(name)
Definition: Rtypes.h:364
static void indent(ostringstream &buf, int indent_level)
char name[80]
Definition: TGX11.cxx:110
char * Form(const char *fmt,...)
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooArgSet * getObservables(const RooArgSet &set, Bool_t valueOnly=kTRUE) const
Given a set of possible observables, return the observables that this PDF depends on.
Definition: RooAbsArg.h:295
friend class RooArgSet
Definition: RooAbsArg.h:600
RooArgSet * getParameters(const RooAbsData *data, bool stripDisconnected=true) const
Create a list of leaf nodes in the arg tree starting with ourself as top node that don't match any of...
Definition: RooAbsArg.cxx:578
RooAbsCacheElement is the abstract base class for objects to be stored in RooAbsCache cache manager o...
RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects.
Int_t getSize() const
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
bool selectCommon(const RooAbsCollection &refColl, RooAbsCollection &outColl) const
Create a subset of the current collection, consisting only of those elements that are contained as we...
virtual Bool_t remove(const RooAbsArg &var, Bool_t silent=kFALSE, Bool_t matchByNameOnly=kFALSE)
Remove the specified argument from our list.
RooAbsArg * find(const char *name) const
Find object with given name in list.
friend class CacheElem
The cache manager.
Definition: RooAbsPdf.h:364
RooArgSet * _normSet
Normalization integral (owned by _normMgr)
Definition: RooAbsPdf.h:353
virtual RooAbsPdf * createProjection(const RooArgSet &iset)
Return a p.d.f that represent a projection of this p.d.f integrated over given observables.
Definition: RooAbsPdf.cxx:3350
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:61
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:547
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:91
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:22
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:35
T * getObj(const RooArgSet *nset, Int_t *sterileIndex=0, const TNamed *isetRangeName=0)
RooArgSet selectFromSet1(RooArgSet const &argSet, int index) const
Create RooArgSet contatining the objects that are both in the cached set 1.
T * getObjByIndex(Int_t index) const
Retrieve payload object by slot index.
RooArgSet selectFromSet2(RooArgSet const &argSet, int index) const
Create RooArgSet contatining the objects that are both in the cached set 2.
Int_t lastIndex() const
Int_t setObj(const RooArgSet *nset, T *obj, const TNamed *isetRangeName=0)
static const TNamed * ptr(const char *stringPtr)
Return a unique TNamed pointer for given C++ string.
Definition: RooNameReg.cxx:93
virtual RooArgList containedArgs(Action)
Return RooAbsArg elements contained in projection cache element.
virtual void printCompactTreeHook(std::ostream &, const char *, Int_t, Int_t)
Print contents of cache when printing self as part of object tree.
Class RooProjectedPdf is a RooAbsPdf implementation that represent a projection of a given input p....
void generateEvent(Int_t code)
No internal generator is implemented.
void printMetaArgs(std::ostream &os) const
Customized printing of arguments of a RooRealIntegral to more intuitively reflect the contents of the...
RooRealProxy intpdf
virtual Bool_t forceAnalyticalInt(const RooAbsArg &dep) const
Force RooRealIntegral to relegate integration of all observables to internal logic.
Int_t getGenerator(const RooArgSet &directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const
No internal generator is implemented.
RooObjCacheManager _cacheMgr
virtual Double_t analyticalIntegralWN(Int_t code, const RooArgSet *normSet, const char *rangeName=0) const
Return analytical integral represent by appropriate element of projection cache.
virtual Int_t getAnalyticalIntegralWN(RooArgSet &allVars, RooArgSet &analVars, const RooArgSet *normSet, const char *rangeName=0) const
Mark all requested variables as internally integrated.
Double_t evaluate() const
Evaluate projected p.d.f.
RooProjectedPdf()
Default constructor.
const RooAbsReal * getProjection(const RooArgSet *iset, const RooArgSet *nset, const char *rangeName, int &code) const
Retrieve object representing projection integral of input p.d.f over observables iset,...
Bool_t redirectServersHook(const RooAbsCollection &newServerList, Bool_t, Bool_t, Bool_t)
The cache manager.
RooSetProxy intobs
RooSetProxy deps
virtual RooAbsPdf * createProjection(const RooArgSet &iset)
Special version of RooAbsReal::createProjection that deals with projections of projections.
virtual Bool_t remove(const RooAbsArg &var, Bool_t silent=kFALSE, Bool_t matchByNameOnly=kFALSE) override
Remove object 'var' from set and deregister 'var' as server to owner.
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE) override
Overloaded RooArgSet::add() method inserts 'var' into set and registers 'var' as server to owner with...
const T & arg() const
Return reference to object held in proxy.
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
Basic string class.
Definition: TString.h:136
@ Integration
Definition: RooGlobalFunc.h:60