Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooAbsCategory.h
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * File: $Id: RooAbsCategory.h,v 1.38 2007/05/11 09:11:30 verkerke 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_CATEGORY
17#define ROO_ABS_CATEGORY
18
19#include "RooAbsArg.h"
20
21#include <string>
22#include <map>
23#include <functional>
24#include <vector>
25
26class RooCatType;
27class TTree;
29class Roo1DTable;
30class TIterator;
31struct TreeReadBuffer; /// A space to attach TBranches
32
33class RooAbsCategory : public RooAbsArg {
34public:
35 /// The type used to denote a specific category state.
36 using value_type = int;
37
38 // Constructors, assignment etc.
40 RooAbsCategory(const char *name, const char *title);
41 RooAbsCategory(const RooAbsCategory& other, const char* name=nullptr) ;
42 ~RooAbsCategory() override;
43
44 // Value accessors
45 virtual value_type getCurrentIndex() const ;
46 virtual const char* getCurrentLabel() const ;
47
48 const std::map<std::string, value_type>::value_type& getOrdinal(unsigned int n) const;
49 unsigned int getCurrentOrdinalNumber() const;
50
51 bool operator==(value_type index) const ;
53 bool operator==(const char* label) const ;
54 bool operator!=(const char* label) { return !operator==(label);}
55 bool operator==(const RooAbsArg& other) const override ;
56 bool operator!=(const RooAbsArg& other) { return !operator==(other);}
57 bool isIdentical(const RooAbsArg& other, bool assumeSameType=false) const override;
58
59 /// Check if a state with name `label` exists.
60 bool hasLabel(const std::string& label) const {
61 return stateNames().find(label) != stateNames().end();
62 }
63 /// Check if a state with index `index` exists.
64 bool hasIndex(value_type index) const;
65
66 /// Get the name corresponding to the given index.
67 /// \return Name or empty string if index is invalid.
68 const std::string& lookupName(value_type index) const;
69 value_type lookupIndex(const std::string& stateName) const;
70
71
72 bool isSignType(bool mustHaveZero=false) const ;
73
74 Roo1DTable *createTable(const char *label) const ;
75
76 // I/O streaming interface
77 bool readFromStream(std::istream& is, bool compact, bool verbose=false) override ;
78 void writeToStream(std::ostream& os, bool compact) const override ;
79
80 void printValue(std::ostream& os) const override ;
81 void printMultiline(std::ostream& os, Int_t contents, bool verbose=false, TString indent="") const override ;
82
83 virtual bool isIntegrationSafeLValue(const RooArgSet* /*set*/) const {
84 // Is this l-value object safe for use as integration observable
85 return true ;
86 }
87
88 RooFit::OwningPtr<RooAbsArg> createFundamental(const char* newname=nullptr) const override;
89
90 /// Iterator for category state names. Points to pairs of index and name.
91 std::map<std::string, value_type>::const_iterator begin() const {
92 return stateNames().cbegin();
93 }
94 /// Iterator for category state names. Points to pairs of index and name.
95 std::map<std::string, value_type>::const_iterator end() const {
96 return stateNames().cend();
97 }
98 /// Number of states defined.
99 std::size_t size() const {
100 return stateNames().size();
101 }
102 /// If there are no states defined
103 bool empty() const {
104 return stateNames().empty();
105 }
106
107 bool isCategory() const override { return true; }
108
109 /// \name Legacy interface
110 /// Previous versions of RooAbsCategory were based on RooCatType, a class containing a state and a label.
111 /// It has been replaced by integers, which use less space and allow for faster access. The following part of the interface
112 /// should not be used if possible.
113 /// Since RooCatType in essence is only an index and a state name, equivalent functionality can be achieved using begin()
114 /// and end() to iterate through pairs of <index, stateName> and by using using lookupName() and lookupIndex().
115 /// @{
116 const RooCatType*
117 R__SUGGEST_ALTERNATIVE("This interface is inefficient. Use lookupName()")
118 lookupType(value_type index, bool printError=false) const;
119 const RooCatType*
120 R__SUGGEST_ALTERNATIVE("This interface is inefficient. Use lookupIndex()")
121 lookupType(const char* label, bool printError=false) const;
122 const RooCatType*
123 R__SUGGEST_ALTERNATIVE("This interface is inefficient. Use lookupName() / lookupIndex()")
124 lookupType(const RooCatType& type, bool printError=false) const;
125 TIterator*
126 R__SUGGEST_ALTERNATIVE("This interface is inefficient. Use begin(), end() or range-based for loops.")
127 typeIterator() const;
128 /// Return number of types defined (in range named rangeName if rangeName!=nullptr)
129 Int_t numTypes(const char* /*rangeName*/=nullptr) const {
130 return stateNames().size();
131 }
132 /// Retrieve the current index. Use getCurrentIndex() for more clarity.
133 Int_t getIndex() const { return getCurrentIndex(); }
134 /// Retrieve current label. Use getCurrentLabel() for more clarity.
135 const char* getLabel() const { return getCurrentLabel(); }
136protected:
137 virtual bool
138 R__SUGGEST_ALTERNATIVE("This interface is inefficient. Use hasIndex() or hasLabel().")
139 isValid(const RooCatType& value) const ;
140 /// \deprecated Use defineState(const std::string& label)
141 const RooCatType*
142 R__SUGGEST_ALTERNATIVE("This interface is inefficient. Use defineState().")
143 defineType(const char* label);
144 /// \deprecated Use defineState(const std::string& label, value_type index)
145 const RooCatType*
146 R__SUGGEST_ALTERNATIVE("This interface is inefficient. Use defineState().")
147 defineType(const char* label, int index);
148 /// \deprecated Use defineStateUnchecked(const std::string& label, value_type index)
149 const RooCatType*
150 R__SUGGEST_ALTERNATIVE("This interface is inefficient. Use defineTypeUnchecked().")
151 defineTypeUnchecked(const char* label, value_type index);
152 /// @}
153
154
155protected:
156 /// Access the map of state names to index numbers. Triggers a recomputation
157 /// if the shape is dirty.
158 const std::map<std::string, value_type>& stateNames() const {
159 if (isShapeDirty()) {
160 _legacyStates.clear();
161 const_cast<RooAbsCategory*>(this)->recomputeShape();
163 }
164
165 return _stateNames;
166 }
167 /// \copydoc stateNames() const
168 std::map<std::string, value_type>& stateNames() {
169 if (isShapeDirty()) {
170 _legacyStates.clear();
173 }
174
175 //Somebody might modify the states
177
178 return _stateNames;
179 }
180
181 /// Evaluate the category state and return.
182 /// The returned state index should correspond to a state name that has been defined via e.g. defineType().
183 virtual value_type evaluate() const = 0;
184
185 // Type definition management
186 virtual const std::map<std::string, RooAbsCategory::value_type>::value_type& defineState(const std::string& label);
187 virtual const std::map<std::string, RooAbsCategory::value_type>::value_type& defineState(const std::string& label, value_type index);
188
189 void defineStateUnchecked(const std::string& label, value_type index);
190 void clearTypes() ;
191
192 bool isValid() const override {
193 return hasIndex(_currentIndex);
194 }
195
196 /// If a category depends on the shape of others, i.e.\ its state numbers or names depend
197 /// on the states of other categories, this function has to be implemented to recompute
198 /// _stateNames and _insertionOrder.
199 /// If one of these two changes, setShapeDirty() has to be called to propagate this information
200 /// to possible users of this category.
201 virtual void recomputeShape() = 0;
202
203 friend class RooVectorDataStore ;
204 void syncCache(const RooArgSet* set=nullptr) override ;
205 void copyCache(const RooAbsArg* source, bool valueOnly=false, bool setValueDirty=true) override ;
206 void setCachedValue(double value, bool notifyClients = true) final;
207 void attachToTree(TTree& t, Int_t bufSize=32000) override ;
208 void attachToVStore(RooVectorDataStore& vstore) override ;
209 void setTreeBranchStatus(TTree& t, bool active) override ;
210 void fillTreeBranch(TTree& t) override ;
211
214
215
216 mutable value_type _currentIndex{std::numeric_limits<int>::min()}; ///< Current category state
217 std::map<std::string, value_type> _stateNames; ///< Map state names to index numbers. Make sure state names are updated in recomputeShape().
218 std::vector<std::string> _insertionOrder; ///< Keeps track in which order state numbers have been inserted. Make sure this is updated in recomputeShape().
219 mutable std::map<value_type, std::unique_ptr<RooCatType, std::function<void(RooCatType*)>> > _legacyStates; ///<! Map holding pointers to RooCatType instances. Only for legacy interface. Don't use if possible.
220
221 static const decltype(_stateNames)::value_type& invalidCategory();
222
223private:
224 std::unique_ptr<TreeReadBuffer> _treeReadBuffer; //! A buffer for reading values from trees
225
226 ClassDefOverride(RooAbsCategory, 4) // Abstract discrete variable
227};
228
229#endif
#define R__SUGGEST_ALTERNATIVE(ALTERNATIVE)
Definition RConfig.hxx:512
#define ClassDefOverride(name, id)
Definition Rtypes.h:341
static void indent(ostringstream &buf, int indent_level)
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 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 Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
char name[80]
Definition TGX11.cxx:110
One-dimensional table.
Definition Roo1DTable.h:23
Common abstract base class for objects that represent a value and a "shape" in RooFit.
Definition RooAbsArg.h:79
void setShapeDirty()
Notify that a shape-like property (e.g. binning) has changed.
Definition RooAbsArg.h:495
bool isShapeDirty() const
Definition RooAbsArg.h:416
void setValueDirty()
Mark the element dirty. This forces a re-evaluation when a value is requested.
Definition RooAbsArg.h:490
void clearShapeDirty() const
Definition RooAbsArg.h:607
A space to attach TBranches.
virtual void recomputeShape()=0
If a category depends on the shape of others, i.e. its state numbers or names depend on the states of...
std::map< std::string, value_type > & stateNames()
Access the map of state names to index numbers.
virtual value_type getCurrentIndex() const
Return index number of current state.
void setCachedValue(double value, bool notifyClients=true) final
Overwrite the value stored in this object's cache.
unsigned int getCurrentOrdinalNumber() const
Return ordinal number of the current state.
bool hasLabel(const std::string &label) const
Check if a state with name label exists.
virtual const char * getCurrentLabel() const
Return label string of current state.
virtual bool isIntegrationSafeLValue(const RooArgSet *) const
const std::string & lookupName(value_type index) const
Get the name corresponding to the given index.
TIterator * typeIterator() const
bool operator==(value_type index) const
Equality operator with a integer (compares with state index number)
RooCatType * retrieveLegacyState(value_type index) const
Return the legacy RooCatType corresponding to index. If it doesn't exist, create one.
void copyCache(const RooAbsArg *source, bool valueOnly=false, bool setValueDirty=true) override
Copy the cached value from given source and raise dirty flag.
value_type _currentIndex
Current category state.
Roo1DTable * createTable(const char *label) const
Create a table matching the shape of this category.
void defineStateUnchecked(const std::string &label, value_type index)
Internal version of defineState() that does not check if type already exists.
const RooCatType * defineTypeUnchecked(const char *label, value_type index)
void setTreeBranchStatus(TTree &t, bool active) override
(De)activate associate tree branch
const RooCatType * lookupType(value_type index, bool printError=false) const
Find our type corresponding to the specified index, or return nullptr for no match.
void writeToStream(std::ostream &os, bool compact) const override
Write object contents to ostream.
Int_t getIndex() const
Retrieve the current index. Use getCurrentIndex() for more clarity.
value_type nextAvailableStateIndex() const
bool operator!=(const char *label)
const char * getLabel() const
Retrieve current label. Use getCurrentLabel() for more clarity.
bool readFromStream(std::istream &is, bool compact, bool verbose=false) override
Read object contents from stream (dummy for now)
bool isSignType(bool mustHaveZero=false) const
Determine if category has 2 or 3 states with index values -1,0,1.
std::map< std::string, value_type >::const_iterator end() const
Iterator for category state names. Points to pairs of index and name.
std::map< std::string, value_type >::const_iterator begin() const
Iterator for category state names. Points to pairs of index and name.
virtual const std::map< std::string, RooAbsCategory::value_type >::value_type & defineState(const std::string &label)
Define a new state with given label.
virtual value_type evaluate() const =0
Evaluate the category state and return.
int value_type
The type used to denote a specific category state.
bool operator!=(const RooAbsArg &other)
Int_t numTypes(const char *=nullptr) const
Return number of types defined (in range named rangeName if rangeName!=nullptr)
void syncCache(const RooArgSet *set=nullptr) override
Explicitly synchronize RooAbsCategory internal cache.
const std::map< std::string, value_type >::value_type & getOrdinal(unsigned int n) const
Return name and index of the nth defined state.
std::size_t size() const
Number of states defined.
RooFit::OwningPtr< RooAbsArg > createFundamental(const char *newname=nullptr) const override
Create a RooCategory fundamental object with our properties.
void printMultiline(std::ostream &os, Int_t contents, bool verbose=false, TString indent="") const override
Print info about this object to the specified stream.
std::map< value_type, std::unique_ptr< RooCatType, std::function< void(RooCatType *)> > > _legacyStates
! Map holding pointers to RooCatType instances. Only for legacy interface. Don't use if possible.
bool isIdentical(const RooAbsArg &other, bool assumeSameType=false) const override
~RooAbsCategory() override
Destructor.
std::vector< std::string > _insertionOrder
Keeps track in which order state numbers have been inserted. Make sure this is updated in recomputeSh...
std::map< std::string, value_type > _stateNames
Map state names to index numbers. Make sure state names are updated in recomputeShape().
bool isValid() const override
WVE (08/21/01) Probably obsolete now.
const RooCatType * defineType(const char *label)
const std::map< std::string, value_type > & stateNames() const
Access the map of state names to index numbers.
bool hasIndex(value_type index) const
Check if a state with index index exists.
void attachToVStore(RooVectorDataStore &vstore) override
Attach the category index and label to as branches to the given vector store.
static const decltype(_stateNames) ::value_type & invalidCategory()
A category state to signify an invalid category.
value_type lookupIndex(const std::string &stateName) const
Find the index number corresponding to the state name.
std::unique_ptr< TreeReadBuffer > _treeReadBuffer
void attachToTree(TTree &t, Int_t bufSize=32000) override
Attach the category index and label as branches to the given TTree.
void fillTreeBranch(TTree &t) override
Fill tree branches associated with current object with current value.
bool empty() const
If there are no states defined.
bool isCategory() const override
void clearTypes()
Delete all currently defined states.
void printValue(std::ostream &os) const override
Print value (label name)
bool operator!=(value_type index)
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition RooArgSet.h:55
RooCatType is an auxiliary class for RooAbsCategory and defines a a single category state.
RooVectorDataStore uses std::vectors to store data columns.
Iterator abstract base class.
Definition TIterator.h:30
Basic string class.
Definition TString.h:139
A TTree represents a columnar dataset.
Definition TTree.h:79
const Int_t n
Definition legend1.C:16
for(Int_t i=0;i< n;i++)
Definition legend1.C:18
T * OwningPtr
An alias for raw pointers for indicating that the return type of a RooFit function is an owning point...
Definition Config.h:43