Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooAbsArg.h
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * File: $Id: RooAbsArg.h,v 1.93 2007/07/16 21:04:28 wouter Exp $
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#ifndef ROO_ABS_ARG
17#define ROO_ABS_ARG
18
19#include <RooAbsCache.h>
20#include <RooFit/Config.h>
22#include <RooLinkedListIter.h>
23#include <RooNameReg.h>
24#include <RooPrintable.h>
25#include <RooSTLRefCountList.h>
26#include <RooStringView.h>
27
28#include <TNamed.h>
29#include <TObjArray.h>
30#include <TRefArray.h>
31
32#include <iostream>
33#include <limits>
34#include <map>
35#include <memory>
36#include <set>
37#include <string>
38#include <unordered_map>
39
40class TTree;
41class RooArgSet;
44class RooAbsData;
45class RooAbsDataStore;
46class RooAbsProxy;
47class RooArgProxy;
48template <class RooCollection_t>
53class RooWorkspace;
54namespace RooFit {
55namespace Experimental {
56class CodegenContext;
57}
58} // namespace RooFit
59
60class RooRefArray : public TObjArray {
61public:
62 RooRefArray() = default;
65
66protected:
67 ClassDefOverride(RooRefArray, 1) // Helper class for proxy lists
68};
69
70class RooAbsArg;
71/// Print at the prompt
72namespace cling {
73std::string printValue(RooAbsArg *);
74}
75
76class RooAbsArg : public TNamed, public RooPrintable {
77public:
80
81 // Constructors, cloning and assignment
82 RooAbsArg();
83 ~RooAbsArg() override;
84 RooAbsArg(const char *name, const char *title);
85 RooAbsArg(const RooAbsArg &other, const char *name = nullptr);
87 virtual TObject *clone(const char *newname = nullptr) const = 0;
88 TObject *Clone(const char *newname = nullptr) const override
89 {
90 return clone(newname && newname[0] != '\0' ? newname : nullptr);
91 }
92 virtual RooAbsArg *cloneTree(const char *newname = nullptr) const;
93
94 // Accessors to client-server relation information
95
96 /// Does value or shape of this arg depend on any other arg?
97 virtual bool isDerived() const { return true; }
98
99 /// Check whether this object depends on values from an element in the `serverList`.
100 ///
101 /// @param serverList Test if one of the elements in this list serves values to `this`.
102 /// @param ignoreArg Ignore values served by this object.
103 /// @return True if values are served.
104 bool dependsOnValue(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg = nullptr) const
105 {
106 return dependsOn(serverList, ignoreArg, true);
107 }
108 /// Check whether this object depends on values served from the object passed as `server`.
109 ///
110 /// @param server Test if `server` serves values to `this`.
111 /// @param ignoreArg Ignore values served by this object.
112 /// @return True if values are served.
113 bool dependsOnValue(const RooAbsArg &server, const RooAbsArg *ignoreArg = nullptr) const
114 {
115 return dependsOn(server, ignoreArg, true);
116 }
117 bool
118 dependsOn(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg = nullptr, bool valueOnly = false) const;
119 /// Test whether we depend on (ie, are served by) the specified object.
120 /// Note that RooAbsArg objects are considered equivalent if they have
121 /// the same name.
122 inline bool dependsOn(const RooAbsArg &server, const RooAbsArg *ignoreArg = nullptr, bool valueOnly = false) const
123 {
124 return dependsOn(server.namePtr(), ignoreArg, valueOnly);
125 }
126 bool dependsOn(TNamed const *namePtr, const RooAbsArg *ignoreArg = nullptr, bool valueOnly = false) const;
127 bool overlaps(const RooAbsArg &testArg, bool valueOnly = false) const;
128 bool hasClients() const { return !_clientList.empty(); }
129
130 ////////////////////////////////////////////////////////////////////////////
131 /// \anchor clientServerInterface
132 /// \name Client-Server Interface
133 /// These functions allow RooFit to figure out who is serving values to whom.
134 /// @{
135
136 /// List of all clients of this object.
137 const RefCountList_t &clients() const { return _clientList; }
138 /// List of all value clients of this object. Value clients receive value updates.
140 /// List of all shape clients of this object. Shape clients receive property information such as
141 /// changes of a value range.
143
144 /// List of all servers of this object.
145 const RefCountList_t &servers() const { return _serverList; }
146 /// Return server of `this` with name `name`. Returns nullptr if not found.
147 inline RooAbsArg *findServer(const char *name) const
148 {
149 const auto serverIt = _serverList.findByName(name);
150 return serverIt != _serverList.end() ? *serverIt : nullptr;
151 }
152 /// Return server of `this` that has the same name as `arg`. Returns `nullptr` if not found.
153 inline RooAbsArg *findServer(const RooAbsArg &arg) const { return _serverList.findByNamePointer(&arg); }
154 /// Return i-th server from server list.
155 inline RooAbsArg *findServer(Int_t index) const { return _serverList.containedObjects()[index]; }
156 /// Check if `this` is serving values to `arg`.
157 inline bool isValueServer(const RooAbsArg &arg) const { return _clientListValue.containsByNamePtr(&arg); }
158 /// Check if `this` is serving values to an object with name `name`.
159 inline bool isValueServer(const char *name) const { return _clientListValue.containsSameName(name); }
160 /// Check if `this` is serving shape to `arg`.
161 inline bool isShapeServer(const RooAbsArg &arg) const { return _clientListShape.containsByNamePtr(&arg); }
162 /// Check if `this` is serving shape to an object with name `name`.
163 inline bool isShapeServer(const char *name) const { return _clientListShape.containsSameName(name); }
164 void
165 leafNodeServerList(RooAbsCollection *list, const RooAbsArg *arg = nullptr, bool recurseNonDerived = false) const;
166 void
167 branchNodeServerList(RooAbsCollection *list, const RooAbsArg *arg = nullptr, bool recurseNonDerived = false) const;
168 void treeNodeServerList(RooAbsCollection *list, const RooAbsArg *arg = nullptr, bool doBranch = true,
169 bool doLeaf = true, bool valueOnly = false, bool recurseNonDerived = false) const;
170
171 /// Is this object a fundamental type that can be added to a dataset?
172 /// Fundamental-type subclasses override this method to return true.
173 /// Note that this test is subtlely different from the dynamic isDerived()
174 /// test, e.g. a constant is not derived but is also not fundamental.
175 inline virtual bool isFundamental() const { return false; }
176
177 /// Create a fundamental-type object that stores our type of value. The
178 /// created object will have a valid value, but not necessarily the same
179 /// as our value. The caller is responsible for deleting the returned object.
180 virtual RooFit::OwningPtr<RooAbsArg> createFundamental(const char *newname = nullptr) const = 0;
181
182 /// Is this argument an l-value, i.e., can it appear on the left-hand side
183 /// of an assignment expression? LValues are also special since they can
184 /// potentially be analytically integrated and generated.
185 inline virtual bool isLValue() const { return false; }
186
187 // Server redirection interface
188 bool redirectServers(const RooAbsCollection &newServerList, bool mustReplaceAll = false, bool nameChange = false,
189 bool isRecursionStep = false);
190 bool redirectServers(std::unordered_map<RooAbsArg *, RooAbsArg *> const &replacements);
192 bool nameChange = false, bool recurseInNewSet = true);
193
195 bool isRecursiveStep);
196
197 virtual void serverNameChangeHook(const RooAbsArg * /*oldServer*/, const RooAbsArg * /*newServer*/) {};
198
199 void addServer(RooAbsArg &server, bool valueProp = true, bool shapeProp = false, std::size_t refCount = 1);
200 void addServerList(RooAbsCollection &serverList, bool valueProp = true, bool shapeProp = false);
201 void R__SUGGEST_ALTERNATIVE("This interface is unsafe! Use RooAbsArg::redirectServers()")
204 void removeServer(RooAbsArg &server, bool force = false);
206
207 /// @}
208 ///////////////////////////////////////////////////////////////////////////////
209
210 // Parameter & observable interpretation of servers
214 RooFit::OwningPtr<RooArgSet> getParameters(const RooArgSet &observables, bool stripDisconnected = true) const;
215 RooFit::OwningPtr<RooArgSet> getParameters(const RooArgSet *observables, bool stripDisconnected = true) const;
226 RooFit::OwningPtr<RooArgSet> getComponents() const;
227
229 void attachDataSet(const RooAbsData &set);
231
232 // I/O streaming interface (machine readable)
233 virtual bool readFromStream(std::istream &is, bool compact, bool verbose = false) = 0;
234 virtual void writeToStream(std::ostream &os, bool compact) const = 0;
235
236 /// Print the object to the defaultPrintStream().
237 /// \param[in] options **V** print verbose. **T** print a tree structure with all children.
238 void Print(Option_t *options = nullptr) const override
239 {
240 // Printing interface (human readable)
242 }
243
244 void printName(std::ostream &os) const override;
245 void printTitle(std::ostream &os) const override;
246 void printClassName(std::ostream &os) const override;
247 void printAddress(std::ostream &os) const override;
248 void printArgs(std::ostream &os) const override;
249 virtual void printMetaArgs(std::ostream & /*os*/) const {};
250 void printMultiline(std::ostream &os, Int_t contents, bool verbose = false, TString indent = "") const override;
251 void printTree(std::ostream &os, TString indent = "") const override;
252
253 Int_t defaultPrintContents(Option_t *opt) const override;
254
255 // Accessors to attributes
256 void setAttribute(const Text_t *name, bool value = true);
257 bool getAttribute(const Text_t *name) const;
258 inline const std::set<std::string> &attributes() const
259 {
260 // Returns set of names of boolean attributes defined
261 return _boolAttrib;
262 }
263
264 void setStringAttribute(const Text_t *key, const Text_t *value);
265 void removeStringAttribute(const Text_t *key);
266 const Text_t *getStringAttribute(const Text_t *key) const;
267 inline const std::map<std::string, std::string> &stringAttributes() const
268 {
269 // Returns std::map<string,string> with all string attributes defined
270 return _stringAttrib;
271 }
272
273 // Accessors to transient attributes
274 void setTransientAttribute(const Text_t *name, bool value = true);
275 bool getTransientAttribute(const Text_t *name) const;
276 inline const std::set<std::string> &transientAttributes() const
277 {
278 // Return set of transient boolean attributes
280 }
281
282 /// Check if the "Constant" attribute is set.
283 inline bool isConstant() const
284 {
285 return _isConstant; // getAttribute("Constant") ;
286 }
287
288 // Sorting
289 Int_t Compare(const TObject *other) const override;
290 bool IsSortable() const override
291 {
292 // Object is sortable in ROOT container class
293 return true;
294 }
295
296 virtual bool operator==(const RooAbsArg &other) const = 0;
297 virtual bool isIdentical(const RooAbsArg &other, bool assumeSameType = false) const = 0;
298
299 // Range management
300 virtual bool inRange(const char *) const
301 {
302 // Is value in range (dummy interface always returns true)
303 return true;
304 }
305 virtual bool hasRange(const char *) const
306 {
307 // Has this argument a defined range (dummy interface always returns false)
308 return false;
309 }
310
320 Never = 2
321 };
322 enum OperMode {
323 Auto = 0,
325 ADirty = 2
326 };
327
328 ////////////////////////////////////////////////////////////////////////////
329 /// \anchor optimisationInterface
330 /// \name Optimisation interface
331 /// These functions allow RooFit to optimise a computation graph, to keep track
332 /// of cached values, and to invalidate caches.
333 /// @{
334
335 // Cache mode optimization (tracks changes & do lazy evaluation vs evaluate always)
336 virtual void optimizeCacheMode(const RooArgSet &observables);
337 virtual void optimizeCacheMode(const RooArgSet &observables, RooArgSet &optNodes, RooLinkedList &processedNodes);
338
339 // Find constant terms in expression
340 bool findConstantNodes(const RooArgSet &observables, RooArgSet &cacheList);
342
343 // constant term optimization
344 virtual void constOptimizeTestStatistic(ConstOpCode opcode, bool doAlsoTrackingOpt = true);
345
346 virtual CacheMode canNodeBeCached() const { return Always; }
347 virtual void setCacheAndTrackHints(RooArgSet & /*trackNodes*/) {};
348
349 // Dirty state accessor
350 inline bool isShapeDirty() const
351 {
352 // Return true is shape has been invalidated by server value change
353 return isDerived() ? _shapeDirty : false;
354 }
355
356 inline bool isValueDirty() const
357 {
358 // Returns true of value has been invalidated by server value change
359 if (inhibitDirty())
360 return true;
361 switch (_operMode) {
362 case AClean: return false;
363 case ADirty: return true;
364 case Auto:
365 if (_valueDirty)
366 return isDerived();
367 return false;
368 }
369 return true; // we should never get here
370 }
371
372 inline bool isValueDirtyAndClear() const
373 {
374 // Returns true of value has been invalidated by server value change
375 if (inhibitDirty())
376 return true;
377 switch (_operMode) {
378 case AClean: return false;
379 case ADirty: return true;
380 case Auto:
381 if (_valueDirty) {
382 _valueDirty = false;
383 return isDerived();
384 }
385 return false;
386 }
387 return true; // But we should never get here
388 }
389
390 inline bool isValueOrShapeDirtyAndClear() const
391 {
392 // Returns true of value has been invalidated by server value change
393
394 if (inhibitDirty())
395 return true;
396 switch (_operMode) {
397 case AClean: return false;
398 case ADirty: return true;
399 case Auto:
400 if (_valueDirty || _shapeDirty) {
401 _shapeDirty = false;
402 _valueDirty = false;
403 return isDerived();
404 }
405 _shapeDirty = false;
406 _valueDirty = false;
407 return false;
408 }
409 return true; // But we should never get here
410 }
411
412 // Cache management
413 void registerCache(RooAbsCache &cache);
414 void unRegisterCache(RooAbsCache &cache);
415 Int_t numCaches() const;
417
418 /// Query the operation mode of this node.
419 inline OperMode operMode() const { return _operMode; }
420 /// Set the operation mode of this node.
421 void setOperMode(OperMode mode, bool recurseADirty = true);
422
423 // Dirty state modifiers
424 /// Mark the element dirty. This forces a re-evaluation when a value is requested.
426 {
427 if (_operMode == Auto && !inhibitDirty())
428 setValueDirty(nullptr);
429 }
430 /// Notify that a shape-like property (*e.g.* binning) has changed.
431 void setShapeDirty() { setShapeDirty(nullptr); }
432
433 const char *aggregateCacheUniqueSuffix() const;
434 virtual const char *cacheUniqueSuffix() const { return nullptr; }
435
436 void wireAllCaches();
437
440
441 /// Overwrite the current value stored in this object, making it look like this object computed that value.
442 // \param[in] value Value to store.
443 // \param[in] notifyClients Notify users of this object that they need to
444 /// recompute their values.
445 virtual void setCachedValue(double /*value*/, bool /*notifyClients*/ = true) {};
446
447 /// @}
448 ////////////////////////////////////////////////////////////////////////////
449
450 // Debug hooks
451 static void verboseDirty(bool flag);
452 void printDirty(bool depth = true) const;
453 static void setDirtyInhibit(bool flag);
454
455 void graphVizTree(const char *fileName, const char *delimiter = "\n", bool useTitle = false, bool useLatex = false);
456 void graphVizTree(std::ostream &os, const char *delimiter = "\n", bool useTitle = false, bool useLatex = false);
457
458 void printComponentTree(const char *indent = "", const char *namePat = nullptr, Int_t nLevel = 999);
459 void printCompactTree(const char *indent = "", const char *fileName = nullptr, const char *namePat = nullptr,
460 RooAbsArg *client = nullptr);
461 void printCompactTree(std::ostream &os, const char *indent = "", const char *namePat = nullptr,
462 RooAbsArg *client = nullptr);
463 virtual void printCompactTreeHook(std::ostream &os, const char *ind = "");
464
465 // We want to support three cases here:
466 // * passing a RooArgSet
467 // * passing a RooArgList
468 // * passing an initializer list
469 // Before, there was only an overload taking a RooArg set, which caused an
470 // implicit creation of a RooArgSet when a RooArgList was passed. This needs
471 // to be avoided, because if the passed RooArgList is owning the arguments,
472 // this information will be lost with the copy. The solution is to have one
473 // overload that takes a general RooAbsCollection, and one overload for
474 // RooArgList that is invoked in the case of passing an initializer list.
478
479 // Transfer the ownership of one or more other RooAbsArgs to this RooAbsArg
480 // via a `std::unique_ptr`.
481 template <typename... Args_t>
482 bool addOwnedComponents(std::unique_ptr<Args_t>... comps)
483 {
484 return addOwnedComponents({*comps.release()...});
485 }
486 const RooArgSet *ownedComponents() const { return _ownedComponents; }
487
489
490 void setWorkspace(RooWorkspace &ws) { _myws = &ws; }
491 inline RooWorkspace *workspace() const { return _myws; }
492
494 Int_t numProxies() const;
495
496 /// De-duplicated pointer to this object's name.
497 /// This can be used for fast name comparisons.
498 /// like `if (namePtr() == other.namePtr())`.
499 /// \note TNamed::GetName() will return a pointer that's
500 /// different for each object, but namePtr() always points
501 /// to a unique instance.
502 inline const TNamed *namePtr() const { return _namePtr; }
503
504 void SetName(const char *name) override;
505 void SetNameTitle(const char *name, const char *title) override;
506
508 {
509 _myws = &ws;
510 return false;
511 };
512
513 virtual bool canComputeBatchWithCuda() const { return false; }
514 virtual bool isReducerNode() const { return false; }
515
516 virtual void applyWeightSquared(bool flag);
517
518 virtual std::unique_ptr<RooAbsArg>
520
521 virtual bool isCategory() const { return false; }
522
523protected:
524 void graphVizAddConnections(std::set<std::pair<RooAbsArg *, RooAbsArg *>> &);
525
526 virtual void operModeHook() {};
527
528 virtual void optimizeDirtyHook(const RooArgSet * /*obs*/) {};
529
530 virtual bool isValid() const;
531
532 virtual void
533 getParametersHook(const RooArgSet * /*nset*/, RooArgSet * /*list*/, bool /*stripDisconnected*/) const {};
534
536 {
537 _valueDirty = false;
538 _shapeDirty = false;
539 }
540
541 void clearValueDirty() const { _valueDirty = false; }
542 void clearShapeDirty() const { _shapeDirty = false; }
543
544 /// Force element to re-evaluate itself when a value is requested.
545 void setValueDirty(const RooAbsArg *source);
546 /// Notify that a shape-like property (*e.g.* binning) has changed.
547 void setShapeDirty(const RooAbsArg *source);
548
549 virtual void ioStreamerPass2();
550 static void ioStreamerPass2Finalize();
551
552private:
553 void addParameters(RooAbsCollection &params, const RooArgSet *nset = nullptr, bool stripDisconnected = true) const;
554
556
557protected:
558 friend class RooAbsReal;
559
560 // Client-Server relation and Proxy management
561 friend class RooAbsCollection;
562 friend class RooWorkspace;
563 friend class RooRealIntegral;
564 RefCountList_t _serverList; // list of server objects
565 RefCountList_t _clientList; // list of client objects
566 RefCountList_t _clientListShape; // subset of clients that requested shape dirty flag propagation
567 RefCountList_t _clientListValue; // subset of clients that requested value dirty flag propagation
568
569 RooRefArray _proxyList; // list of proxies
570
571 std::vector<RooAbsCache *> _cacheList; //! list of caches
572
573 // Proxy management
574 friend class RooArgProxy;
575 template <class RooCollection_t>
576 friend class RooCollectionProxy;
577 friend class RooHistPdf;
578 friend class RooHistFunc;
585 void setProxyNormSet(const RooArgSet *nset);
586
587 // Attribute list
588 std::set<std::string> _boolAttrib; // Boolean attributes
589 std::map<std::string, std::string> _stringAttrib; // String attributes
590 std::set<std::string> _boolAttribTransient; //! Transient boolean attributes (not copied in ctor)
591
592 void printAttribList(std::ostream &os) const;
593
594 // Hooks for RooTreeData interface
596 friend class RooTreeDataStore;
597 friend class RooVectorDataStore;
598 friend class RooDataSet;
599 friend class RooRealMPFE;
600 virtual void syncCache(const RooArgSet *nset = nullptr) = 0;
601 virtual void copyCache(const RooAbsArg *source, bool valueOnly = false, bool setValDirty = true) = 0;
602
603 virtual void attachToTree(TTree &t, Int_t bufSize = 32000) = 0;
605 /// Attach this argument to the data store such that it reads data from there.
606 void attachToStore(RooAbsDataStore &store);
607
608 virtual void setTreeBranchStatus(TTree &t, bool active) = 0;
609 virtual void fillTreeBranch(TTree &t) = 0;
610 TString cleanBranchName() const;
611
612 // Global
613 friend std::ostream &operator<<(std::ostream &os, const RooAbsArg &arg);
614 friend std::istream &operator>>(std::istream &is, RooAbsArg &arg);
616
618 std::vector<RooAbsProxy *> cache;
619 bool isDirty = true;
620 };
621 ProxyListCache _proxyListCache; //! cache of the list of proxies. Avoids type casting.
622
623 // Debug stuff
624 static bool _verboseDirty; // Static flag controlling verbose messaging for dirty state changes
625 static bool _inhibitDirty; // Static flag controlling global inhibit of dirty state propagation
626 bool _deleteWatch = false; //! Delete watch flag
627
628 bool inhibitDirty() const;
629
630public:
633
634 /// Returns the token for retrieving results in the BatchMode. For internal use only.
635 std::size_t dataToken() const { return _dataToken; }
636 bool hasDataToken() const { return _dataToken != std::numeric_limits<std::size_t>::max(); }
637 void setDataToken(std::size_t index);
638 void resetDataToken() { _dataToken = std::numeric_limits<std::size_t>::max(); }
639
640protected:
641 mutable bool _valueDirty = true; // Flag set if value needs recalculating because input values modified
642 mutable bool _shapeDirty = true; // Flag set if value needs recalculating because input shapes modified
643
644 mutable OperMode _operMode = Auto; // Dirty state propagation mode
645 mutable bool _fast = false; // Allow fast access mode in getVal() and proxies
646
647 // Owned components
648 RooArgSet *_ownedComponents = nullptr; //! Set of owned component
649
650 mutable bool _prohibitServerRedirect = false; //! Prohibit server redirects -- Debugging tool
651
652 mutable RooExpensiveObjectCache *_eocache{nullptr}; //! Pointer to global cache manager for expensive components.
653
654 mutable const TNamed *_namePtr = nullptr; //! De-duplicated name pointer, equal for all objects with the same name.
655 bool _isConstant = false; //! Cached isConstant status
656
657 mutable bool _localNoInhibitDirty = false; //! Prevent 'AlwaysDirty' mode for this node
658
659 mutable RooWorkspace *_myws = nullptr; //! In which workspace do I live, if any
660
661 std::size_t _dataToken = std::numeric_limits<std::size_t>::max(); //! Set by the RooFitDriver for this arg to
662 //! retrieve its result in the run context
663
664 /// \cond ROOFIT_INTERNAL
665 // Legacy streamers need the following statics:
666 friend class RooFitResult;
667
668public:
669 // Used internally for schema evolution.
671 /// \endcond
672
673private:
675 bool
677
678 ClassDefOverride(RooAbsArg, 9) // Abstract variable
679};
680
681std::ostream &operator<<(std::ostream &os, const RooAbsArg &arg);
682std::istream &operator>>(std::istream &is, RooAbsArg &arg);
683
684#endif
#define R__SUGGEST_ALTERNATIVE(ALTERNATIVE)
Definition RConfig.hxx:520
std::ostream & operator<<(std::ostream &os, const RooAbsArg &arg)
Ostream operator.
std::istream & operator>>(std::istream &is, RooAbsArg &arg)
Istream operator.
char Text_t
General string (char)
Definition RtypesCore.h:76
const char Option_t
Option string (const char)
Definition RtypesCore.h:80
#define ClassDefOverride(name, id)
Definition Rtypes.h:348
static void indent(ostringstream &buf, int indent_level)
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
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 index
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char mode
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:76
RooExpensiveObjectCache & expensiveObjectCache() const
void setLocalNoDirtyInhibit(bool flag) const
Definition RooAbsArg.h:631
bool overlaps(const RooAbsArg &testArg, bool valueOnly=false) const
Test if any of the nodes of tree are shared with that of the given tree.
RooRefArray _proxyList
Definition RooAbsArg.h:569
void replaceServer(RooAbsArg &oldServer, RooAbsArg &newServer, bool valueProp, bool shapeProp)
Replace 'oldServer' with 'newServer', specifying whether the new server has value or shape server pro...
bool _isConstant
De-duplicated name pointer, equal for all objects with the same name.
Definition RooAbsArg.h:655
void clearValueAndShapeDirty() const
Definition RooAbsArg.h:535
void Print(Option_t *options=nullptr) const override
Print the object to the defaultPrintStream().
Definition RooAbsArg.h:238
virtual void copyCache(const RooAbsArg *source, bool valueOnly=false, bool setValDirty=true)=0
bool dependsOn(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg=nullptr, bool valueOnly=false) const
Test whether we depend on (ie, are served by) any object in the specified collection.
void attachToStore(RooAbsDataStore &store)
Attach this argument to the data store such that it reads data from there.
bool recursiveRedirectServers(const RooAbsCollection &newServerList, bool mustReplaceAll=false, bool nameChange=false, bool recurseInNewSet=true)
Recursively replace all servers with the new servers in newSet.
const TNamed * namePtr() const
De-duplicated pointer to this object's name.
Definition RooAbsArg.h:502
std::map< std::string, std::string > _stringAttrib
Definition RooAbsArg.h:589
const char * aggregateCacheUniqueSuffix() const
void printArgs(std::ostream &os) const override
Print object arguments, ie its proxies.
void printClassName(std::ostream &os) const override
Print object class name.
ProxyListCache _proxyListCache
Definition RooAbsArg.h:621
RooWorkspace * _myws
Prevent 'AlwaysDirty' mode for this node.
Definition RooAbsArg.h:659
~RooAbsArg() override
Destructor.
void resetDataToken()
Definition RooAbsArg.h:638
void attachDataStore(const RooAbsDataStore &set)
Replace server nodes with names matching the dataset variable names with those data set variables,...
bool addOwnedComponents(std::unique_ptr< Args_t >... comps)
Definition RooAbsArg.h:482
virtual bool operator==(const RooAbsArg &other) const =0
RooArgSet * _ownedComponents
Definition RooAbsArg.h:648
void printAddress(std::ostream &os) const override
Print address of this RooAbsArg.
void setShapeDirty()
Notify that a shape-like property (e.g. binning) has changed.
Definition RooAbsArg.h:431
virtual bool isCategory() const
Definition RooAbsArg.h:521
bool dependsOn(const RooAbsArg &server, const RooAbsArg *ignoreArg=nullptr, bool valueOnly=false) const
Test whether we depend on (ie, are served by) the specified object.
Definition RooAbsArg.h:122
virtual void setCachedValue(double, bool=true)
Overwrite the current value stored in this object, making it look like this object computed that valu...
Definition RooAbsArg.h:445
void setDataToken(std::size_t index)
Sets the token for retrieving results in the BatchMode. For internal use only.
virtual void syncCache(const RooArgSet *nset=nullptr)=0
void registerProxy(RooArgProxy &proxy)
Register an RooArgProxy in the proxy list.
void setOperMode(OperMode mode, bool recurseADirty=true)
Set the operation mode of this node.
bool callRedirectServersHook(RooAbsCollection const &newSet, bool mustReplaceAll, bool nameChange, bool isRecursionStep)
Private helper function for RooAbsArg::redirectServers().
friend std::ostream & operator<<(std::ostream &os, const RooAbsArg &arg)
Ostream operator.
void setProhibitServerRedirect(bool flag)
Definition RooAbsArg.h:488
void attachArgs(const RooAbsCollection &set)
Bind this node to objects in set.
void setStringAttribute(const Text_t *key, const Text_t *value)
Associate string 'value' to this object under key 'key'.
bool isShapeServer(const RooAbsArg &arg) const
Check if this is serving shape to arg.
Definition RooAbsArg.h:161
bool isShapeDirty() const
Definition RooAbsArg.h:350
static void ioStreamerPass2Finalize()
Method called by workspace container to finalize schema evolution issues that cannot be handled in a ...
bool isValueDirtyAndClear() const
Definition RooAbsArg.h:372
virtual CacheMode canNodeBeCached() const
Definition RooAbsArg.h:346
bool isConstant() const
Check if the "Constant" attribute is set.
Definition RooAbsArg.h:283
bool _fast
Definition RooAbsArg.h:645
void setWorkspace(RooWorkspace &ws)
Definition RooAbsArg.h:490
virtual TObject * clone(const char *newname=nullptr) const =0
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...
void addParameters(RooAbsCollection &params, const RooArgSet *nset=nullptr, bool stripDisconnected=true) const
Add all parameters of the function and its daughters to params.
const RooArgSet * ownedComponents() const
Definition RooAbsArg.h:486
void removeServer(RooAbsArg &server, bool force=false)
Unregister another RooAbsArg as a server to us, ie, declare that we no longer depend on its value and...
RooAbsArg & operator=(const RooAbsArg &other)=delete
RooFit::OwningPtr< RooArgSet > getObservables(const RooArgSet &set, bool valueOnly=true) const
Given a set of possible observables, return the observables that this PDF depends on.
void setTransientAttribute(const Text_t *name, bool value=true)
Set (default) or clear a named boolean attribute of this object.
void graphVizAddConnections(std::set< std::pair< RooAbsArg *, RooAbsArg * > > &)
Utility function that inserts all point-to-point client-server connections between any two RooAbsArgs...
void unRegisterProxy(RooArgProxy &proxy)
Remove proxy from proxy list.
virtual bool canComputeBatchWithCuda() const
Definition RooAbsArg.h:513
bool _shapeDirty
Definition RooAbsArg.h:642
const RefCountList_t & shapeClients() const
List of all shape clients of this object.
Definition RooAbsArg.h:142
void SetName(const char *name) override
Set the name of the TNamed.
RooSTLRefCountList< RooAbsArg > RefCountList_t
Definition RooAbsArg.h:78
const RefCountList_t & valueClients() const
List of all value clients of this object. Value clients receive value updates.
Definition RooAbsArg.h:139
friend std::istream & operator>>(std::istream &is, RooAbsArg &arg)
Istream operator.
virtual void setExpensiveObjectCache(RooExpensiveObjectCache &cache)
Definition RooAbsArg.h:439
virtual bool hasRange(const char *) const
Definition RooAbsArg.h:305
std::set< std::string > _boolAttrib
Definition RooAbsArg.h:588
void unRegisterCache(RooAbsCache &cache)
Unregister a RooAbsCache. Called from the RooAbsCache destructor.
RefCountList_t _clientListValue
Definition RooAbsArg.h:567
bool addOwnedComponents(const RooAbsCollection &comps)
Take ownership of the contents of 'comps'.
void printAttribList(std::ostream &os) const
Transient boolean attributes (not copied in ctor)
void printTree(std::ostream &os, TString indent="") const override
Print object tree structure.
void SetNameTitle(const char *name, const char *title) override
Set all the TNamed parameters (name and title).
const Text_t * getStringAttribute(const Text_t *key) const
Get string attribute mapped under key 'key'.
bool findConstantNodes(const RooArgSet &observables, RooArgSet &cacheList)
Find branch nodes with all-constant parameters, and add them to the list of nodes that can be cached ...
static bool _verboseDirty
cache of the list of proxies. Avoids type casting.
Definition RooAbsArg.h:624
bool _deleteWatch
Definition RooAbsArg.h:626
void addServerList(RooAbsCollection &serverList, bool valueProp=true, bool shapeProp=false)
Register a list of RooAbsArg as servers to us by calling addServer() for each arg in the list.
virtual bool readFromStream(std::istream &is, bool compact, bool verbose=false)=0
bool dependsOnValue(const RooAbsArg &server, const RooAbsArg *ignoreArg=nullptr) const
Check whether this object depends on values served from the object passed as server.
Definition RooAbsArg.h:113
bool redirectServers(const RooAbsCollection &newServerList, bool mustReplaceAll=false, bool nameChange=false, bool isRecursionStep=false)
Replace all direct servers of this object with the new servers in newServerList.
virtual bool isLValue() const
Is this argument an l-value, i.e., can it appear on the left-hand side of an assignment expression?...
Definition RooAbsArg.h:185
bool isValueServer(const char *name) const
Check if this is serving values to an object with name name.
Definition RooAbsArg.h:159
virtual RooFit::OwningPtr< RooAbsArg > createFundamental(const char *newname=nullptr) const =0
Create a fundamental-type object that stores our type of value.
static void setDirtyInhibit(bool flag)
Control global dirty inhibit mode.
virtual void serverNameChangeHook(const RooAbsArg *, const RooAbsArg *)
Definition RooAbsArg.h:197
virtual void printCompactTreeHook(std::ostream &os, const char *ind="")
Hook function interface for object to insert additional information when printed in the context of a ...
virtual void setCacheAndTrackHints(RooArgSet &)
Definition RooAbsArg.h:347
const std::set< std::string > & attributes() const
Definition RooAbsArg.h:258
bool isShapeServer(const char *name) const
Check if this is serving shape to an object with name name.
Definition RooAbsArg.h:163
const TNamed * _namePtr
Pointer to global cache manager for expensive components.
Definition RooAbsArg.h:654
void printCompactTree(const char *indent="", const char *fileName=nullptr, const char *namePat=nullptr, RooAbsArg *client=nullptr)
Print tree structure of expression tree on stdout, or to file if filename is specified.
virtual std::unique_ptr< RooAbsArg > compileForNormSet(RooArgSet const &normSet, RooFit::Detail::CompileContext &ctx) const
virtual void getParametersHook(const RooArgSet *, RooArgSet *, bool) const
Definition RooAbsArg.h:533
RooWorkspace * workspace() const
Definition RooAbsArg.h:491
void clearValueDirty() const
Definition RooAbsArg.h:541
virtual void ioStreamerPass2()
Method called by workspace container to finalize schema evolution issues that cannot be handled in a ...
RooFit::OwningPtr< RooArgSet > getComponents() const
Create a RooArgSet with all components (branch nodes) of the expression tree headed by this object.
void wireAllCaches()
virtual bool importWorkspaceHook(RooWorkspace &ws)
Definition RooAbsArg.h:507
bool _valueDirty
Definition RooAbsArg.h:641
bool _prohibitServerRedirect
Set of owned component.
Definition RooAbsArg.h:650
virtual const char * cacheUniqueSuffix() const
Definition RooAbsArg.h:434
RefCountListLegacyIterator_t * makeLegacyIterator(const RefCountList_t &list) const
const RefCountList_t & servers() const
List of all servers of this object.
Definition RooAbsArg.h:145
std::size_t _dataToken
In which workspace do I live, if any.
Definition RooAbsArg.h:661
bool dependsOnValue(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg=nullptr) const
Check whether this object depends on values from an element in the serverList.
Definition RooAbsArg.h:104
void addServer(RooAbsArg &server, bool valueProp=true, bool shapeProp=false, std::size_t refCount=1)
Register another RooAbsArg as a server to us, ie, declare that we depend on it.
void removeStringAttribute(const Text_t *key)
Delete a string attribute with a given key.
Int_t Compare(const TObject *other) const override
Utility function used by TCollection::Sort to compare contained TObjects We implement comparison by n...
Int_t defaultPrintContents(Option_t *opt) const override
Define default contents to print.
virtual bool isDerived() const
Does value or shape of this arg depend on any other arg?
Definition RooAbsArg.h:97
virtual void attachToTree(TTree &t, Int_t bufSize=32000)=0
Overloadable function for derived classes to implement attachment as branch to a TTree.
void printComponentTree(const char *indent="", const char *namePat=nullptr, Int_t nLevel=999)
Print tree structure of expression tree on given ostream, only branch nodes are printed.
OperMode _operMode
Definition RooAbsArg.h:644
virtual void constOptimizeTestStatistic(ConstOpCode opcode, bool doAlsoTrackingOpt=true)
Interface function signaling a request to perform constant term optimization.
virtual bool isReducerNode() const
Definition RooAbsArg.h:514
void setValueDirty()
Mark the element dirty. This forces a re-evaluation when a value is requested.
Definition RooAbsArg.h:425
bool getAttribute(const Text_t *name) const
Check if a named attribute is set. By default, all attributes are unset.
bool isValueOrShapeDirtyAndClear() const
Definition RooAbsArg.h:390
bool hasDataToken() const
Definition RooAbsArg.h:636
RooAbsArg * findServer(const RooAbsArg &arg) const
Return server of this that has the same name as arg. Returns nullptr if not found.
Definition RooAbsArg.h:153
static void verboseDirty(bool flag)
Activate verbose messaging related to dirty flag propagation.
virtual bool inRange(const char *) const
Definition RooAbsArg.h:300
virtual void setTreeBranchStatus(TTree &t, bool active)=0
RooFit::OwningPtr< RooArgSet > getVariables(bool stripDisconnected=true) const
Return RooArgSet with all variables (tree leaf nodes of expression tree)
const std::map< std::string, std::string > & stringAttributes() const
Definition RooAbsArg.h:267
RooAbsCache * getCache(Int_t index) const
Return registered cache object by index.
virtual void writeToStream(std::ostream &os, bool compact) const =0
void printMultiline(std::ostream &os, Int_t contents, bool verbose=false, TString indent="") const override
Implement multi-line detailed printing.
virtual RooAbsArg * cloneTree(const char *newname=nullptr) const
Clone tree expression of objects.
void registerCache(RooAbsCache &cache)
Register RooAbsCache with this object.
virtual void optimizeCacheMode(const RooArgSet &observables)
Activate cache mode optimization with given definition of observables.
RefCountList_t _clientListShape
Definition RooAbsArg.h:566
virtual void attachToVStore(RooVectorDataStore &vstore)=0
TString cleanBranchName() const
Construct a mangled name from the actual name that is free of any math symbols that might be interpre...
bool inhibitDirty() const
Delete watch flag.
bool observableOverlaps(const RooAbsData *dset, const RooAbsArg &testArg) const
Test if any of the dependents of the arg tree (as determined by getObservables) overlaps with those o...
void changeServer(RooAbsArg &server, bool valueProp, bool shapeProp)
Change dirty flag propagation mask for specified server.
RooAbsArg * findServer(Int_t index) const
Return i-th server from server list.
Definition RooAbsArg.h:155
Int_t numProxies() const
Return the number of registered proxies.
void printName(std::ostream &os) const override
Print object name.
bool hasClients() const
Definition RooAbsArg.h:128
const std::set< std::string > & transientAttributes() const
Definition RooAbsArg.h:276
const RefCountList_t & clients() const
List of all clients of this object.
Definition RooAbsArg.h:137
bool isValueDirty() const
Definition RooAbsArg.h:356
bool _localNoInhibitDirty
Cached isConstant status.
Definition RooAbsArg.h:657
virtual void printMetaArgs(std::ostream &) const
Definition RooAbsArg.h:249
virtual bool isIdentical(const RooAbsArg &other, bool assumeSameType=false) const =0
virtual void applyWeightSquared(bool flag)
Disables or enables the usage of squared weights.
static bool _inhibitDirty
Definition RooAbsArg.h:625
void setAttribute(const Text_t *name, bool value=true)
Set (default) or clear a named boolean attribute of this object.
void setProxyNormSet(const RooArgSet *nset)
Forward a change in the cached normalization argset to all the registered proxies.
std::size_t dataToken() const
Returns the token for retrieving results in the BatchMode. For internal use only.
Definition RooAbsArg.h:635
void branchNodeServerList(RooAbsCollection *list, const RooAbsArg *arg=nullptr, bool recurseNonDerived=false) const
Fill supplied list with all branch nodes of the arg tree starting with ourself as top node.
RefCountList_t _clientList
Definition RooAbsArg.h:565
void printDirty(bool depth=true) const
Print information about current value dirty state information.
RooAbsProxy * getProxy(Int_t index) const
Return the nth proxy from the proxy list.
TObject * Clone(const char *newname=nullptr) const override
Make a clone of an object using the Streamer facility.
Definition RooAbsArg.h:88
RefCountList_t _serverList
Definition RooAbsArg.h:564
void clearShapeDirty() const
Definition RooAbsArg.h:542
void leafNodeServerList(RooAbsCollection *list, const RooAbsArg *arg=nullptr, bool recurseNonDerived=false) const
Fill supplied list with all leaf nodes of the arg tree, starting with ourself as top node.
RooExpensiveObjectCache * _eocache
Prohibit server redirects – Debugging tool.
Definition RooAbsArg.h:652
virtual bool isFundamental() const
Is this object a fundamental type that can be added to a dataset? Fundamental-type subclasses overrid...
Definition RooAbsArg.h:175
virtual bool isValid() const
WVE (08/21/01) Probably obsolete now.
std::set< std::string > _boolAttribTransient
Definition RooAbsArg.h:590
friend class RooRealMPFE
Definition RooAbsArg.h:599
void printTitle(std::ostream &os) const override
Print object title.
virtual bool redirectServersHook(const RooAbsCollection &newServerList, bool mustReplaceAll, bool nameChange, bool isRecursiveStep)
Function that is called at the end of redirectServers().
virtual void fillTreeBranch(TTree &t)=0
std::vector< RooAbsCache * > _cacheList
Definition RooAbsArg.h:571
void graphVizTree(const char *fileName, const char *delimiter="\n", bool useTitle=false, bool useLatex=false)
Create a GraphViz .dot file visualizing the expression tree headed by this RooAbsArg object.
void substituteServer(RooAbsArg *oldServer, RooAbsArg *newServer)
Set by the RooFitDriver for this arg to retrieve its result in the run context.
bool getTransientAttribute(const Text_t *name) const
Check if a named attribute is set.
virtual void operModeHook()
Definition RooAbsArg.h:526
virtual void optimizeDirtyHook(const RooArgSet *)
Definition RooAbsArg.h:528
bool recursiveCheckObservables(const RooArgSet *nset) const
Recursively call checkObservables on all nodes in the expression tree.
bool isValueServer(const RooAbsArg &arg) const
Check if this is serving values to arg.
Definition RooAbsArg.h:157
bool localNoDirtyInhibit() const
Definition RooAbsArg.h:632
Int_t numCaches() const
Return number of registered caches.
virtual bool checkObservables(const RooArgSet *nset) const
Overloadable function in which derived classes can implement consistency checks of the variables.
RooAbsArg()
Default constructor.
void attachDataSet(const RooAbsData &set)
Replace server nodes with names matching the dataset variable names with those data set variables,...
TIteratorToSTLInterface< RefCountList_t::Container_t > RefCountListLegacyIterator_t
Definition RooAbsArg.h:79
RooAbsArg * findServer(const char *name) const
Return server of this with name name. Returns nullptr if not found.
Definition RooAbsArg.h:147
void treeNodeServerList(RooAbsCollection *list, const RooAbsArg *arg=nullptr, bool doBranch=true, bool doLeaf=true, bool valueOnly=false, bool recurseNonDerived=false) const
Fill supplied list with nodes of the arg tree, following all server links, starting with ourself as t...
bool IsSortable() const override
Definition RooAbsArg.h:290
RooAbsArg * findNewServer(const RooAbsCollection &newSet, bool nameChange) const
Find the new server in the specified set that matches the old server.
OperMode operMode() const
Query the operation mode of this node.
Definition RooAbsArg.h:419
Abstract base class for data members of RooAbsArgs that cache other (composite) RooAbsArg expressions...
Definition RooAbsCache.h:27
Abstract container object that can hold multiple RooAbsArg objects.
Abstract base class for a data collection.
Abstract base class for binned and unbinned datasets.
Definition RooAbsData.h:57
Abstract interface for proxy classes.
Definition RooAbsProxy.h:37
Abstract base class for objects that represent a real value and implements functionality common to al...
Definition RooAbsReal.h:63
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition RooArgList.h:22
Abstract interface for RooAbsArg proxy classes.
Definition RooArgProxy.h:24
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition RooArgSet.h:24
Concrete proxy for RooArgSet or RooArgList objects.
Combines several disjunct datasets into one.
Container class to hold unbinned data.
Definition RooDataSet.h:32
Singleton class that serves as repository for objects that are expensive to calculate.
RooFitResult is a container class to hold the input and output of a PDF fit to a dataset.
A real-valued function sampled from a multidimensional histogram.
Definition RooHistFunc.h:31
A probability density function sampled from a multidimensional histogram.
Definition RooHistPdf.h:30
Collection class for internal use, storing a collection of RooAbsArg pointers in a doubly linked list...
A 'mix-in' base class that define the standard RooFit plotting and printing methods.
virtual StyleOption defaultPrintStyle(Option_t *opt) const
static std::ostream & defaultPrintStream(std::ostream *os=nullptr)
Return a reference to the current default stream to use in Print().
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,...
Performs hybrid numerical/analytical integrals of RooAbsReal objects.
RooRefArray()=default
RooRefArray & operator=(const RooRefArray &other)=default
void Streamer(TBuffer &) override
Stream an object of class RooRefArray.
RooRefArray(const RooRefArray &other)
Definition RooAbsArg.h:63
TTree-backed data storage.
Uses std::vector to store data columns.
Persistable container for RooFit projects.
Buffer base class used for serializing objects.
Definition TBuffer.h:43
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
An array of TObjects.
Definition TObjArray.h:31
Mother of all ROOT objects.
Definition TObject.h:41
An array of references to TObjects.
Definition TRefArray.h:33
Basic string class.
Definition TString.h:138
A TTree represents a columnar dataset.
Definition TTree.h:89
The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or othe...
Definition CodegenImpl.h:67
T * OwningPtr
An alias for raw pointers for indicating that the return type of a RooFit function is an owning point...
Definition Config.h:35
std::vector< RooAbsProxy * > cache
Definition RooAbsArg.h:618