Logo ROOT  
Reference Guide
RooGenContext.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 RooGenContext.cxx
19 \class RooGenContext
20 \ingroup Roofitcore
21 
22 Class RooGenContext implement a universal generator context for all
23 RooAbsPdf classes that do not have or need a specialized generator
24 context. This generator context queries the input p.d.f which observables
25 it can generate internally and delegates generation of those observables
26 to the p.d.f if it deems that safe. The other observables are generated
27 use a RooAcceptReject sampling technique.
28 **/
29 
30 
31 #include "RooFit.h"
32 #include "RooMsgService.h"
33 #include "Riostream.h"
34 
35 #include "RooGenContext.h"
36 #include "RooAbsPdf.h"
37 #include "RooDataSet.h"
38 #include "RooRealIntegral.h"
39 #include "RooAcceptReject.h"
40 #include "RooRealVar.h"
41 #include "RooDataHist.h"
42 #include "RooErrorHandler.h"
43 #include "RooNumGenConfig.h"
44 #include "RooNumGenFactory.h"
45 
46 #include "TString.h"
47 #include "TIterator.h"
48 #include "TClass.h"
49 
50 
51 
52 using namespace std;
53 
55  ;
56 
57 
58 
59 ////////////////////////////////////////////////////////////////////////////////
60 /// Initialize a new context for generating events with the specified
61 /// variables, using the specified PDF model. A prototype dataset (if provided)
62 /// is not cloned and still belongs to the caller. The contents and shape
63 /// of this dataset can be changed between calls to generate() as long as the
64 /// expected columns to be copied to the generated dataset are present.
65 /// Any argument supplied in the forceDirect RooArgSet are always offered
66 /// for internal generation to the p.d.f., even if this is deemed unsafe by
67 /// the logic of RooGenContext.
68 
70  const RooDataSet *prototype, const RooArgSet* auxProto,
71  Bool_t verbose, const RooArgSet* forceDirect) :
72  RooAbsGenContext(model,vars,prototype,auxProto,verbose),
73  _cloneSet(0), _pdfClone(0), _acceptRejectFunc(0), _generator(0),
74  _maxVar(0), _uniIter(0), _updateFMaxPerEvent(0)
75 {
76  cxcoutI(Generation) << "RooGenContext::ctor() setting up event generator context for p.d.f. " << model.GetName()
77  << " for generation of observable(s) " << vars ;
78  if (prototype) ccxcoutI(Generation) << " with prototype data for " << *prototype->get() ;
79  if (auxProto && auxProto->getSize()>0) ccxcoutI(Generation) << " with auxiliary prototypes " << *auxProto ;
80  if (forceDirect && forceDirect->getSize()>0) ccxcoutI(Generation) << " with internal generation forced for observables " << *forceDirect ;
81  ccxcoutI(Generation) << endl ;
82 
83 
84  // Clone the model and all nodes that it depends on so that this context
85  // is independent of any existing objects.
86  RooArgSet nodes(model,model.GetName());
87  _cloneSet= (RooArgSet*) nodes.snapshot(kTRUE);
88  if (!_cloneSet) {
89  coutE(Generation) << "RooGenContext::RooGenContext(" << GetName() << ") Couldn't deep-clone PDF, abort," << endl ;
91  }
92 
93  // Find the clone in the snapshot list
94  _pdfClone = (RooAbsPdf*)_cloneSet->find(model.GetName());
96 
97  // Optionally fix RooAddPdf normalizations
98  if (prototype&&_pdfClone->dependsOn(*prototype->get())) {
99  RooArgSet fullNormSet(vars) ;
100  fullNormSet.add(*prototype->get()) ;
101  _pdfClone->fixAddCoefNormalization(fullNormSet) ;
102  }
103 
104  // Analyze the list of variables to generate...
105  _isValid= kTRUE;
106  TIterator *iterator= vars.createIterator();
107  TIterator *servers= _pdfClone->serverIterator();
108  const RooAbsArg *tmp = 0;
109  const RooAbsArg *arg = 0;
110  while((_isValid && (tmp= (const RooAbsArg*)iterator->Next()))) {
111  // is this argument derived?
112  if(!tmp->isFundamental()) {
113  coutE(Generation) << "RooGenContext::ctor(): cannot generate values for derived \"" << tmp->GetName() << "\"" << endl;
114  _isValid= kFALSE;
115  continue;
116  }
117  // lookup this argument in the cloned set of PDF dependents
118  arg= (const RooAbsArg*)_cloneSet->find(tmp->GetName());
119  if(0 == arg) {
120  coutI(Generation) << "RooGenContext::ctor() WARNING model does not depend on \"" << tmp->GetName()
121  << "\" which will have uniform distribution" << endl;
122  _uniformVars.add(*tmp);
123  }
124  else {
125 
126  // does the model depend on this variable directly, ie, like "x" in
127  // f(x) or f(x,g(x,y)) or even f(x,x) ?
128  const RooAbsArg *direct= arg ;
129  if (forceDirect==0 || !forceDirect->find(direct->GetName())) {
130  if (!_pdfClone->isDirectGenSafe(*arg)) {
131  cxcoutD(Generation) << "RooGenContext::ctor() observable " << arg->GetName() << " has been determined to be unsafe for internal generation" << endl;
132  direct=0 ;
133  }
134  }
135 
136  // does the model depend indirectly on this variable through an lvalue chain?
137  // otherwise, this variable will have to be generated with accept/reject
138  if(direct) {
139  _directVars.add(*arg);
140  } else {
141  _otherVars.add(*arg);
142  }
143  }
144  }
145  delete servers;
146  delete iterator;
147  if(!isValid()) {
148  coutE(Generation) << "RooGenContext::ctor() constructor failed with errors" << endl;
149  return;
150  }
151 
152  // At this point directVars are all variables that are safe to be generated directly
153  // otherVars are all variables that are _not_ safe to be generated directly
154  if (_directVars.getSize()>0) {
155  cxcoutD(Generation) << "RooGenContext::ctor() observables " << _directVars << " are safe for internal generator (if supported by p.d.f)" << endl ;
156  }
157  if (_otherVars.getSize()>0) {
158  cxcoutD(Generation) << "RooGenContext::ctor() observables " << _otherVars << " are NOT safe for internal generator (if supported by p.d.f)" << endl ;
159  }
160 
161  // If PDF depends on prototype data, direct generator cannot use static initialization
162  // in initGenerator()
163  Bool_t staticInitOK = !_pdfClone->dependsOn(_protoVars) ;
164  if (!staticInitOK) {
165  cxcoutD(Generation) << "RooGenContext::ctor() Model depends on supplied protodata observables, static initialization of internal generator will not be allowed" << endl ;
166  }
167 
168  // Can the model generate any of the direct variables itself?
169  RooArgSet generatedVars;
170  if (_directVars.getSize()>0) {
171  _code= _pdfClone->getGenerator(_directVars,generatedVars,staticInitOK);
172 
173  cxcoutD(Generation) << "RooGenContext::ctor() Model indicates that it can internally generate observables "
174  << generatedVars << " with configuration identifier " << _code << endl ;
175  } else {
176  _code = 0 ;
177  }
178 
179  // Move variables which cannot be generated into the list to be generated with accept/reject
180  _directVars.remove(generatedVars);
182 
183  // Update _directVars to only include variables that will actually be directly generated
185  _directVars.add(generatedVars);
186 
187  cxcoutI(Generation) << "RooGenContext::ctor() Context will" ;
188  if (_directVars.getSize()>0) ccxcoutI(Generation) << " let model internally generate observables " << _directVars ;
189  if (_directVars.getSize()>0 && _otherVars.getSize()>0) ccxcoutI(Generation) << " and" ;
190  if (_otherVars.getSize()>0) ccxcoutI(Generation) << " generate variables " << _otherVars << " with accept/reject sampling" ;
191  if (_uniformVars.getSize()>0) ccxcoutI(Generation) << ", non-observable variables " << _uniformVars << " will be generated with flat distribution" ;
192  ccxcoutI(Generation) << endl ;
193 
194  // initialize the accept-reject generator
196  depList->remove(_otherVars);
197 
198  TString nname(_pdfClone->GetName()) ;
199  nname.Append("_AccRej") ;
200  TString ntitle(_pdfClone->GetTitle()) ;
201  ntitle.Append(" (Accept/Reject)") ;
202 
203 
204  RooArgSet* protoDeps = model.getObservables(_protoVars) ;
205 
206 
207  if (_protoVars.getSize()==0) {
208 
209  // No prototype variables
210 
211  if(depList->getSize()==0) {
212  // All variable are generated with accept-reject
213 
214  // Check if PDF supports maximum finding
215  Int_t maxFindCode = _pdfClone->getMaxVal(_otherVars) ;
216  if (maxFindCode != 0) {
217  coutI(Generation) << "RooGenContext::ctor() no prototype data provided, all observables are generated with numerically and "
218  << "model supports analytical maximum findin:, can provide analytical pdf maximum to numeric generator" << endl ;
219  Double_t maxVal = _pdfClone->maxVal(maxFindCode) / _pdfClone->getNorm(_theEvent) ;
220  _maxVar = new RooRealVar("funcMax","function maximum",maxVal) ;
221  cxcoutD(Generation) << "RooGenContext::ctor() maximum value returned by RooAbsPdf::maxVal() is " << maxVal << endl ;
222  }
223  }
224 
225  if (_otherVars.getSize()>0) {
226  _pdfClone->getVal(&vars) ; // WVE debug
227  _acceptRejectFunc= new RooRealIntegral(nname,ntitle,*_pdfClone,*depList,&vars);
228  cxcoutI(Generation) << "RooGenContext::ctor() accept/reject sampling function is " << _acceptRejectFunc->GetName() << endl ;
229  } else {
230  _acceptRejectFunc = 0 ;
231  }
232 
233  } else {
234 
235  // Generation _with_ prototype variable
236  depList->remove(_protoVars,kTRUE,kTRUE) ;
238  cxcoutI(Generation) << "RooGenContext::ctor() accept/reject sampling function is " << _acceptRejectFunc->GetName() << endl ;
239 
240  // Check if PDF supports maximum finding for the entire phase space
241  RooArgSet allVars(_otherVars);
242  allVars.add(_directVars);
243  Int_t maxFindCode = _pdfClone->getMaxVal(allVars) ;
244  if (maxFindCode != 0) {
245  // Special case: PDF supports max-finding in otherVars, no need to scan other+proto space for maximum
246  coutI(Generation) << "RooGenContext::ctor() prototype data provided, and "
247  << "model supports analytical maximum finding in the full phase space: "
248  << "can provide analytical pdf maximum to numeric generator" << endl ;
249  _maxVar = new RooRealVar("funcMax","function maximum",_pdfClone->maxVal(maxFindCode)) ;
250  } else {
251  maxFindCode = _pdfClone->getMaxVal(_otherVars) ;
252  if (maxFindCode != 0) {
253  _updateFMaxPerEvent = maxFindCode ;
254  coutI(Generation) << "RooGenContext::ctor() prototype data provided, and "
255  << "model supports analytical maximum finding in the variables which are not"
256  << " internally generated. Can provide analytical pdf maximum to numeric "
257  << "generator" << endl;
258  cxcoutD(Generation) << "RooGenContext::ctor() maximum value must be reevaluated for each "
259  << "event with configuration code " << maxFindCode << endl ;
260  _maxVar = new RooRealVar("funcMax","function maximum",1) ;
261  }
262  }
263 
264  if (!_maxVar) {
265 
266  // Regular case: First find maximum in other+proto space
267  RooArgSet otherAndProto(_otherVars) ;
268 
269  otherAndProto.add(*protoDeps) ;
270 
271  if (_otherVars.getSize()>0) {
272 
273  cxcoutD(Generation) << "RooGenContext::ctor() prototype data provided, observables are generated numericaly no "
274  << "analytical estimate of maximum function value provided by model, must determine maximum value through initial sampling space "
275  << "of accept/reject observables plus prototype observables: " << otherAndProto << endl ;
276 
277  // Calculate maximum in other+proto space if there are any accept/reject generated observables
279  *model.getGeneratorConfig(),_verbose) ;
280 // RooAcceptReject maxFinder(*_acceptRejectFunc,otherAndProto,RooNumGenConfig::defaultConfig(),_verbose) ;
281  Double_t max = maxFinder->getFuncMax() ;
282  _maxVar = new RooRealVar("funcMax","function maximum",max) ;
283 
284  if (max==0) {
285  coutE(Generation) << "RooGenContext::ctor(" << model.GetName()
286  << ") ERROR: generating conditional p.d.f. which requires prior knowledge of function maximum, "
287  << "but chosen numeric generator (" << maxFinder->IsA()->GetName() << ") does not support maximum finding" << endl ;
288  delete maxFinder ;
289  throw string("RooGenContext::ctor()") ;
290  }
291  delete maxFinder ;
292 
293  cxcoutD(Generation) << "RooGenContext::ctor() maximum function value found through initial sampling is " << max << endl ;
294  }
295  }
296 
297  }
298 
299  if (_acceptRejectFunc && _otherVars.getSize()>0) {
301  cxcoutD(Generation) << "RooGenContext::ctor() creating MC sampling generator " << _generator->IsA()->GetName() << " from function for observables " << _otherVars << endl ;
302  //_generator= new RooAcceptReject(*_acceptRejectFunc,_otherVars,RooNumGenConfig::defaultConfig(),_verbose,_maxVar);
303  } else {
304  _generator = 0 ;
305  }
306 
307  delete protoDeps ;
308  delete depList;
310 }
311 
312 
313 ////////////////////////////////////////////////////////////////////////////////
314 /// Destructor.
315 
317 {
318  // Clean up the cloned objects used in this context.
319  delete _cloneSet;
320 
321  // Clean up our accept/reject generator
322  if (_generator) delete _generator;
324  if (_maxVar) delete _maxVar ;
325  if (_uniIter) delete _uniIter ;
326 }
327 
328 
329 
330 ////////////////////////////////////////////////////////////////////////////////
331 /// Attach the cloned model to the event buffer we will be filling.
332 
334 {
336  if (_acceptRejectFunc) {
338  }
339 
340  // Attach the RooAcceptReject generator the event buffer
341  if (_generator) {
343  }
344 
345 }
346 
347 
348 
349 ////////////////////////////////////////////////////////////////////////////////
350 /// Perform one-time initialization of the generator context
351 
353 {
354  RooFIter iter = theEvent.fwdIterator() ;
355  RooAbsArg* arg ;
356  while((arg=iter.next())) {
358  }
359 
360  attach(theEvent) ;
361 
362  // Reset the cloned model's error counters.
364 
365  // Initialize the PDFs internal generator
366  if (_directVars.getSize()>0) {
367  cxcoutD(Generation) << "RooGenContext::initGenerator() initializing internal generator of model with code " << _code << endl ;
369  }
370 
371  // Create iterator for uniform vars (if any)
372  if (_uniformVars.getSize()>0) {
373  delete _uniIter;
375  }
376 }
377 
378 
379 ////////////////////////////////////////////////////////////////////////////////
380 /// Generate one event. The 'remaining' integer is not used other than
381 /// for printing messages
382 
383 void RooGenContext::generateEvent(RooArgSet &theEvent, Int_t remaining)
384 {
385  if(_otherVars.getSize() > 0) {
386  // call the accept-reject generator to generate its variables
387 
388  if (_updateFMaxPerEvent!=0) {
390  cxcoutD(Generation) << "RooGenContext::initGenerator() reevaluation of maximum function value is required for each event, new value is " << max << endl ;
391  _maxVar->setVal(max) ;
392  }
393 
394  if (_generator) {
395  Double_t resampleRatio(1) ;
396  const RooArgSet *subEvent= _generator->generateEvent(remaining,resampleRatio);
397  if (resampleRatio<1) {
398  coutI(Generation) << "RooGenContext::generateEvent INFO: accept/reject generator requests resampling of previously produced events by factor "
399  << resampleRatio << " due to increased maximum weight" << endl ;
400  resampleData(resampleRatio) ;
401  }
402  if(0 == subEvent) {
403  coutE(Generation) << "RooGenContext::generateEvent ERROR accept/reject generator failed" << endl ;
404  return;
405  }
406  theEvent.assignValueOnly(*subEvent) ;
407  //theEvent= *subEvent;
408 
409  }
410  }
411 
412  // Use the model's optimized generator, if one is available.
413  // The generator writes directly into our local 'event' since we attached it above.
414  if(_directVars.getSize() > 0) {
416  }
417 
418  // Generate uniform variables (non-dependents)
419  if (_uniIter) {
420  _uniIter->Reset() ;
421  RooAbsArg* uniVar ;
422  while((uniVar=(RooAbsArg*)_uniIter->Next())) {
423  RooAbsLValue* arglv = dynamic_cast<RooAbsLValue*>(uniVar) ;
424  if (!arglv) {
425  coutE(Generation) << "RooGenContext::generateEvent(" << GetName() << ") ERROR: uniform variable " << uniVar->GetName() << " is not an lvalue" << endl ;
427  }
428  arglv->randomize() ;
429  }
430  theEvent = _uniformVars ;
431  }
432 
433 }
434 
435 
436 ////////////////////////////////////////////////////////////////////////////////
437 /// Printing interface
438 
440 {
442  os << indent << " --- RooGenContext --- " << endl ;
443  os << indent << "Using PDF ";
445 
446  if(verbose) {
447  os << indent << "Use PDF generator for " << _directVars << endl ;
448  os << indent << "Use MC sampling generator " << (_generator ? _generator->IsA()->GetName() : "<none>") << " for " << _otherVars << endl ;
449  if (_protoVars.getSize()>0) {
450  os << indent << "Prototype observables are " << _protoVars << endl ;
451  }
452  }
453 }
RooErrorHandler::softAbort
static void softAbort()
Definition: RooErrorHandler.h:30
RooGenContext::initGenerator
virtual void initGenerator(const RooArgSet &theEvent)
Perform one-time initialization of the generator context.
Definition: RooGenContext.cxx:352
RooAbsArg::serverIterator
TIterator * serverIterator() const
Definition: RooAbsArg.h:140
RooAbsArg::ADirty
@ ADirty
Definition: RooAbsArg.h:390
RooRealVar::setVal
virtual void setVal(Double_t value)
Set value of variable to 'value'.
Definition: RooRealVar.cxx:257
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:100
RooGenContext::_maxVar
RooRealVar * _maxVar
Definition: RooGenContext.h:52
RooMsgService.h
RooAbsPdf::generateEvent
virtual void generateEvent(Int_t code)
Interface for generation of an event using the algorithm corresponding to the specified code.
Definition: RooAbsPdf.cxx:2493
RooFit.h
RooAbsGenContext::_theEvent
RooArgSet * _theEvent
Definition: RooAbsGenContext.h:78
RooAbsReal::createIntegral
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:548
RooGenContext::_pdfClone
RooAbsPdf * _pdfClone
Definition: RooGenContext.h:46
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
RooAbsCollection::assignValueOnly
RooAbsCollection & assignValueOnly(const RooAbsCollection &other, Bool_t oneSafe=kFALSE)
The assignment operator sets the value of any argument in our set that also appears in the other set.
Definition: RooAbsCollection.cxx:344
RooAbsCollection::fwdIterator
RooFIter fwdIterator() const
One-time forward iterator.
Definition: RooAbsCollection.h:193
coutE
#define coutE(a)
Definition: RooMsgService.h:33
RooGenContext
Class RooGenContext implement a universal generator context for all RooAbsPdf classes that do not hav...
Definition: RooGenContext.h:30
RooAbsGenContext::_isValid
Bool_t _isValid
Definition: RooAbsGenContext.h:79
RooAbsReal::getVal
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:91
RooNumGenFactory.h
RooGenContext::attach
virtual void attach(const RooArgSet &params)
Attach the cloned model to the event buffer we will be filling.
Definition: RooGenContext.cxx:333
RooAbsCollection::remove
virtual Bool_t remove(const RooAbsArg &var, Bool_t silent=kFALSE, Bool_t matchByNameOnly=kFALSE)
Remove the specified argument from our list.
Definition: RooAbsCollection.cxx:585
RooAbsCollection::find
RooAbsArg * find(const char *name) const
Find object with given name in list.
Definition: RooAbsCollection.cxx:810
RooAbsArg::setOperMode
void setOperMode(OperMode mode, Bool_t recurseADirty=kTRUE)
Set the operation mode of this node.
Definition: RooAbsArg.cxx:1817
RooAbsPdf::getGenerator
virtual Int_t getGenerator(const RooArgSet &directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const
Load generatedVars with the subset of directVars that we can generate events for, and return a code t...
Definition: RooAbsPdf.cxx:2471
coutI
#define coutI(a)
Definition: RooMsgService.h:30
TClass.h
indent
static void indent(ostringstream &buf, int indent_level)
Definition: TClingCallFunc.cxx:87
RooAbsGenContext::resampleData
void resampleData(Double_t &ratio)
Rescale existing output buffer with given ratio.
Definition: RooAbsGenContext.cxx:373
RooGenContext::_cloneSet
RooArgSet * _cloneSet
Definition: RooGenContext.h:45
RooAbsPdf::initGenerator
virtual void initGenerator(Int_t code)
Interface for one-time initialization to setup the generator for the specified code.
Definition: RooAbsPdf.cxx:2481
RooAbsArg::recursiveRedirectServers
Bool_t recursiveRedirectServers(const RooAbsCollection &newServerList, Bool_t mustReplaceAll=kFALSE, Bool_t nameChange=kFALSE, Bool_t recurseInNewSet=kTRUE)
Recursively replace all servers with the new servers in newSet.
Definition: RooAbsArg.cxx:1159
TString
Basic string class.
Definition: TString.h:136
RooDataSet.h
RooAbsReal::fixAddCoefNormalization
virtual void fixAddCoefNormalization(const RooArgSet &addNormSet=RooArgSet(), Bool_t force=kTRUE)
Fix the interpretation of the coefficient of any RooAddPdf component in the expression tree headed by...
Definition: RooAbsReal.cxx:3895
RooAbsPdf::isDirectGenSafe
virtual Bool_t isDirectGenSafe(const RooAbsArg &arg) const
Check if given observable can be safely generated using the pdfs internal generator mechanism (if tha...
Definition: RooAbsPdf.cxx:2506
TString.h
RooGenContext::generateEvent
virtual void generateEvent(RooArgSet &theEvent, Int_t remaining)
Generate one event.
Definition: RooGenContext.cxx:383
bool
TIterator
Iterator abstract base class.
Definition: TIterator.h:30
RooDataSet::get
virtual const RooArgSet * get(Int_t index) const override
Return RooArgSet with coordinates of event 'index'.
Definition: RooDataSet.cxx:1056
RooAbsNumGenerator::generateEvent
virtual const RooArgSet * generateEvent(UInt_t remaining, Double_t &resampleRatio)=0
RooRealIntegral
RooRealIntegral performs hybrid numerical/analytical integrals of RooAbsReal objects.
Definition: RooRealIntegral.h:34
RooAbsGenContext::printMultiline
virtual void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const
Interface for multi-line printing.
Definition: RooAbsGenContext.cxx:335
RooArgSet::snapshot
RooArgSet * snapshot(bool deepCopy=true) const
Use RooAbsCollection::snapshot(), but return as RooArgSet.
Definition: RooArgSet.h:115
RooPrintable::kName
@ kName
Definition: RooPrintable.h:33
RooAcceptReject.h
RooAbsPdf::getNorm
Double_t getNorm(const RooArgSet &nset) const
Get normalisation term needed to normalise the raw values returned by getVal().
Definition: RooAbsPdf.h:209
RooAbsGenContext::_verbose
Bool_t _verbose
Definition: RooAbsGenContext.h:80
RooAbsPdf.h
RooNumGenFactory::createSampler
RooAbsNumGenerator * createSampler(RooAbsReal &func, const RooArgSet &genVars, const RooArgSet &condVars, const RooNumGenConfig &config, Bool_t verbose=kFALSE, RooAbsReal *maxFuncVal=0)
Construct a numeric integrator instance that operates on function 'func' and is configured with 'conf...
Definition: RooNumGenFactory.cxx:163
RooAbsLValue::randomize
virtual void randomize(const char *rangeName=0)=0
TIterator.h
RooAbsGenContext::isValid
Bool_t isValid() const
Definition: RooAbsGenContext.h:34
RooFIter
A one-time forward iterator working on RooLinkedList or RooAbsCollection.
Definition: RooLinkedListIter.h:40
RooFit::Generation
@ Generation
Definition: RooGlobalFunc.h:60
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:101
TString::Append
TString & Append(const char *cs)
Definition: TString.h:564
RooDataHist.h
RooAbsCollection::createIterator
TIterator * createIterator(Bool_t dir=kIterForward) const
TIterator-style iteration over contained elements.
Definition: RooAbsCollection.h:178
RooAbsNumGenerator
Class RooAbsNumGenerator is the abstract base class for MC event generator implementations like RooAc...
Definition: RooAbsNumGenerator.h:30
RooFIter::next
RooAbsArg * next()
Return next element or nullptr if at end.
Definition: RooLinkedListIter.h:49
RooPrintable::kArgs
@ kArgs
Definition: RooPrintable.h:33
RooAbsReal::getMaxVal
virtual Int_t getMaxVal(const RooArgSet &vars) const
Advertise capability to determine maximum value of function for given set of observables.
Definition: RooAbsReal.cxx:3633
RooAbsGenContext
RooAbsGenContext is the abstract base class for generator contexts of RooAbsPdf objects.
Definition: RooAbsGenContext.h:26
RooAbsCollection::add
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
Definition: RooAbsCollection.cxx:455
RooGenContext::_uniIter
TIterator * _uniIter
Definition: RooGenContext.h:53
RooGenContext.h
RooAbsGenContext::_protoVars
RooArgSet _protoVars
Definition: RooAbsGenContext.h:82
RooRealVar.h
TIterator::Next
virtual TObject * Next()=0
RooAbsArg::isFundamental
virtual Bool_t isFundamental() const
Is this object a fundamental type that can be added to a dataset? Fundamental-type subclasses overrid...
Definition: RooAbsArg.h:243
RooAbsReal::maxVal
virtual Double_t maxVal(Int_t code) const
Return maximum value for set of observables identified by code assigned in getMaxVal.
Definition: RooAbsReal.cxx:3644
TIterator::Reset
virtual void Reset()=0
RooPrintable::kClassName
@ kClassName
Definition: RooPrintable.h:33
RooAbsNumGenerator::getFuncMax
virtual Double_t getFuncMax()
Definition: RooAbsNumGenerator.h:53
Double_t
double Double_t
Definition: RtypesCore.h:59
RooAbsArg::getObservables
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
RooNumGenFactory::instance
static RooNumGenFactory & instance()
Static method returning reference to singleton instance of factory.
Definition: RooNumGenFactory.cxx:108
RooGenContext::_otherVars
RooArgSet _otherVars
Definition: RooGenContext.h:47
RooGenContext::_updateFMaxPerEvent
Int_t _updateFMaxPerEvent
Definition: RooGenContext.h:54
RooGenContext::_generator
RooAbsNumGenerator * _generator
Definition: RooGenContext.h:51
RooGenContext::_uniformVars
RooArgSet _uniformVars
Definition: RooGenContext.h:47
RooNumGenConfig.h
RooAbsArg::dependsOn
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:799
RooGenContext::_directVars
RooArgSet _directVars
Definition: RooGenContext.h:47
RooPrintable::printStream
virtual void printStream(std::ostream &os, Int_t contents, StyleOption style, TString indent="") const
Print description of object on ostream, printing contents set by contents integer,...
Definition: RooPrintable.cxx:75
genreflex::verbose
bool verbose
Definition: rootcling_impl.cxx:133
RooPrintable::kSingleLine
@ kSingleLine
Definition: RooPrintable.h:34
RooGenContext::_code
Int_t _code
Definition: RooGenContext.h:48
RooErrorHandler.h
RooDataSet
RooDataSet is a container class to hold unbinned data.
Definition: RooDataSet.h:33
make_cnn_model.model
model
Definition: make_cnn_model.py:6
RooAbsArg
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooRealIntegral.h
RooAbsPdf
Definition: RooAbsPdf.h:41
RooAbsLValue
Abstract base class for objects that are lvalues, i.e.
Definition: RooAbsLValue.h:26
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
RooRealVar
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:39
RooAbsCollection::removeAll
virtual void removeAll()
Remove all arguments from our set, deleting them if we own them.
Definition: RooAbsCollection.cxx:644
Riostream.h
RooGenContext::_acceptRejectFunc
RooRealIntegral * _acceptRejectFunc
Definition: RooGenContext.h:50
RooGenContext::~RooGenContext
virtual ~RooGenContext()
Destructor.
Definition: RooGenContext.cxx:316
cxcoutI
#define cxcoutI(a)
Definition: RooMsgService.h:85
RooAbsNumGenerator::attachParameters
void attachParameters(const RooArgSet &vars)
Reattach original parameters to function clone.
Definition: RooAbsNumGenerator.cxx:168
RooGenContext::RooGenContext
RooGenContext(const RooAbsPdf &model, const RooArgSet &vars, const RooDataSet *prototype=0, const RooArgSet *auxProto=0, Bool_t verbose=kFALSE, const RooArgSet *forceDirect=0)
Initialize a new context for generating events with the specified variables, using the specified PDF ...
Definition: RooGenContext.cxx:69
RooAbsPdf::resetErrorCounters
virtual void resetErrorCounters(Int_t resetValue=10)
Reset error counter to given value, limiting the number of future error messages for this pdf to 'res...
Definition: RooAbsPdf.cxx:623
RooGenContext::printMultiline
virtual void printMultiline(std::ostream &os, Int_t content, Bool_t verbose=kFALSE, TString indent="") const
Printing interface.
Definition: RooGenContext.cxx:439
RooAbsCollection::getSize
Int_t getSize() const
Definition: RooAbsCollection.h:231
RooArgSet
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:33
cxcoutD
#define cxcoutD(a)
Definition: RooMsgService.h:81
ccxcoutI
#define ccxcoutI(a)
Definition: RooMsgService.h:86
int