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"
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
57RooAddition::RooAddition(const char *name, const char *title, const RooArgList &sumSet)
58 : RooAbsReal(name, title), _set("!set", "set of components", this), _cacheMgr(this, 10)
59{
60 _set.addTyped<RooAbsReal>(sumSet);
61}
62
63
64
65////////////////////////////////////////////////////////////////////////////////
66/// Constructor with two sets of RooAbsReals.
67///
68/// The sum of pair-wise products of elements in the sets will be computed:
69/// \f[
70/// A = \sum_i \mathrm{Set1}[i] * \mathrm{Set2}[i]
71/// \f]
72///
73/// \param[in] name Name of the PDF
74/// \param[in] title Title
75/// \param[in] sumSet1 Left-hand element of the pair-wise products
76/// \param[in] sumSet2 Right-hand element of the pair-wise products
77///
78RooAddition::RooAddition(const char *name, const char *title, const RooArgList &sumSet1, const RooArgList &sumSet2)
79 : RooAbsReal(name, title), _set("!set", "set of components", this), _cacheMgr(this, 10)
80{
81 if (sumSet1.size() != sumSet2.size()) {
82 coutE(InputArguments) << "RooAddition::ctor(" << GetName() << ") ERROR: input lists should be of equal length" << std::endl;
84 }
85
86 for (unsigned int i = 0; i < sumSet1.size(); ++i) {
87 const auto comp1 = &sumSet1[i];
88 const auto comp2 = &sumSet2[i];
89
90 if (!dynamic_cast<RooAbsReal*>(comp1)) {
91 coutE(InputArguments) << "RooAddition::ctor(" << GetName() << ") ERROR: component " << comp1->GetName()
92 << " in first list is not of type RooAbsReal" << std::endl;
94 }
95
96 if (!dynamic_cast<RooAbsReal*>(comp2)) {
97 coutE(InputArguments) << "RooAddition::ctor(" << GetName() << ") ERROR: component " << comp2->GetName()
98 << " in first list is not of type RooAbsReal" << std::endl;
100 }
101 TString _name(name);
102 _name.Append( "_[");
103 _name.Append(comp1->GetName());
104 _name.Append( "_x_");
105 _name.Append(comp2->GetName());
106 _name.Append( "]");
107 auto prod = std::make_unique<RooProduct>( _name, _name , RooArgSet(*comp1, *comp2));
108 _set.add(*prod);
109 _ownedList.addOwned(std::move(prod));
110 }
111}
112
113
114
115////////////////////////////////////////////////////////////////////////////////
116/// Copy constructor
117
118RooAddition::RooAddition(const RooAddition& other, const char* name)
119 : RooAbsReal(other, name)
120 , _set("!set",this,other._set)
121 , _cacheMgr(other._cacheMgr,this)
122{
123 // Member _ownedList is intentionally not copy-constructed -- ownership is not transferred
124}
125
126////////////////////////////////////////////////////////////////////////////////
127/// Calculate and return current value of self
128
130{
131 double sum(0);
132 const RooArgSet* nset = _set.nset() ;
133
134 for (auto* comp : static_range_cast<RooAbsReal*>(_set)) {
135 const double tmp = comp->getVal(nset);
136 sum += tmp ;
137 }
138 return sum ;
139}
140
141
142////////////////////////////////////////////////////////////////////////////////
143/// Compute addition of PDFs in batches.
145{
146 std::vector<std::span<const double>> pdfs;
147 std::vector<double> coefs;
148 pdfs.reserve(_set.size());
149 coefs.reserve(_set.size());
150 for (const auto arg : _set) {
151 pdfs.push_back(ctx.at(arg));
152 coefs.push_back(1.0);
153 }
154 RooBatchCompute::compute(ctx.config(this), RooBatchCompute::AddPdf, ctx.output(), pdfs, coefs);
155}
156
157////////////////////////////////////////////////////////////////////////////////
158/// Return the default error level for MINUIT error analysis
159/// If the addition contains one or more RooNLLVars and
160/// no RooChi2Vars, return the defaultErrorLevel() of
161/// RooNLLVar. If the addition contains one ore more RooChi2Vars
162/// and no RooNLLVars, return the defaultErrorLevel() of
163/// RooChi2Var. If the addition contains neither or both
164/// issue a warning message and return a value of 1
165
167{
168 RooAbsReal* nllArg(nullptr) ;
169 RooAbsReal* chi2Arg(nullptr) ;
170
171 std::unique_ptr<RooArgSet> comps{getComponents()};
172 for(RooAbsArg * arg : *comps) {
173 if (dynamic_cast<RooFit::Detail::RooNLLVarNew*>(arg)) {
174 nllArg = static_cast<RooAbsReal*>(arg) ;
175 }
176#ifdef ROOFIT_LEGACY_EVAL_BACKEND
177 if (dynamic_cast<RooNLLVar*>(arg)) {
178 nllArg = static_cast<RooAbsReal*>(arg) ;
179 }
180 if (dynamic_cast<RooChi2Var*>(arg)) {
181 chi2Arg = static_cast<RooAbsReal*>(arg) ;
182 }
183#endif
184 }
185
186 if (nllArg && !chi2Arg) {
187 coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName()
188 << ") Summation contains a RooNLLVar, using its error level" << std::endl;
189 return nllArg->defaultErrorLevel() ;
190 } else if (chi2Arg && !nllArg) {
191 coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName()
192 << ") Summation contains a RooChi2Var, using its error level" << std::endl;
193 return chi2Arg->defaultErrorLevel() ;
194 } else if (!nllArg && !chi2Arg) {
195 coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName() << ") WARNING: "
196 << "Summation contains neither RooNLLVar nor RooChi2Var server, using default level of 1.0" << std::endl;
197 } else {
198 coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName() << ") WARNING: "
199 << "Summation contains BOTH RooNLLVar and RooChi2Var server, using default level of 1.0" << std::endl;
200 }
201
202 return 1.0 ;
203}
204
205
206
207////////////////////////////////////////////////////////////////////////////////
208
210{
211 for (const auto arg : _set) {
212 static_cast<RooAbsReal*>(arg)->setData(data,cloneData) ;
213 }
214 return true ;
215}
216
217
218
219////////////////////////////////////////////////////////////////////////////////
220
221void RooAddition::printMetaArgs(std::ostream& os) const
222{
223 // We can use the implementation of RooRealSumPdf with an empty coefficient list.
224 static const RooArgList coefs{};
226}
227
228////////////////////////////////////////////////////////////////////////////////
229
230Int_t RooAddition::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* rangeName) const
231{
232 // we always do things ourselves -- actually, always delegate further down the line ;-)
233 analVars.add(allVars);
234
235 // check if we already have integrals for this combination of factors
236 Int_t sterileIndex(-1);
237 CacheElem* cache = static_cast<CacheElem*>(_cacheMgr.getObj(&analVars,&analVars,&sterileIndex,RooNameReg::ptr(rangeName)));
238 if (cache!=nullptr) {
239 Int_t code = _cacheMgr.lastIndex();
240 return code+1;
241 }
242
243 // we don't, so we make it right here....
244 cache = new CacheElem;
245 for (auto *arg : static_range_cast<RooAbsReal const*>(_set)) {// checked in c'tor that this will work...
246 cache->_I.addOwned(std::unique_ptr<RooAbsReal>{arg->createIntegral(analVars,rangeName)});
247 }
248
249 Int_t code = _cacheMgr.setObj(&analVars,&analVars,(RooAbsCacheElement*)cache,RooNameReg::ptr(rangeName));
250 return 1+code;
251}
252
253////////////////////////////////////////////////////////////////////////////////
254/// Calculate integral internally from appropriate integral cache
255
256double RooAddition::analyticalIntegral(Int_t code, const char* rangeName) const
257{
258 // note: rangeName implicit encoded in code: see _cacheMgr.setObj in getPartIntList...
259 CacheElem *cache = static_cast<CacheElem*>(_cacheMgr.getObjByIndex(code-1));
260 if (cache==nullptr) {
261 // cache got sterilized, trigger repopulation of this slot, then try again...
262 std::unique_ptr<RooArgSet> vars( getParameters(RooArgSet()) );
263 RooArgSet iset = _cacheMgr.selectFromSet2(*vars, code-1);
264 RooArgSet dummy;
265 Int_t code2 = getAnalyticalIntegral(iset,dummy,rangeName);
266 assert(code==code2); // must have revived the right (sterilized) slot...
267 return analyticalIntegral(code2,rangeName);
268 }
269 assert(cache!=nullptr);
270
271 // loop over cache, and sum...
272 double result(0);
273 for (auto I : cache->_I) {
274 result += static_cast<const RooAbsReal*>(I)->getVal();
275 }
276 return result;
277
278}
279
280
281////////////////////////////////////////////////////////////////////////////////
282
283std::list<double>* RooAddition::binBoundaries(RooAbsRealLValue& obs, double xlo, double xhi) const
284{
285 return RooRealSumPdf::binBoundaries(_set, obs, xlo, xhi);
286}
287
288
290{
292}
293
294
295////////////////////////////////////////////////////////////////////////////////
296
297std::list<double>* RooAddition::plotSamplingHint(RooAbsRealLValue& obs, double xlo, double xhi) const
298{
299 return RooRealSumPdf::plotSamplingHint(_set, obs, xlo, xhi);
300}
#define coutI(a)
#define coutE(a)
#define ClassImp(name)
Definition Rtypes.h:382
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:250
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:61
void doEval(RooFit::EvalContext &) const override
Compute addition of PDFs in batches.
Int_t getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &numVars, const char *rangeName=nullptr) const override
Interface function getAnalyticalIntergral advertises the analytical integrals that are supported.
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:62
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:70
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.
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:24
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:19
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.
std::span< const double > at(RooAbsArg const *arg, RooAbsArg const *caller=nullptr)
std::span< double > output()
RooBatchCompute::Config config(RooAbsArg const *arg) const
Implements a -log(likelihood) calculation from a dataset and a PDF.
Definition RooNLLVar.h:20
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:572
#define I(x, y, z)
void compute(Config cfg, Computer comp, std::span< double > output, VarSpan vars, ArgSpan extraArgs={})
static uint64_t sum(uint64_t i)
Definition Factory.cxx:2345