Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooAddition.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 RooAddition.cxx
19\class RooAddition
20\ingroup Roofitcore
21
22Calculates the sum of a set of RooAbsReal terms, or
23when constructed with two sets, it sums the product of the terms
24in the two sets.
25**/
26
27
28#include "Riostream.h"
29#include "RooAddition.h"
30#include "RooRealSumFunc.h"
31#include "RooRealSumPdf.h"
32#include "RooProduct.h"
33#include "RooErrorHandler.h"
34#include "RooArgSet.h"
35#include "RooNameReg.h"
36#include "RooNLLVarNew.h"
37#include "RooMsgService.h"
38#include "RooBatchCompute.h"
39
40#ifdef ROOFIT_LEGACY_EVAL_BACKEND
41#include "RooNLLVar.h"
42#include "RooChi2Var.h"
43#endif
44
45#include <algorithm>
46#include <cmath>
47
49
50
51////////////////////////////////////////////////////////////////////////////////
52/// Constructor with a single set consisting of RooAbsReal.
53/// \param[in] name Name of the PDF
54/// \param[in] title Title
55/// \param[in] sumSet The value of the function will be the sum of the values in this set
56/// \param[in] takeOwnership If true, the RooAddition object will take ownership of the arguments in `sumSet`
57
58RooAddition::RooAddition(const char *name, const char *title, const RooArgList &sumSet)
59 : RooAbsReal(name, title), _set("!set", "set of components", this), _cacheMgr(this, 10)
60{
61 _set.addTyped<RooAbsReal>(sumSet);
62}
63
64
65
66////////////////////////////////////////////////////////////////////////////////
67/// Constructor with two sets of RooAbsReals.
68///
69/// The sum of pair-wise products of elements in the sets will be computed:
70/// \f[
71/// A = \sum_i \mathrm{Set1}[i] * \mathrm{Set2}[i]
72/// \f]
73///
74/// \param[in] name Name of the PDF
75/// \param[in] title Title
76/// \param[in] sumSet1 Left-hand element of the pair-wise products
77/// \param[in] sumSet2 Right-hand element of the pair-wise products
78/// \param[in] takeOwnership If true, the RooAddition object will take ownership of the arguments in the `sumSets`
79///
80RooAddition::RooAddition(const char *name, const char *title, const RooArgList &sumSet1, const RooArgList &sumSet2)
81 : RooAbsReal(name, title), _set("!set", "set of components", this), _cacheMgr(this, 10)
82{
83 if (sumSet1.size() != sumSet2.size()) {
84 coutE(InputArguments) << "RooAddition::ctor(" << GetName() << ") ERROR: input lists should be of equal length" << std::endl;
86 }
87
88 for (unsigned int i = 0; i < sumSet1.size(); ++i) {
89 const auto comp1 = &sumSet1[i];
90 const auto comp2 = &sumSet2[i];
91
92 if (!dynamic_cast<RooAbsReal*>(comp1)) {
93 coutE(InputArguments) << "RooAddition::ctor(" << GetName() << ") ERROR: component " << comp1->GetName()
94 << " in first list is not of type RooAbsReal" << std::endl;
96 }
97
98 if (!dynamic_cast<RooAbsReal*>(comp2)) {
99 coutE(InputArguments) << "RooAddition::ctor(" << GetName() << ") ERROR: component " << comp2->GetName()
100 << " in first list is not of type RooAbsReal" << std::endl;
102 }
103 TString _name(name);
104 _name.Append( "_[");
105 _name.Append(comp1->GetName());
106 _name.Append( "_x_");
107 _name.Append(comp2->GetName());
108 _name.Append( "]");
109 auto prod = std::make_unique<RooProduct>( _name, _name , RooArgSet(*comp1, *comp2));
110 _set.add(*prod);
111 _ownedList.addOwned(std::move(prod));
112 }
113}
114
115
116
117////////////////////////////////////////////////////////////////////////////////
118/// Copy constructor
119
120RooAddition::RooAddition(const RooAddition& other, const char* name)
121 : RooAbsReal(other, name)
122 , _set("!set",this,other._set)
123 , _cacheMgr(other._cacheMgr,this)
124{
125 // Member _ownedList is intentionally not copy-constructed -- ownership is not transferred
126}
127
128////////////////////////////////////////////////////////////////////////////////
129/// Calculate and return current value of self
130
132{
133 double sum(0);
134 const RooArgSet* nset = _set.nset() ;
135
136 for (auto* comp : static_range_cast<RooAbsReal*>(_set)) {
137 const double tmp = comp->getVal(nset);
138 sum += tmp ;
139 }
140 return sum ;
141}
142
143
144////////////////////////////////////////////////////////////////////////////////
145/// Compute addition of PDFs in batches.
146void RooAddition::computeBatch(double* output, size_t nEvents, RooFit::Detail::DataMap const& dataMap) const
147{
150 pdfs.reserve(_set.size());
151 coefs.reserve(_set.size());
152 for (const auto arg : _set)
153 {
154 pdfs.push_back(dataMap.at(arg));
155 coefs.push_back(1.0);
156 }
157 RooBatchCompute::compute(dataMap.config(this), RooBatchCompute::AddPdf, output, nEvents, pdfs, coefs);
158}
159
160////////////////////////////////////////////////////////////////////////////////
161
163{
164 // If the number of elements to sum is less than 3, just build a sum expression.
165 // else build a loop to sum over the values.
166 unsigned int eleSize = _set.size();
167 std::string result;
168 if (eleSize > 3) {
169 std::string className = GetName();
170 std::string varName = "elements" + className;
171 std::string sumName = "sum" + className;
172 std::string code;
173 std::string decl = "double " + varName + "[" + std::to_string(eleSize) + "]{";
174 int idx = 0;
175 for (RooAbsArg *it : _set) {
176 decl += ctx.getResult(*it) + ",";
177 ctx.addResult(it, varName + "[" + std::to_string(idx) + "]");
178 idx++;
179 }
180 decl.back() = '}';
181 code += decl + ";\n";
182
183 ctx.addToGlobalScope("double " + sumName + " = 0;\n");
184 std::string iterator = "i_" + className;
185 code += "for(int " + iterator + " = 0; " + iterator + " < " + std::to_string(eleSize) + "; " + iterator +
186 "++) {\n" + sumName + " += " + varName + "[" + iterator + "];\n}\n";
187 result = sumName;
188 ctx.addResult(this, result);
189
190 ctx.addToCodeBody(this, code);
191 }
192
193 result = "(";
194 for (RooAbsArg *it : _set) {
195 result += ctx.getResult(*it) + '+';
196 }
197 result.back() = ')';
198 ctx.addResult(this, result);
199}
200
201////////////////////////////////////////////////////////////////////////////////
202/// Return the default error level for MINUIT error analysis
203/// If the addition contains one or more RooNLLVars and
204/// no RooChi2Vars, return the defaultErrorLevel() of
205/// RooNLLVar. If the addition contains one ore more RooChi2Vars
206/// and no RooNLLVars, return the defaultErrorLevel() of
207/// RooChi2Var. If the addition contains neither or both
208/// issue a warning message and return a value of 1
209
211{
212 RooAbsReal* nllArg(nullptr) ;
213 RooAbsReal* chi2Arg(nullptr) ;
214
215 std::unique_ptr<RooArgSet> comps{getComponents()};
216 for(RooAbsArg * arg : *comps) {
217 if (dynamic_cast<RooNLLVarNew*>(arg)) {
218 nllArg = static_cast<RooAbsReal*>(arg) ;
219 }
220#ifdef ROOFIT_LEGACY_EVAL_BACKEND
221 if (dynamic_cast<RooNLLVar*>(arg)) {
222 nllArg = static_cast<RooAbsReal*>(arg) ;
223 }
224 if (dynamic_cast<RooChi2Var*>(arg)) {
225 chi2Arg = static_cast<RooAbsReal*>(arg) ;
226 }
227#endif
228 }
229
230 if (nllArg && !chi2Arg) {
231 coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName()
232 << ") Summation contains a RooNLLVar, using its error level" << std::endl;
233 return nllArg->defaultErrorLevel() ;
234 } else if (chi2Arg && !nllArg) {
235 coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName()
236 << ") Summation contains a RooChi2Var, using its error level" << std::endl;
237 return chi2Arg->defaultErrorLevel() ;
238 } else if (!nllArg && !chi2Arg) {
239 coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName() << ") WARNING: "
240 << "Summation contains neither RooNLLVar nor RooChi2Var server, using default level of 1.0" << std::endl;
241 } else {
242 coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName() << ") WARNING: "
243 << "Summation contains BOTH RooNLLVar and RooChi2Var server, using default level of 1.0" << std::endl;
244 }
245
246 return 1.0 ;
247}
248
249
250
251////////////////////////////////////////////////////////////////////////////////
252
254{
255 for (const auto arg : _set) {
256 static_cast<RooAbsReal*>(arg)->setData(data,cloneData) ;
257 }
258 return true ;
259}
260
261
262
263////////////////////////////////////////////////////////////////////////////////
264
265void RooAddition::printMetaArgs(std::ostream& os) const
266{
267 // We can use the implementation of RooRealSumPdf with an empty coefficient list.
268 static const RooArgList coefs{};
270}
271
272////////////////////////////////////////////////////////////////////////////////
273
274Int_t RooAddition::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* rangeName) const
275{
276 // we always do things ourselves -- actually, always delegate further down the line ;-)
277 analVars.add(allVars);
278
279 // check if we already have integrals for this combination of factors
280 Int_t sterileIndex(-1);
281 CacheElem* cache = static_cast<CacheElem*>(_cacheMgr.getObj(&analVars,&analVars,&sterileIndex,RooNameReg::ptr(rangeName)));
282 if (cache!=nullptr) {
283 Int_t code = _cacheMgr.lastIndex();
284 return code+1;
285 }
286
287 // we don't, so we make it right here....
288 cache = new CacheElem;
289 for (auto *arg : static_range_cast<RooAbsReal const*>(_set)) {// checked in c'tor that this will work...
290 cache->_I.addOwned(std::unique_ptr<RooAbsReal>{arg->createIntegral(analVars,rangeName)});
291 }
292
293 Int_t code = _cacheMgr.setObj(&analVars,&analVars,(RooAbsCacheElement*)cache,RooNameReg::ptr(rangeName));
294 return 1+code;
295}
296
297////////////////////////////////////////////////////////////////////////////////
298/// Calculate integral internally from appropriate integral cache
299
300double RooAddition::analyticalIntegral(Int_t code, const char* rangeName) const
301{
302 // note: rangeName implicit encoded in code: see _cacheMgr.setObj in getPartIntList...
303 CacheElem *cache = static_cast<CacheElem*>(_cacheMgr.getObjByIndex(code-1));
304 if (cache==nullptr) {
305 // cache got sterilized, trigger repopulation of this slot, then try again...
306 std::unique_ptr<RooArgSet> vars( getParameters(RooArgSet()) );
307 RooArgSet iset = _cacheMgr.selectFromSet2(*vars, code-1);
308 RooArgSet dummy;
309 Int_t code2 = getAnalyticalIntegral(iset,dummy,rangeName);
310 assert(code==code2); // must have revived the right (sterilized) slot...
311 return analyticalIntegral(code2,rangeName);
312 }
313 assert(cache!=nullptr);
314
315 // loop over cache, and sum...
316 double result(0);
317 for (auto I : cache->_I) {
318 result += static_cast<const RooAbsReal*>(I)->getVal();
319 }
320 return result;
321
322}
323
324
325////////////////////////////////////////////////////////////////////////////////
326
327std::list<double>* RooAddition::binBoundaries(RooAbsRealLValue& obs, double xlo, double xhi) const
328{
329 return RooRealSumPdf::binBoundaries(_set, obs, xlo, xhi);
330}
331
332
334{
336}
337
338
339////////////////////////////////////////////////////////////////////////////////
340
341std::list<double>* RooAddition::plotSamplingHint(RooAbsRealLValue& obs, double xlo, double xhi) const
342{
343 return RooRealSumPdf::plotSamplingHint(_set, obs, xlo, xhi);
344}
#define coutI(a)
#define coutE(a)
#define ClassImp(name)
Definition Rtypes.h:377
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
char name[80]
Definition TGX11.cxx:110
Common abstract base class for objects that represent a value and a "shape" in RooFit.
Definition RooAbsArg.h:77
RooFit::OwningPtr< 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...
RooFit::OwningPtr< RooArgSet > getComponents() const
Create a RooArgSet with all components (branch nodes) of the expression tree headed by this object.
Abstract base class for objects to be stored in RooAbsCache cache manager objects.
const char * GetName() const override
Returns name of object.
virtual bool add(const RooAbsArg &var, bool silent=false)
Add the specified argument to list.
Storage_t::size_type size() const
bool addTyped(const RooAbsCollection &list, bool silent=false)
Adds elements of a given RooAbsCollection to the container if they match the specified type.
virtual bool addOwned(RooAbsArg &var, bool silent=false)
Add an argument and transfer the ownership to the collection.
Abstract base class for binned and unbinned datasets.
Definition RooAbsData.h:57
const RooArgSet * nset() const
Definition RooAbsProxy.h:52
Abstract base class for objects that represent a real value that may appear on the left hand side of ...
Abstract base class for objects that represent a real value and implements functionality common to al...
Definition RooAbsReal.h:59
double getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition RooAbsReal.h:103
virtual double defaultErrorLevel() const
Definition RooAbsReal.h:248
Calculates the sum of a set of RooAbsReal terms, or when constructed with two sets,...
Definition RooAddition.h:27
RooArgList _ownedList
List of owned components.
Definition RooAddition.h:63
Int_t getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &numVars, const char *rangeName=nullptr) const override
Interface function getAnalyticalIntergral advertises the analytical integrals that are supported.
void computeBatch(double *output, size_t nEvents, RooFit::Detail::DataMap const &) const override
Compute addition of PDFs in batches.
std::list< double > * binBoundaries(RooAbsRealLValue &, double, double) const override
Retrieve bin boundaries if this distribution is binned in obs.
RooListProxy _set
set of terms to be summed
Definition RooAddition.h:64
void printMetaArgs(std::ostream &os) const override
bool setData(RooAbsData &data, bool cloneData=true) override
double analyticalIntegral(Int_t code, const char *rangeName=nullptr) const override
Calculate integral internally from appropriate integral cache.
RooObjCacheManager _cacheMgr
! The cache manager
Definition RooAddition.h:72
double defaultErrorLevel() const override
Return the default error level for MINUIT error analysis If the addition contains one or more RooNLLV...
double evaluate() const override
Calculate and return current value of self.
std::list< double > * plotSamplingHint(RooAbsRealLValue &, double, double) const override
Interface for returning an optional hint for initial sampling points when constructing a curve projec...
bool isBinnedDistribution(const RooArgSet &obs) const override
Tests if the distribution is binned. Unless overridden by derived classes, this always returns false.
void translate(RooFit::Detail::CodeSquashContext &ctx) const override
This function defines a translation for each RooAbsReal based object that can be used to express the ...
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:55
Int_t setObj(const RooArgSet *nset, T *obj, const TNamed *isetRangeName=nullptr)
Setter function without integration set.
T * getObjByIndex(Int_t index) const
Retrieve payload object by slot index.
RooArgSet selectFromSet2(RooArgSet const &argSet, int index) const
Create RooArgSet containing the objects that are both in the cached set 2 with a given index and an i...
Int_t lastIndex() const
Return index of slot used in last get or set operation.
T * getObj(const RooArgSet *nset, Int_t *sterileIndex=nullptr, const TNamed *isetRangeName=nullptr)
Getter function without integration set.
Simple calculation from a binned dataset and a PDF.
Definition RooChi2Var.h:50
bool add(const RooAbsArg &var, bool valueServer, bool shapeServer, bool silent)
Overloaded RooCollection_t::add() method insert object into set and registers object as server to own...
static void softAbort()
Soft abort function that interrupts macro execution but doesn't kill ROOT.
A class to maintain the context for squashing of RooFit models into code.
void addResult(RooAbsArg const *key, std::string const &value)
A function to save an expression that includes/depends on the result of the input node.
void addToCodeBody(RooAbsArg const *klass, std::string const &in)
Adds the input string to the squashed code body.
std::string const & getResult(RooAbsArg const &arg)
Gets the result for the given node using the node name.
void addToGlobalScope(std::string const &str)
Adds the given string to the string block that will be emitted at the top of the squashed function.
RooBatchCompute::Config config(RooAbsArg const *arg) const
Definition DataMap.cxx:40
std::span< const double > at(RooAbsArg const *arg, RooAbsArg const *caller=nullptr)
Definition DataMap.cxx:22
Implements a -log(likelihood) calculation from a dataset and a PDF.
Definition RooNLLVar.h:50
static const TNamed * ptr(const char *stringPtr)
Return a unique TNamed pointer for given C++ string.
std::list< double > * plotSamplingHint(RooAbsRealLValue &, double, double) const override
Interface for returning an optional hint for initial sampling points when constructing a curve projec...
std::list< double > * binBoundaries(RooAbsRealLValue &, double, double) const override
Retrieve bin boundaries if this distribution is binned in obs.
void printMetaArgs(std::ostream &os) const override
Customized printing of arguments of a RooRealSumPdf to more intuitively reflect the contents of the p...
bool isBinnedDistribution(const RooArgSet &obs) const override
Check if all components that depend on obs are binned.
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
Basic string class.
Definition TString.h:139
TString & Append(const char *cs)
Definition TString.h:574
#define I(x, y, z)
std::vector< std::span< const double > > VarVector
std::vector< double > ArgVector
void compute(Config cfg, Computer comp, RestrictArr output, size_t size, const VarVector &vars, ArgVector &extraArgs)
static uint64_t sum(uint64_t i)
Definition Factory.cxx:2345
static void output()