Logo ROOT  
Reference Guide
RooGenericPdf.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 RooGenericPdf.cxx
19\class RooGenericPdf
20\ingroup Roofitcore
21
22RooGenericPdf is a concrete implementation of a probability density function,
23which takes a RooArgList of servers and a C++ expression string defining how
24its value should be calculated from the given list of servers.
25A fully numerical integration is automatically performed to normalize the given
26expression. RooGenericPdf uses a RooFormula object to perform the expression evaluation.
27
28The string expression can be any valid TFormula expression referring to the
29listed servers either by name or by their ordinal list position. These three are
30equivalent:
31```
32 RooFormulaVar("gen", "x*y", RooArgList(x,y)) // reference by name
33 RooFormulaVar("gen", "@0*@1", RooArgList(x,y)) // reference by ordinal with @
34 RooFormulaVar("gen", "x[0]*x[1]", RooArgList(x,y)) // TFormula-builtin reference by ordinal
35```
36Note that `x[i]` is an expression reserved for TFormula. All variable references
37are automatically converted to the TFormula-native format. If a variable with
38the name `x` is given, the RooFormula interprets `x[i]` as a list position,
39but `x` without brackets as the name of a RooFit object.
40
41The last two versions, while slightly less readable, are more versatile because
42the names of the arguments are not hard coded.
43**/
44
45#include "RooFit.h"
46#include "Riostream.h"
47
48#include "RooGenericPdf.h"
49#include "RooStreamParser.h"
50#include "RooMsgService.h"
51#include "RooArgList.h"
52#include "RunContext.h"
53
54
55
56using namespace std;
57
59
60
61
62////////////////////////////////////////////////////////////////////////////////
63/// Constructor with formula expression and list of input variables
64
65RooGenericPdf::RooGenericPdf(const char *name, const char *title, const RooArgList& dependents) :
66 RooAbsPdf(name,title),
67 _actualVars("actualVars","Variables used by PDF expression",this),
68 _formExpr(title)
69{
70 _actualVars.add(dependents) ;
71 formula();
72
73 if (_actualVars.getSize()==0) _value = traceEval(0) ;
74}
75
76
77
78////////////////////////////////////////////////////////////////////////////////
79/// Constructor with a name, title, formula expression and a list of variables
80
81RooGenericPdf::RooGenericPdf(const char *name, const char *title,
82 const char* inFormula, const RooArgList& dependents) :
83 RooAbsPdf(name,title),
84 _actualVars("actualVars","Variables used by PDF expression",this),
85 _formExpr(inFormula)
86{
87 _actualVars.add(dependents) ;
88 formula();
89
90 if (_actualVars.getSize()==0) _value = traceEval(0) ;
91}
92
93
94
95////////////////////////////////////////////////////////////////////////////////
96/// Copy constructor
97
98RooGenericPdf::RooGenericPdf(const RooGenericPdf& other, const char* name) :
99 RooAbsPdf(other, name),
100 _actualVars("actualVars",this,other._actualVars),
101 _formExpr(other._formExpr)
102{
103 formula();
104}
105
106
107////////////////////////////////////////////////////////////////////////////////
108
110{
111 if (!_formula) {
112 const_cast<std::unique_ptr<RooFormula>&>(_formula).reset(
114 const_cast<TString&>(_formExpr) = _formula->formulaString().c_str();
115 }
116 return *_formula ;
117}
118
119
120
121////////////////////////////////////////////////////////////////////////////////
122/// Calculate current value of this object
123
125{
126 return formula().eval(_normSet) ;
127}
128
129
130////////////////////////////////////////////////////////////////////////////////
131/// Evaluate this formula for values found in inputData.
133 if (normSet != nullptr && normSet != _normSet)
134 throw std::logic_error("Got conflicting normSets");
135
136 auto results = formula().evaluateSpan(this, inputData, _normSet);
137 inputData.spans[this] = results;
138
139 return results;
140}
141
142////////////////////////////////////////////////////////////////////////////////
143/// Change formula expression to given expression
144
145Bool_t RooGenericPdf::setFormula(const char* inFormula)
146{
147 if (formula().reCompile(inFormula)) return kTRUE ;
148
149 _formExpr = inFormula ;
150 setValueDirty() ;
151 return kFALSE ;
152}
153
154
155
156////////////////////////////////////////////////////////////////////////////////
157/// Check if given value is valid
158
159Bool_t RooGenericPdf::isValidReal(Double_t /*value*/, Bool_t /*printError*/) const
160{
161 return kTRUE ;
162}
163
164
165
166////////////////////////////////////////////////////////////////////////////////
167/// Propagate server changes to embedded formula object
168
169Bool_t RooGenericPdf::redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t /*isRecursive*/)
170{
171 if (_formula) {
172 return _formula->changeDependents(newServerList,mustReplaceAll,nameChange);
173 } else {
174 return kTRUE ;
175 }
176}
177
178
179
180////////////////////////////////////////////////////////////////////////////////
181/// Print info about this object to the specified stream.
182
184{
186 if (verbose) {
187 os << " --- RooGenericPdf --- " << endl ;
188 indent.Append(" ");
189 os << indent ;
190 formula().printMultiline(os,content,verbose,indent);
191 }
192}
193
194
195
196////////////////////////////////////////////////////////////////////////////////
197/// Add formula expression as meta argument in printing interface
198
199void RooGenericPdf::printMetaArgs(ostream& os) const
200{
201 os << "formula=\"" << _formExpr << "\" " ;
202}
203
204
205
206////////////////////////////////////////////////////////////////////////////////
207/// Read object contents from given stream
208
209Bool_t RooGenericPdf::readFromStream(istream& is, Bool_t compact, Bool_t /*verbose*/)
210{
211 if (compact) {
212 coutE(InputArguments) << "RooGenericPdf::readFromStream(" << GetName() << "): can't read in compact mode" << endl ;
213 return kTRUE ;
214 } else {
215 RooStreamParser parser(is) ;
216 return setFormula(parser.readLine()) ;
217 }
218}
219
220
221////////////////////////////////////////////////////////////////////////////////
222/// Write object contents to given stream
223
224void RooGenericPdf::writeToStream(ostream& os, Bool_t compact) const
225{
226 if (compact) {
227 os << getVal() << endl ;
228 } else {
229 os << GetTitle() ;
230 }
231}
232
233
234
#define coutE(a)
Definition: RooMsgService.h:33
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
void setValueDirty()
Mark the element dirty. This forces a re-evaluation when a value is requested.
Definition: RooAbsArg.h:491
RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects.
Int_t getSize() const
virtual void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const
Print multi line detailed information of this RooAbsPdf.
Definition: RooAbsPdf.cxx:1945
RooArgSet * _normSet
Normalization integral (owned by _normMgr)
Definition: RooAbsPdf.h:353
Double_t traceEval(const RooArgSet *set) const
Calculate current value of object, with error tracing wrapper.
Definition: RooAbsReal.cxx:353
Double_t _value
Definition: RooAbsReal.h:477
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
RooFormula internally uses ROOT's TFormula to compute user-defined expressions of RooAbsArgs.
Definition: RooFormula.h:34
RooSpan< double > evaluateSpan(const RooAbsReal *dataOwner, RooBatchCompute::RunContext &inputData, const RooArgSet *nset=nullptr) const
Definition: RooFormula.cxx:368
Double_t eval(const RooArgSet *nset=0) const
Evalute all parameters/observables, and then evaluate formula.
Definition: RooFormula.cxx:342
void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const
Printing interface.
Definition: RooFormula.cxx:414
RooGenericPdf is a concrete implementation of a probability density function, which takes a RooArgLis...
Definition: RooGenericPdf.h:25
void printMultiline(std::ostream &os, Int_t content, Bool_t verbose=kFALSE, TString indent="") const
Print info about this object to the specified stream.
Bool_t setFormula(const char *formula)
Change formula expression to given expression.
virtual Double_t evaluate() const
Calculate current value of this object.
virtual void writeToStream(std::ostream &os, Bool_t compact) const
Write object contents to given stream.
void printMetaArgs(std::ostream &os) const
Add formula expression as meta argument in printing interface.
RooListProxy _actualVars
Definition: RooGenericPdf.h:50
std::unique_ptr< RooFormula > _formula
Definition: RooGenericPdf.h:61
virtual Bool_t redirectServersHook(const RooAbsCollection &newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive)
Propagate server changes to embedded formula object.
RooSpan< double > evaluateSpan(RooBatchCompute::RunContext &inputData, const RooArgSet *normSet) const
Evaluate this formula for values found in inputData.
virtual Bool_t isValidReal(Double_t value, Bool_t printError) const
Check if given value is valid.
RooFormula & formula() const
TString _formExpr
Formula engine.
Definition: RooGenericPdf.h:62
virtual Bool_t readFromStream(std::istream &is, Bool_t compact, Bool_t verbose=kFALSE)
Read object contents from given stream.
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE) override
Reimplementation of standard RooArgList::add()
A simple container to hold a batch of data values.
Definition: RooSpan.h:34
TString readLine()
Read an entire line from the stream and return as TString This method recognizes the use of '\' in th...
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
Basic string class.
Definition: TString.h:136
const char * Data() const
Definition: TString.h:369
@ InputArguments
Definition: RooGlobalFunc.h:61
This struct enables passing computation data around between elements of a computation graph.
Definition: RunContext.h:31
std::unordered_map< const RooAbsReal *, RooSpan< const double > > spans
Once an object has computed its value(s), the span pointing to the results is registered here.
Definition: RunContext.h:52