Logo ROOT  
Reference Guide
RooConvGenContext.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 * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8 * *
9 * Copyright (c) 2000-2005, 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 RooConvGenContext.cxx
19\class RooConvGenContext
20\ingroup Roofitcore
21
22RooConvGenContext is an efficient implementation of the generator context
23specific for RooAbsAnaConvPdf objects. The physics model is generated
24with a truth resolution model and the requested resolution model is generated
25separately as a PDF. The convolution variable of the physics model is
26subsequently explicitly smeared with the resolution model distribution.
27**/
28
29#include "RooMsgService.h"
30#include "RooErrorHandler.h"
31#include "RooConvGenContext.h"
32#include "RooAbsAnaConvPdf.h"
33#include "RooNumConvPdf.h"
34#include "RooFFTConvPdf.h"
35#include "RooProdPdf.h"
36#include "RooDataSet.h"
37#include "RooArgSet.h"
38#include "RooTruthModel.h"
39#include "Riostream.h"
40
41
42using namespace std;
43
45;
46
47
48////////////////////////////////////////////////////////////////////////////////
49/// Constructor for specialized generator context for analytical convolutions.
50///
51/// Builds a generator for the physics PDF convoluted with the truth model
52/// and a generator for the resolution model as PDF. Events are generated
53/// by sampling events from the p.d.f and smearings from the resolution model
54/// and adding these to obtain a distribution of events consistent with the
55/// convolution of these two. The advantage of this procedure is so that
56/// both p.d.f and resolution model can take advantage of any internal
57/// generators that may be defined.
58
60 const RooDataSet *prototype, const RooArgSet* auxProto, Bool_t verbose) :
61 RooAbsGenContext(model,vars,prototype,auxProto,verbose), _pdfVarsOwned(0), _modelVarsOwned(0)
62{
63 cxcoutI(Generation) << "RooConvGenContext::ctor() setting up special generator context for analytical convolution p.d.f. " << model.GetName()
64 << " for generation of observable(s) " << vars << endl ;
65
66 // Clone PDF and change model to internal truth model
68 if (!_pdfCloneSet) {
69 coutE(Generation) << "RooConvGenContext::RooConvGenContext(" << GetName() << ") Couldn't deep-clone PDF, abort," << endl ;
71 }
72
74 RooTruthModel truthModel("truthModel","Truth resolution model",*pdfClone->convVar()) ;
75 pdfClone->changeModel(truthModel) ;
76 auto convV = dynamic_cast<RooRealVar*>(pdfClone->convVar());
77 if (!convV) {
78 throw std::runtime_error("RooConvGenContext only works with convolution variables of type RooRealVar.");
79 }
80 convV->removeRange();
81
82 // Create generator for physics X truth model
83 _pdfVars = (RooArgSet*) pdfClone->getObservables(&vars) ; ;
84 _pdfGen = pdfClone->genContext(*_pdfVars,prototype,auxProto,verbose) ;
85
86 // Clone resolution model and use as normal PDF
87 _modelCloneSet = (RooArgSet*) RooArgSet(*model._convSet.at(0)).snapshot(kTRUE) ;
88 if (!_modelCloneSet) {
89 coutE(Generation) << "RooConvGenContext::RooConvGenContext(" << GetName() << ") Couldn't deep-clone resolution model, abort," << endl ;
91 }
93 _modelCloneSet->find(model._convSet.at(0)->GetName())->Clone("smearing") ;
94 _modelCloneSet->addOwned(*modelClone) ;
95 modelClone->changeBasis(0) ;
96 convV = dynamic_cast<RooRealVar*>(&modelClone->convVar());
97 if (!convV) {
98 throw std::runtime_error("RooConvGenContext only works with convolution variables of type RooRealVar.");
99 }
100 convV->removeRange();
101
102 // Create generator for resolution model as PDF
103 _modelVars = (RooArgSet*) modelClone->getObservables(&vars) ;
104
105 _modelVars->add(modelClone->convVar()) ;
106 _convVarName = modelClone->convVar().GetName() ;
107 _modelGen = modelClone->genContext(*_modelVars,prototype,auxProto,verbose) ;
108
109 if (prototype) {
110 _pdfVars->add(*prototype->get()) ;
111 _modelVars->add(*prototype->get()) ;
112 }
113
114 // WVE ADD FOR DEBUGGING
115 if (auxProto) {
116 _pdfVars->add(*auxProto) ;
117 _modelVars->add(*auxProto) ;
118 }
119
120// cout << "RooConvGenContext::ctor(" << this << "," << GetName() << ") _pdfVars = " << _pdfVars << " " ; _pdfVars->Print("1") ;
121// cout << "RooConvGenContext::ctor(" << this << "," << GetName() << ") _modelVars = " << _modelVars << " " ; _modelVars->Print("1") ;
122}
123
124
125
126////////////////////////////////////////////////////////////////////////////////
127/// Constructor for specialized generator context for numerical convolutions.
128///
129/// Builds a generator for the physics PDF convoluted with the truth model
130/// and a generator for the resolution model as PDF. Events are generated
131/// by sampling events from the p.d.f and smearings from the resolution model
132/// and adding these to obtain a distribution of events consistent with the
133/// convolution of these two. The advantage of this procedure is so that
134/// both p.d.f and resolution model can take advantage of any internal
135/// generators that may be defined.
136
138 const RooDataSet *prototype, const RooArgSet* auxProto, Bool_t verbose) :
139 RooAbsGenContext(model,vars,prototype,auxProto,verbose)
140{
141 cxcoutI(Generation) << "RooConvGenContext::ctor() setting up special generator context for numeric convolution p.d.f. " << model.GetName()
142 << " for generation of observable(s) " << vars << endl ;
143
144 // Create generator for physics X truth model
147 _pdfGen = ((RooAbsPdf&)model.conv().clonePdf()).genContext(*_pdfVars,prototype,auxProto,verbose) ;
148 _pdfCloneSet = 0 ;
149
150 // Create generator for resolution model as PDF
153 _convVarName = model.conv().cloneVar().GetName() ;
154 _modelGen = ((RooAbsPdf&)model.conv().cloneModel()).genContext(*_modelVars,prototype,auxProto,verbose) ;
156 _modelCloneSet->add(model.conv().cloneModel()) ;
157
158 if (prototype) {
159 _pdfVars->add(*prototype->get()) ;
160 _modelVars->add(*prototype->get()) ;
161 }
162}
163
164
165
166////////////////////////////////////////////////////////////////////////////////
167/// Constructor for specialized generator context for FFT numerical convolutions.
168///
169/// Builds a generator for the physics PDF convoluted with the truth model
170/// and a generator for the resolution model as PDF. Events are generated
171/// by sampling events from the p.d.f and smearings from the resolution model
172/// and adding these to obtain a distribution of events consistent with the
173/// convolution of these two. The advantage of this procedure is so that
174/// both p.d.f and resolution model can take advantage of any internal
175/// generators that may be defined.
176
178 const RooDataSet *prototype, const RooArgSet* auxProto, Bool_t verbose) :
179 RooAbsGenContext(model,vars,prototype,auxProto,verbose)
180{
181 cxcoutI(Generation) << "RooConvGenContext::ctor() setting up special generator context for fft convolution p.d.f. " << model.GetName()
182 << " for generation of observable(s) " << vars << endl ;
183
184 _convVarName = model._x.arg().GetName() ;
185
186 // Create generator for physics model
187 _pdfCloneSet = (RooArgSet*) RooArgSet(model._pdf1.arg()).snapshot(kTRUE) ;
188 RooAbsPdf* pdfClone = (RooAbsPdf*) _pdfCloneSet->find(model._pdf1.arg().GetName()) ;
189 RooRealVar* cvPdf = (RooRealVar*) _pdfCloneSet->find(model._x.arg().GetName()) ;
190 cvPdf->removeRange() ;
191 RooArgSet* tmp1 = pdfClone->getObservables(&vars) ;
194 _pdfGen = pdfClone->genContext(*_pdfVars,prototype,auxProto,verbose) ;
195
196 // Create generator for resolution model
197 _modelCloneSet = (RooArgSet*) RooArgSet(model._pdf2.arg()).snapshot(kTRUE) ;
198 RooAbsPdf* modelClone = (RooAbsPdf*) _modelCloneSet->find(model._pdf2.arg().GetName()) ;
199 RooRealVar* cvModel = (RooRealVar*) _modelCloneSet->find(model._x.arg().GetName()) ;
200 cvModel->removeRange() ;
201 RooArgSet* tmp2 = modelClone->getObservables(&vars) ;
204 _modelGen = modelClone->genContext(*_pdfVars,prototype,auxProto,verbose) ;
205
206 delete tmp1 ;
207 delete tmp2 ;
208
209 if (prototype) {
210 _pdfVars->add(*prototype->get()) ;
211 _modelVars->add(*prototype->get()) ;
212 }
213}
214
215
216
217////////////////////////////////////////////////////////////////////////////////
218/// Destructor
219
221{
222 // Destructor. Delete all owned subgenerator contexts
223 delete _pdfGen ;
224 delete _modelGen ;
225 delete _pdfCloneSet ;
226 delete _modelCloneSet ;
227 delete _modelVars ;
228 delete _pdfVars ;
229 delete _pdfVarsOwned ;
230 delete _modelVarsOwned ;
231}
232
233
234
235////////////////////////////////////////////////////////////////////////////////
236/// Attach given set of arguments to internal clones of
237/// pdf and resolution model
238
240{
241 // Find convolution variable in input and output sets
244
245 // Replace all servers in _pdfVars and _modelVars with those in theEvent, except for the convolution variable
246 RooArgSet* pdfCommon = (RooArgSet*) args.selectCommon(*_pdfVars) ;
247 pdfCommon->remove(*cvPdf,kTRUE,kTRUE) ;
248
249 RooArgSet* modelCommon = (RooArgSet*) args.selectCommon(*_modelVars) ;
250 modelCommon->remove(*cvModel,kTRUE,kTRUE) ;
251
252 _pdfGen->attach(*pdfCommon) ;
253 _modelGen->attach(*modelCommon) ;
254
255 delete pdfCommon ;
256 delete modelCommon ;
257}
258
259
260////////////////////////////////////////////////////////////////////////////////
261/// One-time initialization of generator context, attaches
262/// the context to the supplied event container
263
265{
266 // Find convolution variable in input and output sets
269 _cvOut = (RooRealVar*) theEvent.find(_convVarName) ;
270
271 // Replace all servers in _pdfVars and _modelVars with those in theEvent, except for the convolution variable
272 RooArgSet* pdfCommon = (RooArgSet*) theEvent.selectCommon(*_pdfVars) ;
273 pdfCommon->remove(*_cvPdf,kTRUE,kTRUE) ;
274 _pdfVars->replace(*pdfCommon) ;
275 delete pdfCommon ;
276
277 RooArgSet* modelCommon = (RooArgSet*) theEvent.selectCommon(*_modelVars) ;
278 modelCommon->remove(*_cvModel,kTRUE,kTRUE) ;
279 _modelVars->replace(*modelCommon) ;
280 delete modelCommon ;
281
282 // Initialize component generators
285}
286
287
288
289////////////////////////////////////////////////////////////////////////////////
290/// Generate a single event
291
293{
294 while(1) {
295
296 // Generate pdf and model data
297 _modelGen->generateEvent(*_modelVars,remaining) ;
298 _pdfGen->generateEvent(*_pdfVars,remaining) ;
299
300 // Construct smeared convolution variable
301 Double_t convValSmeared = _cvPdf->getVal() + _cvModel->getVal() ;
302 if (_cvOut->isValidReal(convValSmeared)) {
303 // Smeared value in acceptance range, transfer values to output set
304 theEvent.assign(*_modelVars) ;
305 theEvent.assign(*_pdfVars) ;
306 _cvOut->setVal(convValSmeared) ;
307 return ;
308 }
309 }
310}
311
312
313
314////////////////////////////////////////////////////////////////////////////////
315/// Set the traversal order for events in the prototype dataset
316/// The argument is a array of integers with a size identical
317/// to the number of events in the prototype dataset. Each element
318/// should contain an integer in the range 1-N.
319
321{
325}
326
327
328////////////////////////////////////////////////////////////////////////////////
329/// Print the details of this generator context
330
332{
334 os << indent << "--- RooConvGenContext ---" << endl ;
335 os << indent << "List of component generators" << endl ;
336
337 TString indent2(indent) ;
338 indent2.Append(" ") ;
339
340 _modelGen->printMultiline(os,content,verbose,indent2);
341 _pdfGen->printMultiline(os,content,verbose,indent2);
342}
#define cxcoutI(a)
Definition: RooMsgService.h:85
#define coutE(a)
Definition: RooMsgService.h:33
const Bool_t kTRUE
Definition: RtypesCore.h:100
#define ClassImp(name)
Definition: Rtypes.h:375
static void indent(ostringstream &buf, int indent_level)
RooAbsAnaConvPdf is the base class for PDFs that represent a physics model that can be analytically c...
virtual Bool_t changeModel(const RooResolutionModel &newModel)
Change the current resolution model to newModel.
RooAbsGenContext * genContext(const RooArgSet &vars, const RooDataSet *prototype=0, const RooArgSet *auxProto=0, Bool_t verbose=kFALSE) const override
Create a generator context for this p.d.f.
RooAbsRealLValue * convVar()
Retrieve the convolution variable.
RooListProxy _convSet
Set of (resModel (x) basisFunc) convolution objects.
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:318
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
void assign(const RooAbsCollection &other) const
Sets the value, cache and constant attribute of any argument in our set that also appears in the othe...
virtual Bool_t addOwned(RooAbsArg &var, Bool_t silent=kFALSE)
Add an argument and transfer the ownership to the collection.
virtual Bool_t replace(const RooAbsArg &var1, const RooAbsArg &var2)
Replace var1 with var2 and return true for success.
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.
RooAbsGenContext is the abstract base class for generator contexts of RooAbsPdf objects.
void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const override
Interface for multi-line printing.
virtual void attach(const RooArgSet &params)
Interface to attach given parameters to object in this context.
virtual void initGenerator(const RooArgSet &theEvent)
Interface function to initialize context for generation for given set of observables.
virtual void generateEvent(RooArgSet &theEvent, Int_t remaining)=0
virtual void setProtoDataOrder(Int_t *lut)
Set the traversal order of prototype data to that in the lookup tables passed as argument.
virtual RooAbsGenContext * genContext(const RooArgSet &vars, const RooDataSet *prototype=0, const RooArgSet *auxProto=0, Bool_t verbose=kFALSE) const
Interface function to create a generator context from a p.d.f.
Definition: RooAbsPdf.cxx:1903
Bool_t isValidReal(Double_t value, Bool_t printError=kFALSE) const override
Check if given value is valid.
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:93
RooAbsArg * at(Int_t idx) const
Return object at given index, or nullptr if index is out of range.
Definition: RooArgList.h:110
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:57
RooArgSet * snapshot(bool deepCopy=true) const
Use RooAbsCollection::snapshot(), but return as RooArgSet.
Definition: RooArgSet.h:180
RooConvGenContext is an efficient implementation of the generator context specific for RooAbsAnaConvP...
RooArgSet * _modelCloneSet
Owner of resModel clone.
RooArgSet * _modelVarsOwned
Owning version of modelVars ;.
RooConvGenContext(const RooFFTConvPdf &model, const RooArgSet &vars, const RooDataSet *prototype=0, const RooArgSet *auxProto=0, Bool_t _verbose=kFALSE)
Constructor for specialized generator context for FFT numerical convolutions.
RooAbsGenContext * _pdfGen
Physics model generator context.
RooAbsGenContext * _modelGen
Resolution model generator context.
void setProtoDataOrder(Int_t *lut) override
Set the traversal order for events in the prototype dataset The argument is a array of integers with ...
RooArgSet * _pdfCloneSet
Owner of PDF clone.
~RooConvGenContext() override
Destructor.
void printMultiline(std::ostream &os, Int_t content, Bool_t verbose=kFALSE, TString indent="") const override
Print the details of this generator context.
RooArgSet * _pdfVarsOwned
Owning version of pdfVars ;.
RooRealVar * _cvPdf
Convolution variable in PDFxTruth event.
void attach(const RooArgSet &params) override
Attach given set of arguments to internal clones of pdf and resolution model.
RooRealVar * _cvOut
Convolution variable in output event.
RooRealVar * _cvModel
Convolution variable in resModel event.
void generateEvent(RooArgSet &theEvent, Int_t remaining) override
Generate a single event.
void initGenerator(const RooArgSet &theEvent) override
One-time initialization of generator context, attaches the context to the supplied event container.
TString _convVarName
Name of convolution variable.
RooArgSet * _pdfVars
Holder of PDF x truth event.
RooArgSet * _modelVars
Holder of resModel event.
RooDataSet is a container class to hold unbinned data.
Definition: RooDataSet.h:55
const RooArgSet * get(Int_t index) const override
Return RooArgSet with coordinates of event 'index'.
static void softAbort()
Soft abort function that interrupts macro execution but doesn't kill ROOT.
PDF for the numerical (FFT) convolution of two PDFs.
Definition: RooFFTConvPdf.h:25
RooRealProxy _pdf1
First input p.d.f.
Definition: RooFFTConvPdf.h:69
RooRealProxy _x
Convolution observable.
Definition: RooFFTConvPdf.h:67
RooRealProxy _pdf2
Second input p.d.f.
Definition: RooFFTConvPdf.h:70
Numeric 1-dimensional convolution operator PDF.
Definition: RooNumConvPdf.h:26
RooNumConvolution & conv() const
Definition: RooNumConvPdf.h:63
RooAbsReal & cloneModel() const
RooRealVar & cloneVar() const
RooAbsReal & clonePdf() const
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:40
void setVal(Double_t value) override
Set value of variable to 'value'.
Definition: RooRealVar.cxx:281
void removeRange(const char *name=0)
Remove range limits for binning with given name. Empty name means default range.
Definition: RooRealVar.cxx:423
RooResolutionModel is the base class for PDFs that represent a resolution model that can be convolute...
virtual void changeBasis(RooFormulaVar *basis)
Change the basis function we convolute with.
RooAbsRealLValue & convVar() const
Return the convolution variable of the resolution model.
const T & arg() const
Return reference to object held in proxy.
RooTruthModel is an implementation of RooResolution model that provides a delta-function resolution m...
Definition: RooTruthModel.h:21
TObject * Clone(const char *newname="") const override
Make a clone of an object using the Streamer facility.
Definition: TNamed.cxx:74
const char * GetName() const override
Returns name of object.
Definition: TNamed.h:47
Basic string class.
Definition: TString.h:136
TString & Append(const char *cs)
Definition: TString.h:564
@ Generation
Definition: RooGlobalFunc.h:63