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 
22 RooGenericPdf is a concrete implementation of a probability density function,
23 which takes a RooArgList of servers and a C++ expression string defining how
24 its value should be calculated from the given list of servers.
25 A fully numerical integration is automatically performed to normalize the given
26 expression. RooGenericPdf uses a RooFormula object to perform the expression evaluation.
27 
28 The string expression can be any valid TFormula expression referring to the
29 listed servers either by name or by their ordinal list position. These three are
30 equivalent:
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 ```
36 Note that `x[i]` is an expression reserved for TFormula. All variable references
37 are automatically converted to the TFormula-native format. If a variable with
38 the name `x` is given, the RooFormula interprets `x[i]` as a list position,
39 but `x` without brackets as the name of a RooFit object.
40 
41 The last two versions, while slightly less readable, are more versatile because
42 the 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 
56 using namespace std;
57 
59 
60 
61 
62 ////////////////////////////////////////////////////////////////////////////////
63 /// Constructor with formula expression and list of input variables
64 
65 RooGenericPdf::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 
81 RooGenericPdf::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 
98 RooGenericPdf::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 
145 Bool_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 
159 Bool_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 
169 Bool_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 
199 void RooGenericPdf::printMetaArgs(ostream& os) const
200 {
201  os << "formula=\"" << _formExpr << "\" " ;
202 }
203 
204 
205 
206 ////////////////////////////////////////////////////////////////////////////////
207 /// Read object contents from given stream
208 
209 Bool_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 
224 void 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 
RooStreamParser.h
RooAbsPdf::_normSet
RooArgSet * _normSet
Normalization integral (owned by _normMgr)
Definition: RooAbsPdf.h:325
RooFormula
RooFormula internally uses ROOT's TFormula to compute user-defined expressions of RooAbsArgs.
Definition: RooFormula.h:34
RooGenericPdf::_actualVars
RooListProxy _actualVars
Definition: RooGenericPdf.h:50
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:100
RooMsgService.h
RooGenericPdf::evaluate
virtual Double_t evaluate() const
Calculate current value of this object.
Definition: RooGenericPdf.cxx:124
RooFit.h
RooFit::InputArguments
@ InputArguments
Definition: RooGlobalFunc.h:61
TString::Data
const char * Data() const
Definition: TString.h:369
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
coutE
#define coutE(a)
Definition: RooMsgService.h:33
RooArgList
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:21
RooGenericPdf::writeToStream
virtual void writeToStream(std::ostream &os, Bool_t compact) const
Write object contents to given stream.
Definition: RooGenericPdf.cxx:224
RooAbsReal::getVal
Double_t getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition: RooAbsReal.h:91
RooGenericPdf::formula
RooFormula & formula() const
Definition: RooGenericPdf.cxx:109
RooAbsPdf::printMultiline
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:2039
RooGenericPdf::_formExpr
TString _formExpr
Formula engine.
Definition: RooGenericPdf.h:62
RooGenericPdf::printMetaArgs
void printMetaArgs(std::ostream &os) const
Add formula expression as meta argument in printing interface.
Definition: RooGenericPdf.cxx:199
indent
static void indent(ostringstream &buf, int indent_level)
Definition: TClingCallFunc.cxx:87
TString
Basic string class.
Definition: TString.h:136
RooGenericPdf.h
RooGenericPdf::printMultiline
void printMultiline(std::ostream &os, Int_t content, Bool_t verbose=kFALSE, TString indent="") const
Print info about this object to the specified stream.
Definition: RooGenericPdf.cxx:183
RooGenericPdf::readFromStream
virtual Bool_t readFromStream(std::istream &is, Bool_t compact, Bool_t verbose=kFALSE)
Read object contents from given stream.
Definition: RooGenericPdf.cxx:209
bool
RooStreamParser
Definition: RooStreamParser.h:21
Double_t
RooGenericPdf::evaluateSpan
RooSpan< double > evaluateSpan(RooBatchCompute::RunContext &inputData, const RooArgSet *normSet) const
Evaluate this formula for values found in inputData.
Definition: RooGenericPdf.cxx:132
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:101
RooGenericPdf::setFormula
Bool_t setFormula(const char *formula)
Change formula expression to given expression.
Definition: RooGenericPdf.cxx:145
RooAbsCollection
RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects.
Definition: RooAbsCollection.h:33
RooGenericPdf::RooGenericPdf
RooGenericPdf()
Definition: RooGenericPdf.h:28
RooFormula::evaluateSpan
RooSpan< double > evaluateSpan(const RooAbsReal *dataOwner, RooBatchCompute::RunContext &inputData, const RooArgSet *nset=nullptr) const
Definition: RooFormula.cxx:368
RooAbsReal::_value
Double_t _value
Definition: RooAbsReal.h:477
RooGenericPdf::redirectServersHook
virtual Bool_t redirectServersHook(const RooAbsCollection &newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive)
Propagate server changes to embedded formula object.
Definition: RooGenericPdf.cxx:169
RooStreamParser::readLine
TString readLine()
Read an entire line from the stream and return as TString This method recognizes the use of '\' in th...
Definition: RooStreamParser.cxx:309
RooAbsReal::traceEval
Double_t traceEval(const RooArgSet *set) const
Calculate current value of object, with error tracing wrapper.
Definition: RooAbsReal.cxx:354
RooGenericPdf
RooGenericPdf is a concrete implementation of a probability density function, which takes a RooArgLis...
Definition: RooGenericPdf.h:25
name
char name[80]
Definition: TGX11.cxx:110
RooGenericPdf::isValidReal
virtual Bool_t isValidReal(Double_t value, Bool_t printError) const
Check if given value is valid.
Definition: RooGenericPdf.cxx:159
genreflex::verbose
bool verbose
Definition: rootcling_impl.cxx:133
RunContext.h
RooFormula::printMultiline
void printMultiline(std::ostream &os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const
Printing interface.
Definition: RooFormula.cxx:414
RooListProxy::add
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE) override
Reimplementation of standard RooArgList::add()
Definition: RooListProxy.cxx:104
RooAbsArg::setValueDirty
void setValueDirty()
Mark the element dirty. This forces a re-evaluation when a value is requested.
Definition: RooAbsArg.h:490
RooAbsPdf
Definition: RooAbsPdf.h:41
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
Riostream.h
RooFormula::eval
Double_t eval(const RooArgSet *nset=0) const
Evalute all parameters/observables, and then evaluate formula.
Definition: RooFormula.cxx:342
RooArgList.h
RooBatchCompute::RunContext::spans
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
RooBatchCompute::RunContext
This struct enables passing computation data around between elements of a computation graph.
Definition: RunContext.h:31
RooAbsCollection::getSize
Int_t getSize() const
Definition: RooAbsCollection.h:231
RooSpan
A simple container to hold a batch of data values.
Definition: RooSpan.h:34
RooArgSet
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:33
int
RooGenericPdf::_formula
std::unique_ptr< RooFormula > _formula
Definition: RooGenericPdf.h:61