Logo ROOT  
Reference Guide
RooAbsCollection.h
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * File: $Id: RooAbsCollection.h,v 1.26 2007/08/09 19:55:47 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_COLLECTION
17#define ROO_ABS_COLLECTION
18
19#include "TObject.h"
20#include "TString.h"
21#include "RooAbsArg.h"
22#include "RooPrintable.h"
23#include "RooCmdArg.h"
24#include "RooLinkedListIter.h"
25
26// The range casts are not used in this file, but if you want to work with
27// RooFit collections you also want to have static_range_cast and
28// dynamic_range_cast available without including RangeCast.h every time.
29#include "ROOT/RRangeCast.hxx"
30
31#include "ROOT/RSpan.hxx"
32
33#include <string>
34#include <unordered_map>
35#include <vector>
36#include <type_traits>
37#include <memory>
38
39
40// To make ROOT::RangeStaticCast available under the name static_range_cast.
41template <typename T, typename Range_t>
43{
44 return ROOT::RangeStaticCast<T>(std::forward<Range_t>(coll));
45}
46
47
48// To make ROOT::RangeDynCast available under the dynamic_range_cast.
49template <typename T, typename Range_t>
51{
52 return ROOT::RangeDynCast<T>(std::forward<Range_t>(coll));
53}
54
55
56class RooCmdArg;
57
58namespace RooFit {
59namespace Detail {
60struct HashAssistedFind;
61}
62}
63
64class RooAbsCollection : public TObject, public RooPrintable {
65public:
66 using Storage_t = std::vector<RooAbsArg*>;
67 using const_iterator = Storage_t::const_iterator;
68
69
70 // Constructors, assignment etc.
72 RooAbsCollection(const char *name);
73 virtual TObject* clone(const char* newname) const = 0 ;
74 virtual TObject* create(const char* newname) const = 0 ;
75 TObject* Clone(const char* newname=0) const override {
76 return clone(newname?newname:GetName()) ;
77 }
78 ~RooAbsCollection() override;
79
80 // Create a copy of an existing list. New variables cannot be added
81 // to a copied list. The variables in the copied list are independent
82 // of the original variables.
83 RooAbsCollection(const RooAbsCollection& other, const char *name="");
85
86 void assign(const RooAbsCollection& other) const;
87 RooAbsCollection &assignValueOnly(const RooAbsCollection& other, bool forceIfSizeOne=false);
88 void assignFast(const RooAbsCollection& other, bool setValDirty=true) const;
89
90 // Move constructor
92
93 // Copy list and contents (and optionally 'deep' servers)
94 RooAbsCollection *snapshot(bool deepCopy=true) const ;
95 bool snapshot(RooAbsCollection& output, bool deepCopy=true) const ;
96
97 /// Set the size at which the collection will automatically start using an extra
98 /// lookup table instead of performing a linear search.
99 void setHashTableSize(Int_t number) {
101 }
102 /// Query the size at which the collection will automatically start using an extra
103 /// lookup table instead of performing a linear search.
106 }
107
108 /// Const access to the underlying stl container.
109 Storage_t const& get() const { return _list; }
110
111 // List content management
112 virtual bool add(const RooAbsArg& var, bool silent=false) ;
113 virtual bool addOwned(RooAbsArg& var, bool silent=false);
114 bool addOwned(std::unique_ptr<RooAbsArg> var, bool silent=false);
115 virtual RooAbsArg *addClone(const RooAbsArg& var, bool silent=false) ;
116 virtual bool replace(const RooAbsArg& var1, const RooAbsArg& var2) ;
117 virtual bool remove(const RooAbsArg& var, bool silent=false, bool matchByNameOnly=false) ;
118 virtual void removeAll() ;
119
120 template<typename Iterator_t,
121 typename value_type = typename std::remove_pointer<typename std::iterator_traits<Iterator_t>::value_type>,
123 bool add(Iterator_t beginIt, Iterator_t endIt, bool silent=false) {
124 bool result = false ;
125 _list.reserve(_list.size() + std::distance(beginIt, endIt));
126 for (auto it = beginIt; it != endIt; ++it) {
127 result |= add(**it,silent);
128 }
129 return result;
130 }
131 ////////////////////////////////////////////////////////////////////////////////
132 /// Add a collection of arguments to this collection by calling add()
133 /// for each element in the source collection
134 bool add(const RooAbsCollection& list, bool silent=false) {
135 return add(list._list.begin(), list._list.end(), silent);
136 }
137 virtual bool addOwned(const RooAbsCollection& list, bool silent=false);
138 bool addOwned(RooAbsCollection&& list, bool silent=false);
139 virtual void addClone(const RooAbsCollection& list, bool silent=false);
140 bool replace(const RooAbsCollection &other);
141 bool remove(const RooAbsCollection& list, bool silent=false, bool matchByNameOnly=false) ;
142 template<class forwardIt>
143 void remove(forwardIt rangeBegin, forwardIt rangeEnd, bool silent = false, bool matchByNameOnly = false) {
144 for (forwardIt it = rangeBegin; it != rangeEnd; ++it) {
145 static_assert(std::is_same<
146 typename std::iterator_traits<forwardIt>::value_type,
147 RooAbsArg*>::value, "Can only remove lists of RooAbsArg*.");
148 auto castedElm = static_cast<RooAbsArg*>(*it);
149 remove(*castedElm, silent, matchByNameOnly);
150 }
151 }
152
153 // Utilities functions when used as configuration object
154 double getRealValue(const char* name, double defVal=0, bool verbose=false) const ;
155 const char* getCatLabel(const char* name, const char* defVal="", bool verbose=false) const ;
156 Int_t getCatIndex(const char* name, Int_t defVal=0, bool verbose=false) const ;
157 const char* getStringValue(const char* name, const char* defVal="", bool verbose=false) const ;
158 bool setRealValue(const char* name, double newVal=0, bool verbose=false) ;
159 bool setCatLabel(const char* name, const char* newVal="", bool verbose=false) ;
160 bool setCatIndex(const char* name, Int_t newVal=0, bool verbose=false) ;
161 bool setStringValue(const char* name, const char* newVal="", bool verbose=false) ;
162
163 // Group operations on AbsArgs
164 void setAttribAll(const Text_t* name, bool value=true) ;
165
166 // List search methods
167 RooAbsArg *find(const char *name) const ;
168 RooAbsArg *find(const RooAbsArg&) const ;
169
170 /// Find object by name in the collection
171 TObject* FindObject(const char* name) const override { return find(name); }
172
173 /// Find object in the collection, Note: matching by object name, like the find() method
174 TObject* FindObject(const TObject* obj) const override { auto arg = dynamic_cast<const RooAbsArg*>(obj); return (arg) ? find(*arg) : nullptr; }
175
176 /// Check if collection contains an argument with the same name as var.
177 /// To check for a specific instance, use containsInstance().
178 bool contains(const RooAbsArg& var) const {
179 return find(var) != nullptr;
180 }
181 /// Check if this exact instance is in this collection.
182 virtual bool containsInstance(const RooAbsArg& var) const {
183 return std::find(_list.begin(), _list.end(), &var) != _list.end();
184 }
185 RooAbsCollection* selectByAttrib(const char* name, bool value) const ;
186 bool selectCommon(const RooAbsCollection& refColl, RooAbsCollection& outColl) const ;
187 RooAbsCollection* selectCommon(const RooAbsCollection& refColl) const ;
188 RooAbsCollection* selectByName(const char* nameList, bool verbose=false) const ;
189 bool equals(const RooAbsCollection& otherColl) const ;
190 bool hasSameLayout(const RooAbsCollection& other) const;
191
192 template<typename Iterator_t,
193 typename value_type = typename std::remove_pointer<typename std::iterator_traits<Iterator_t>::value_type>,
195 bool overlaps(Iterator_t otherCollBegin, Iterator_t otherCollEnd) const {
196 for (auto it = otherCollBegin; it != otherCollEnd; ++it) {
197 if (find(**it)) {
198 return true ;
199 }
200 }
201 return false ;
202 }
203
204 ////////////////////////////////////////////////////////////////////////////////
205 /// Check if this and other collection have common entries
206 bool overlaps(const RooAbsCollection& otherColl) const {
207 return overlaps(otherColl._list.begin(), otherColl._list.end());
208 }
209
210 /// TIterator-style iteration over contained elements.
211 /// \note These iterators are slow. Use begin() and end() or
212 /// range-based for loop instead.
213 inline TIterator* createIterator(bool dir = kIterForward) const
214 R__SUGGEST_ALTERNATIVE("begin(), end() and range-based for loops.") {
215 // Create and return an iterator over the elements in this collection
216 return new RooLinkedListIter(makeLegacyIterator(dir));
217 }
218
219 /// TIterator-style iteration over contained elements.
220 /// \note This iterator is slow. Use begin() and end() or range-based for loop instead.
222 R__SUGGEST_ALTERNATIVE("begin(), end() and range-based for loops.") {
224 }
225
226 /// One-time forward iterator.
227 /// \note Use begin() and end() or range-based for loop instead.
229 R__SUGGEST_ALTERNATIVE("begin(), end() and range-based for loops.") {
231 }
232
234 return _list.begin();
235 }
236
238 return _list.end();
239 }
240
241 Storage_t::const_reverse_iterator rbegin() const {
242 return _list.rbegin();
243 }
244
245 Storage_t::const_reverse_iterator rend() const {
246 return _list.rend();
247 }
248
249 Storage_t::size_type size() const {
250 return _list.size();
251 }
252
253 bool empty() const {
254 return _list.empty();
255 }
256
257 void reserve(Storage_t::size_type count) {
258 _list.reserve(count);
259 }
260
261 /// Clear contents. If the collection is owning, it will also delete the contents.
262 void clear() {
263 removeAll();
264 }
265
266 /// Return the number of elements in the collection
267 inline Int_t getSize() const R__SUGGEST_ALTERNATIVE("size() returns true size.") {
268 return _list.size();
269 }
270
271 inline RooAbsArg *first() const {
272 // Return the first element in this collection
273 // calling front on an empty container is undefined
274 return _list.empty() ? nullptr : _list.front();
275 }
276
277 RooAbsArg * operator[](Storage_t::size_type i) const {
278 return _list[i];
279 }
280
281
282 /// Returns index of given arg, or -1 if arg is not in the collection.
283 inline Int_t index(const RooAbsArg* arg) const {
284 auto item = std::find(_list.begin(), _list.end(), arg);
285 return item != _list.end() ? item - _list.begin() : -1;
286 }
287
288 /// Returns index of given arg, or -1 if arg is not in the collection.
289 inline Int_t index(const RooAbsArg& arg) const {
290 return index(&arg);
291 }
292
293 Int_t index(const char* name) const;
294
295 inline void Print(Option_t *options= 0) const override {
296 // Printing interface (human readable)
298 }
299 std::string contentsString() const ;
300
301
302 void printName(std::ostream& os) const override ;
303 void printTitle(std::ostream& os) const override ;
304 void printClassName(std::ostream& os) const override ;
305 void printValue(std::ostream& os) const override ;
306 void printMultiline(std::ostream& os, Int_t contents, bool verbose=false, TString indent="") const override ;
307
308 Int_t defaultPrintContents(Option_t* opt) const override ;
309
310 // Latex printing methods
311 void printLatex(const RooCmdArg& arg1=RooCmdArg(), const RooCmdArg& arg2=RooCmdArg(),
312 const RooCmdArg& arg3=RooCmdArg(), const RooCmdArg& arg4=RooCmdArg(),
313 const RooCmdArg& arg5=RooCmdArg(), const RooCmdArg& arg6=RooCmdArg(),
314 const RooCmdArg& arg7=RooCmdArg(), const RooCmdArg& arg8=RooCmdArg()) const ;
315 void printLatex(std::ostream& ofs, Int_t ncol, const char* option="NEYU", Int_t sigDigit=1,
316 const RooLinkedList& siblingLists=RooLinkedList(), const RooCmdArg* formatCmd=0) const ;
317
318 void setName(const char *name) {
319 // Set name of collection
320 _name= name;
321 }
322 const char* GetName() const override {
323 // Return namer of collection
324 return _name.Data() ;
325 }
326 bool isOwning() const {
327 // Does collection own contents?
328 return _ownCont ;
329 }
330
331 bool allInRange(const char* rangeSpec) const ;
332
333 void dump() const ;
334
335 void releaseOwnership() { _ownCont = false ; }
336 void takeOwnership() { _ownCont = true ; }
337
338 void sort(bool reverse = false);
339 void sortTopologically();
340
341 void RecursiveRemove(TObject *obj) override;
342
343 void useHashMapForFind(bool flag) const;
344
345 // For use in the RooArgList/Set(std::vector<RooAbsArgPtrOrDouble> const&) constructor.
346 // Can be replaced with std::variant when C++17 is the minimum supported standard.
348 RooAbsArgPtrOrDouble(RooAbsArg & arg) : ptr{&arg}, hasPtr{true} {}
349 RooAbsArgPtrOrDouble(double x) : val{x}, hasPtr{false} {}
350
351 RooAbsArg * ptr = nullptr;
352 double val = 0.0;
353 bool hasPtr = false;
354 };
355
356protected:
357 Storage_t _list; ///< Actual object storage
359
360 bool _ownCont = false; ///< Flag to identify a list that owns its contents.
361 TString _name; ///< Our name.
362 bool _allRRV = true; ///< All contents are RRV
363
364 void deleteList() ;
365
366 // Support for snapshot method
367 bool addServerClonesToList(const RooAbsArg& var) ;
368
371
372 mutable TNamed* _structureTag{nullptr}; ///<! Structure tag
373 mutable TNamed* _typedStructureTag{nullptr}; ///<! Typed structure tag
374
376
379
380 /// Determine whether it's possible to add a given RooAbsArg to the collection or not.
381 virtual bool canBeAdded(const RooAbsArg& arg, bool silent) const = 0;
382
383 template<class T>
384 static void assert_is_no_temporary(T &&) {
386 "A reference to a temporary RooAbsArg will be passed to a RooAbsCollection constructor! "
387 "This is not allowed, because the collection will not own the arguments. "
388 "Hence, the collection will contain dangling pointers when the temporary goes out of scope."
389 );
390 }
391
392private:
393 std::unique_ptr<LegacyIterator_t> makeLegacyIterator (bool forward = true) const;
394
396 mutable std::unique_ptr<HashAssistedFind> _hashAssistedFind; ///<!
397 std::size_t _sizeThresholdForMapSearch = 100; ///<!
398
399 void insert(RooAbsArg*);
400
401 ClassDefOverride(RooAbsCollection,3) // Collection of RooAbsArg objects
402};
403
404#endif
#define R__SUGGEST_ALTERNATIVE(ALTERNATIVE)
Definition: RConfig.hxx:521
ROOT::RRangeCast< T, true, Range_t > dynamic_range_cast(Range_t &&coll)
ROOT::RRangeCast< T, false, Range_t > static_range_cast(Range_t &&coll)
char Text_t
Definition: RtypesCore.h:62
const char Option_t
Definition: RtypesCore.h:66
#define ClassDefOverride(name, id)
Definition: Rtypes.h:339
static void indent(ostringstream &buf, int indent_level)
const Bool_t kIterForward
Definition: TCollection.h:42
Option_t Option_t option
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
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
char name[80]
Definition: TGX11.cxx:110
Wraps any collection that can be used in range-based loops and applies static_cast<T> or dynamic_cast...
Definition: RRangeCast.hxx:135
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects.
void remove(forwardIt rangeBegin, forwardIt rangeEnd, bool silent=false, bool matchByNameOnly=false)
RooAbsCollection * selectByAttrib(const char *name, bool value) const
Create a subset of the current collection, consisting only of those elements with the specified attri...
bool equals(const RooAbsCollection &otherColl) const
Check if this and other collection have identically-named contents.
std::unique_ptr< HashAssistedFind > _hashAssistedFind
!
virtual void removeAll()
Remove all arguments from our set, deleting them if we own them.
void deleteList()
Delete contents of the list.
virtual bool addOwned(RooAbsArg &var, bool silent=false)
Add an argument and transfer the ownership to the collection.
Int_t getCatIndex(const char *name, Int_t defVal=0, bool verbose=false) const
Get index value of a RooAbsCategory stored in set with given name.
std::vector< RooAbsArg * > Storage_t
TNamed * _typedStructureTag
! Typed structure tag
virtual bool remove(const RooAbsArg &var, bool silent=false, bool matchByNameOnly=false)
Remove the specified argument from our list.
Storage_t const & get() const
Const access to the underlying stl container.
RooAbsCollection & assignValueOnly(const RooAbsCollection &other, bool forceIfSizeOne=false)
Sets the value of any argument in our set that also appears in the other set.
virtual TObject * create(const char *newname) const =0
Int_t defaultPrintContents(Option_t *opt) const override
Define default RooPrinable print options for given Print() flag string For inline printing only show ...
bool allInRange(const char *rangeSpec) const
Return true if all contained object report to have their value inside the specified range.
void assignFast(const RooAbsCollection &other, bool setValDirty=true) const
Functional equivalent of assign() but assumes this and other collection have same layout.
void sortTopologically()
Sort collection topologically: the servers of any RooAbsArg will be before that RooAbsArg in the coll...
const char * getStringValue(const char *name, const char *defVal="", bool verbose=false) const
Get string value of a RooStringVar stored in set with given name.
TNamed * typedStructureTag()
bool contains(const RooAbsArg &var) const
Check if collection contains an argument with the same name as var.
bool empty() const
virtual bool canBeAdded(const RooAbsArg &arg, bool silent) const =0
Determine whether it's possible to add a given RooAbsArg to the collection or not.
RooAbsCollection * snapshot(bool deepCopy=true) const
Take a snap shot of current collection contents.
RooAbsCollection()
Default constructor.
void printValue(std::ostream &os) const override
Print value of collection, i.e.
void Print(Option_t *options=0) const override
This method must be overridden when a class wants to print itself.
Int_t getSize() const
Return the number of elements in the collection.
Storage_t::const_reverse_iterator rend() const
~RooAbsCollection() override
Destructor.
bool setStringValue(const char *name, const char *newVal="", bool verbose=false)
Set string value of a RooStringVar stored in set with given name to newVal.
const char * GetName() const override
Returns name of object.
virtual bool add(const RooAbsArg &var, bool silent=false)
Add the specified argument to list.
void setAttribAll(const Text_t *name, bool value=true)
Set given attribute in each element of the collection by calling each elements setAttribute() functio...
bool overlaps(const RooAbsCollection &otherColl) const
Check if this and other collection have common entries.
void printLatex(const RooCmdArg &arg1=RooCmdArg(), const RooCmdArg &arg2=RooCmdArg(), const RooCmdArg &arg3=RooCmdArg(), const RooCmdArg &arg4=RooCmdArg(), const RooCmdArg &arg5=RooCmdArg(), const RooCmdArg &arg6=RooCmdArg(), const RooCmdArg &arg7=RooCmdArg(), const RooCmdArg &arg8=RooCmdArg()) const
Output content of collection as LaTex table.
virtual RooAbsArg * addClone(const RooAbsArg &var, bool silent=false)
Add a clone of the specified argument to list.
Storage_t::const_reverse_iterator rbegin() const
TObject * FindObject(const TObject *obj) const override
Find object in the collection, Note: matching by object name, like the find() method.
void printTitle(std::ostream &os) const override
Return collection title.
Int_t index(const RooAbsArg *arg) const
Returns index of given arg, or -1 if arg is not in the collection.
RooFIter fwdIterator() const
One-time forward iterator.
TNamed * structureTag()
bool overlaps(Iterator_t otherCollBegin, Iterator_t otherCollEnd) const
bool _allRRV
All contents are RRV.
bool addServerClonesToList(const RooAbsArg &var)
Add clones of servers of given argument to end of list.
RooLinkedListIter iterator(bool dir=kIterForward) const
TIterator-style iteration over contained elements.
const_iterator end() const
bool hasSameLayout(const RooAbsCollection &other) const
Check that all entries where the collections overlap have the same name.
void RecursiveRemove(TObject *obj) override
If one of the TObject we have a referenced to is deleted, remove the reference.
bool setRealValue(const char *name, double newVal=0, bool verbose=false)
Set value of a RooAbsRealLValye stored in set with given name to newVal No error messages are printed...
void assign(const RooAbsCollection &other) const
Sets the value, cache and constant attribute of any argument in our set that also appears in the othe...
TString _name
Our name.
Storage_t::size_type size() const
RooAbsArg * operator[](Storage_t::size_type i) const
RooAbsArg * first() const
static void assert_is_no_temporary(T &&)
virtual bool replace(const RooAbsArg &var1, const RooAbsArg &var2)
Replace var1 with var2 and return true for success.
bool add(const RooAbsCollection &list, bool silent=false)
Add a collection of arguments to this collection by calling add() for each element in the source coll...
void reserve(Storage_t::size_type count)
bool setCatIndex(const char *name, Int_t newVal=0, bool verbose=false)
Set index value of a RooAbsCategoryLValue stored in set with given name to newVal.
void clear()
Clear contents. If the collection is owning, it will also delete the contents.
void printMultiline(std::ostream &os, Int_t contents, bool verbose=false, TString indent="") const override
Implement multiline printing of collection, one line for each contained object showing the requested ...
double getRealValue(const char *name, double defVal=0, bool verbose=false) const
Get value of a RooAbsReal stored in set with given name.
bool setCatLabel(const char *name, const char *newVal="", bool verbose=false)
Set state name of a RooAbsCategoryLValue stored in set with given name to newVal.
Storage_t _list
Actual object storage.
RooAbsCollection * selectByName(const char *nameList, bool verbose=false) const
Create a subset of the current collection, consisting only of those elements with names matching the ...
bool _ownCont
Flag to identify a list that owns its contents.
Int_t index(const RooAbsArg &arg) const
Returns index of given arg, or -1 if arg is not in the collection.
const_iterator begin() const
void printName(std::ostream &os) const override
Return collection name.
void sort(bool reverse=false)
Sort collection using std::sort and name comparison.
std::unique_ptr< LegacyIterator_t > makeLegacyIterator(bool forward=true) const
Factory for legacy iterators.
bool add(Iterator_t beginIt, Iterator_t endIt, bool silent=false)
std::size_t _sizeThresholdForMapSearch
!
void dump() const
Base contents dumper for debugging purposes.
bool selectCommon(const RooAbsCollection &refColl, RooAbsCollection &outColl) const
Create a subset of the current collection, consisting only of those elements that are contained as we...
TObject * FindObject(const char *name) const override
Find object by name in the collection.
TNamed * _structureTag
! Structure tag
const char * getCatLabel(const char *name, const char *defVal="", bool verbose=false) const
Get state name of a RooAbsCategory stored in set with given name.
virtual bool containsInstance(const RooAbsArg &var) const
Check if this exact instance is in this collection.
void useHashMapForFind(bool flag) const
bool isOwning() const
void setHashTableSize(Int_t number)
Set the size at which the collection will automatically start using an extra lookup table instead of ...
std::string contentsString() const
Return comma separated list of contained object names as STL string.
void printClassName(std::ostream &os) const override
Return collection class name.
void setName(const char *name)
RooAbsCollection & operator=(const RooAbsCollection &other)
Assign values from the elements in other to our elements.
Int_t getHashTableSize() const
Query the size at which the collection will automatically start using an extra lookup table instead o...
virtual TObject * clone(const char *newname) const =0
void insert(RooAbsArg *)
Insert an element into the owned collections.
TObject * Clone(const char *newname=0) const override
Make a clone of an object using the Streamer facility.
TIterator * createIterator(bool dir=kIterForward) const
TIterator-style iteration over contained elements.
RooAbsArg * find(const char *name) const
Find object with given name in list.
Storage_t::const_iterator const_iterator
RooCmdArg is a named container for two doubles, two integers two object points and three string point...
Definition: RooCmdArg.h:26
A one-time forward iterator working on RooLinkedList or RooAbsCollection.
A wrapper around TIterator derivatives.
RooLinkedList is an collection class for internal use, storing a collection of RooAbsArg pointers in ...
Definition: RooLinkedList.h:38
RooPlotable is a 'mix-in' base class that define the standard RooFit plotting and printing methods.
Definition: RooPrintable.h:25
virtual StyleOption defaultPrintStyle(Option_t *opt) const
static std::ostream & defaultPrintStream(std::ostream *os=0)
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,...
TIterator and GenericRooFIter front end with STL back end.
Iterator abstract base class.
Definition: TIterator.h:30
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
Mother of all ROOT objects.
Definition: TObject.h:37
Basic string class.
Definition: TString.h:136
const char * Data() const
Definition: TString.h:369
Double_t x[n]
Definition: legend1.C:17
for(Int_t i=0;i< n;i++)
Definition: legend1.C:18
double T(double x)
Definition: ChebyshevPol.h:34
std::pair< Double_t, Double_t > Range_t
Definition: TGLUtil.h:1196
The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or othe...
Definition: Common.h:18
void forward(const LAYERDATA &prevLayerData, LAYERDATA &currLayerData)
apply the weights (and functions) in forward direction of the DNN
Definition: NeuralNet.icc:546
Helper for hash-map-assisted finding of elements by name.
static void output()