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 <functional>
22#include <limits>
23#include <map>
24#include <string>
25#include <vector>
26
27class RooCatType;
28class TTree;
30class Roo1DTable;
31class TIterator;
32struct TreeReadBuffer; /// A space to attach TBranches
33
34class RooAbsCategory : public RooAbsArg {
35public:
36 /// The type used to denote a specific category state.
37 using value_type = int;
38
39 // Constructors, assignment etc.
41 RooAbsCategory(const char *name, const char *title);
42 RooAbsCategory(const RooAbsCategory& other, const char* name=nullptr) ;
43 ~RooAbsCategory() override;
44
45 // Value accessors
46 virtual value_type getCurrentIndex() const ;
47 virtual const char* getCurrentLabel() const ;
48
49 const std::map<std::string, value_type>::value_type& getOrdinal(unsigned int n) const;
50 unsigned int getCurrentOrdinalNumber() const;
51
52 bool operator==(value_type index) const ;
54 bool operator==(const char* label) const ;
55 bool operator!=(const char* label) { return !operator==(label);}
56 bool operator==(const RooAbsArg& other) const override ;
57 bool operator!=(const RooAbsArg& other) { return !operator==(other);}
58 bool isIdentical(const RooAbsArg& other, bool assumeSameType=false) const override;
59
60 /// Check if a state with name `label` exists.
61 bool hasLabel(const std::string& label) const {
62 return stateNames().find(label) != stateNames().end();
63 }
64 /// Check if a state with index `index` exists.
65 bool hasIndex(value_type index) const;
66
67 /// Get the name corresponding to the given index.
68 /// \return Name or empty string if index is invalid.
69 const std::string& lookupName(value_type index) const;
70 value_type lookupIndex(const std::string& stateName) const;
71
72
73 bool isSignType(bool mustHaveZero=false) const ;
74
75 Roo1DTable *createTable(const char *label) const ;
76
77 // I/O streaming interface
78 bool readFromStream(std::istream& is, bool compact, bool verbose=false) override ;
79 void writeToStream(std::ostream& os, bool compact) const override ;
80
81 void printValue(std::ostream& os) const override ;
82 void printMultiline(std::ostream& os, Int_t contents, bool verbose=false, TString indent="") const override ;
83
84 virtual bool isIntegrationSafeLValue(const RooArgSet* /*set*/) const {
85 // Is this l-value object safe for use as integration observable
86 return true ;
87 }
88
89 RooFit::OwningPtr<RooAbsArg> createFundamental(const char* newname=nullptr) const override;
90
91 /// Iterator for category state names. Points to pairs of index and name.
92 std::map<std::string, value_type>::const_iterator begin() const {
93 return stateNames().cbegin();
94 }
95 /// Iterator for category state names. Points to pairs of index and name.
96 std::map<std::string, value_type>::const_iterator end() const {
97 return stateNames().cend();
98 }
99 /// Number of states defined.
100 std::size_t size() const {
101 return stateNames().size();
102 }
103 /// If there are no states defined
104 bool empty() const {
105 return stateNames().empty();
106 }
107
108 bool isCategory() const override { return true; }
109
110 /// \name Legacy interface
111 /// Previous versions of RooAbsCategory were based on RooCatType, a class containing a state and a label.
112 /// It has been replaced by integers, which use less space and allow for faster access. The following part of the interface
113 /// should not be used if possible.
114 /// Since RooCatType in essence is only an index and a state name, equivalent functionality can be achieved using begin()
115 /// and end() to iterate through pairs of <index, stateName> and by using using lookupName() and lookupIndex().
116 /// @{
117 const RooCatType*
118 R__SUGGEST_ALTERNATIVE("This interface is inefficient. Use lookupName()")
119 lookupType(value_type index, bool printError=false) const;
122 lookupType(const char* label, bool printError=false) const;
125 lookupType(const RooCatType& type, bool printError=false) const;
126 TIterator*
129 /// Return number of types defined (in range named rangeName if rangeName!=nullptr)
130 Int_t numTypes(const char* /*rangeName*/=nullptr) const {
131 return stateNames().size();
132 }
133 /// Retrieve the current index. Use getCurrentIndex() for more clarity.
134 Int_t getIndex() const { return getCurrentIndex(); }
135 /// Retrieve current label. Use getCurrentLabel() for more clarity.
136 const char* getLabel() const { return getCurrentLabel(); }
137protected:
138 virtual bool
139 R__SUGGEST_ALTERNATIVE("This interface is inefficient. Use hasIndex() or hasLabel().")
141 /// \deprecated Use defineState(const std::string& label)
144 defineType(const char* label);
145 /// \deprecated Use defineState(const std::string& label, value_type index)
148 defineType(const char* label, int index);
149 /// \deprecated Use defineStateUnchecked(const std::string& label, value_type index)
152 defineTypeUnchecked(const char* label, value_type index);
153 /// @}
154
155
157 /// Access the map of state names to index numbers. Triggers a recomputation
158 /// if the shape is dirty.
159 const std::map<std::string, value_type>& stateNames() const {
160 if (isShapeDirty()) {
161 _legacyStates.clear();
162 const_cast<RooAbsCategory*>(this)->recomputeShape();
164 }
165
166 return _stateNames;
167 }
168 /// \copydoc stateNames() const
169 std::map<std::string, value_type>& stateNames() {
170 if (isShapeDirty()) {
171 _legacyStates.clear();
174 }
175
176 //Somebody might modify the states
178
179 return _stateNames;
180 }
181
182 /// Evaluate the category state and return.
183 /// The returned state index should correspond to a state name that has been defined via e.g. defineType().
184 virtual value_type evaluate() const = 0;
185
186 // Type definition management
187 virtual const std::map<std::string, RooAbsCategory::value_type>::value_type& defineState(const std::string& label);
188 virtual const std::map<std::string, RooAbsCategory::value_type>::value_type& defineState(const std::string& label, value_type index);
189
190 void defineStateUnchecked(const std::string& label, value_type index);
191 void clearTypes() ;
192
193 bool isValid() const override {
194 return hasIndex(_currentIndex);
195 }
196
197 /// If a category depends on the shape of others, i.e.\ its state numbers or names depend
198 /// on the states of other categories, this function has to be implemented to recompute
199 /// _stateNames and _insertionOrder.
200 /// If one of these two changes, setShapeDirty() has to be called to propagate this information
201 /// to possible users of this category.
202 virtual void recomputeShape() = 0;
203
204 friend class RooVectorDataStore ;
205 void syncCache(const RooArgSet* set=nullptr) override ;
206 void copyCache(const RooAbsArg* source, bool valueOnly=false, bool setValueDirty=true) override ;
207 void setCachedValue(double value, bool notifyClients = true) final;
208 void attachToTree(TTree& t, Int_t bufSize=32000) override ;
210 void setTreeBranchStatus(TTree& t, bool active) override ;
211 void fillTreeBranch(TTree& t) override ;
212
215
216
217 mutable value_type _currentIndex{std::numeric_limits<int>::min()}; ///< Current category state
218 std::map<std::string, value_type> _stateNames; ///< Map state names to index numbers. Make sure state names are updated in recomputeShape().
219 std::vector<std::string> _insertionOrder; ///< Keeps track in which order state numbers have been inserted. Make sure this is updated in recomputeShape().
220 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.
221
222 static const decltype(_stateNames)::value_type& invalidCategory();
223
224private:
225 TreeReadBuffer *_treeReadBuffer = nullptr; //! A buffer for reading values from trees
226
227 ClassDefOverride(RooAbsCategory, 4) // Abstract discrete variable
228};
229
230#endif
#define R__SUGGEST_ALTERNATIVE(ALTERNATIVE)
Definition RConfig.hxx:520
#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 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
const_iterator end() const
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:76
void setShapeDirty()
Notify that a shape-like property (e.g. binning) has changed.
Definition RooAbsArg.h:431
bool isShapeDirty() const
Definition RooAbsArg.h:350
void setValueDirty()
Mark the element dirty. This forces a re-evaluation when a value is requested.
Definition RooAbsArg.h:425
void clearShapeDirty() const
Definition RooAbsArg.h:542
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.
static const decltype(_stateNames) ::value_type & invalidCategory()
A category state to signify an invalid category.
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.
TreeReadBuffer * _treeReadBuffer
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.
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.
void attachToVStore(RooVectorDataStore &vstore) override
Attach the category index and label to as branches to the given vector store.
value_type lookupIndex(const std::string &stateName) const
Find the index number corresponding to the state name.
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:24
RooCatType is an auxiliary class for RooAbsCategory and defines a a single category state.
Uses std::vector to store data columns.
Iterator abstract base class.
Definition TIterator.h:30
Basic string class.
Definition TString.h:138
A TTree represents a columnar dataset.
Definition TTree.h:89
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:35