Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooAbsCategory.cxx
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * @(#)root/roofitcore:$Id$
5 * Authors: *
6 * WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
7 * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8 * *
9 * Copyright (c) 2000-2005, Regents of the University of California *
10 * and Stanford University. All rights reserved. *
11 * *
12 * Redistribution and use in source and binary forms, *
13 * with or without modification, are permitted according to the terms *
14 * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
15 *****************************************************************************/
16
17/**
18\file RooAbsCategory.cxx
19\class RooAbsCategory
20\ingroup Roofitcore
21
22RooAbsCategory is the base class for objects that represent a discrete value with a finite number of states.
23
24Each state is denoted by an integer and a name. Both can be used to retrieve and
25set states, but referring to states by index is more efficient. Conversion between
26index and name can be done using lookupName() or lookupIndex().
27It is possible to iterate through all defined states using begin() and end().
28
29For category classes deriving from RooAbsCategory, states can only be evaluated, *i.e.*, queried.
30Refer to RooAbsCategoryLValue and its derived classes for categories where states can also be set. The
31simplest category class whose states can be set, queried and saved in a dataset, refer to RooCategory.
32
33### Interface change in ROOT-6.22
34Category data were based in the class RooCatType, holding an index state and a category name truncated to 256
35characters. This wastes 64 bytes of storage space per entry, and prevents fast retrieval of category data.
36Since ROOT-6.22, categories are only represented by an integer. RooAbsCategory::lookupName() can be used to
37retrieve the corresponding state name. There is no limit for the length of the state name.
38
39To not break old code, the old RooCatType interfaces are still available. Whenever possible,
40the following replacements should be used:
41- lookupType() \f$ \rightarrow \f$ lookupName() / lookupIndex()
42- typeIterator() \f$ \rightarrow \f$ range-based for loop / begin() / end()
43- isValidIndex(Int_t index) \f$ \rightarrow \f$ hasIndex()
44- isValid(const RooCatType&) \f$ \rightarrow \f$ hasIndex() / hasLabel()
45**/
46
47#include "RooAbsCategory.h"
48
49#include "RooArgSet.h"
50#include "Roo1DTable.h"
51#include "RooCategory.h"
52#include "RooMsgService.h"
53#include "RooVectorDataStore.h"
55#include "TreeReadBuffer.h"
56
57#include "Compression.h"
58#include "TString.h"
59#include "TTree.h"
60#include "TLeaf.h"
61#include "TBranch.h"
62
63#include <functional>
64#include <memory>
65
66
67/// A category state to signify an invalid category. The category name is empty,
68/// the index is the minimal int.
70 static const decltype(RooAbsCategory::_stateNames)::value_type invalid{"", std::numeric_limits<value_type>::min()};
71 return invalid;
72}
73
74
76
77
78////////////////////////////////////////////////////////////////////////////////
79/// Constructor
80
81RooAbsCategory::RooAbsCategory(const char *name, const char *title) :
82 RooAbsArg(name,title), _currentIndex(0)
83{
86}
87
88
89
90////////////////////////////////////////////////////////////////////////////////
91/// Copy constructor, copies the registered category states from the original.
92
94 RooAbsArg(other,name), _currentIndex(other._currentIndex),
95 _stateNames(other._stateNames),
96 _insertionOrder(other._insertionOrder)
97{
100}
101
102
103
104////////////////////////////////////////////////////////////////////////////////
105/// Destructor
106
108{
109 if (_treeReadBuffer) {
110 delete _treeReadBuffer;
111 }
112 _treeReadBuffer = nullptr;
113}
114
115
116
117////////////////////////////////////////////////////////////////////////////////
118/// Return index number of current state
119
130
131
132
133////////////////////////////////////////////////////////////////////////////////
134/// Return label string of current state.
135
137{
138 const auto index = getCurrentIndex();
139 for (const auto& item : stateNames()) {
140 if (item.second == index)
141 return item.first.c_str();
142 }
143
144 return "";
145}
146
147
148////////////////////////////////////////////////////////////////////////////////
149/// Equality operator with a integer (compares with state index number)
150
155
156
157
158////////////////////////////////////////////////////////////////////////////////
159/// Equality operator with a string (compares with state label string)
160
161bool RooAbsCategory::operator==(const char* label) const
162{
163 return strcmp(label, getCurrentLabel()) == 0;
164}
165
166
167
168////////////////////////////////////////////////////////////////////////////////
169/// Equality operator with another RooAbsArg. Only functional
170/// is also a RooAbsCategory, will return true if index is the same
171
173{
174 const RooAbsCategory* otherCat = dynamic_cast<const RooAbsCategory*>(&other) ;
175 return otherCat ? operator==(otherCat->getCurrentIndex()) : false ;
176}
177
178
179////////////////////////////////////////////////////////////////////////////////
180
182{
183 if (!assumeSameType) {
184 const RooAbsCategory* otherCat = dynamic_cast<const RooAbsCategory*>(&other) ;
185 return otherCat ? operator==(otherCat->getCurrentIndex()) : false ;
186 } else {
187 return getCurrentIndex() == static_cast<const RooAbsCategory&>(other).getCurrentIndex();
188 }
189}
190
191
192////////////////////////////////////////////////////////////////////////////////
193/// Check if a state with index `index` exists.
195{
196 for (const auto& item : stateNames()) {
197 if (item.second == index)
198 return true;
199 }
200
201 return false;
202}
203
204
205////////////////////////////////////////////////////////////////////////////////
206/// Look up the name corresponding to the given index.
207const std::string& RooAbsCategory::lookupName(value_type index) const {
208 for (const auto& item : stateNames()) {
209 if (item.second == index)
210 return item.first;
211 }
212
213 return invalidCategory().first;
214}
215
216////////////////////////////////////////////////////////////////////////////////
217/// Define a new state with given label. The next available
218/// integer is assigned as index value.
219const std::map<std::string, RooAbsCategory::value_type>::value_type& RooAbsCategory::defineState(const std::string& label)
220{
221 return defineState(label, nextAvailableStateIndex());
222}
223
224
225////////////////////////////////////////////////////////////////////////////////
226/// Internal version of defineState() that does not check if type
227/// already exists
229{
230 _stateNames.emplace(label, index);
231 _insertionOrder.push_back(label);
232
233 if (_stateNames.size() == 1)
235
237}
238
239
240
241////////////////////////////////////////////////////////////////////////////////
242/// Define new state with given name and index number.
243
244const std::map<std::string, RooAbsCategory::value_type>::value_type& RooAbsCategory::defineState(const std::string& label, RooAbsCategory::value_type index)
245{
246 auto& theStateNames = stateNames();
247
248 if (hasIndex(index)) {
249 coutE(InputArguments) << "RooAbsCategory::" << __func__ << "(" << GetName() << "): index "
250 << index << " already assigned" << std::endl;
251 return invalidCategory();
252 }
253
254 if (hasLabel(label)) {
255 coutE(InputArguments) << "RooAbsCategory::" << __func__ << "(" << GetName() << "): label "
256 << label << " already assigned or not allowed" << std::endl;
257 return invalidCategory();
258 }
259
260 const auto result = theStateNames.emplace(label, index);
261 _insertionOrder.push_back(label);
262
263 if (theStateNames.size() == 1)
265
267
268 return *(result.first);
269}
270
271
272
273////////////////////////////////////////////////////////////////////////////////
274/// Delete all currently defined states
275
277{
278 _stateNames.clear();
279 _insertionOrder.clear();
281 setShapeDirty() ;
282}
283
284
285////////////////////////////////////////////////////////////////////////////////
286/// Find the index number corresponding to the state name.
287/// \see hasLabel() for checking if a given label has been defined.
288/// \return Index of the category or std::numeric_limits<int>::min() on failure.
290 const auto item = stateNames().find(stateName);
291 if (item != stateNames().end()) {
292 return item->second;
293 }
294
295 return invalidCategory().second;
296}
297
298////////////////////////////////////////////////////////////////////////////////
299/// Find our type that matches the specified type, or return 0 for no match.
300/// \deprecated RooCatType is not used, any more. This function will create one and let it leak.
301/// Use lookupIndex() (preferred) or lookupName() instead.
302const RooCatType* RooAbsCategory::lookupType(const RooCatType &other, bool printError) const
303{
304 return lookupType(other.getVal(), printError);
305}
306
307
308
309////////////////////////////////////////////////////////////////////////////////
310/// Find our type corresponding to the specified index, or return nullptr for no match.
311/// \deprecated RooCatType is not used, any more. This function will create one and let it leak.
312/// Use lookupIndex() (preferred) or lookupName() instead.
314{
315 for (const auto &item : stateNames()) {
316 if (item.second == index) {
318 }
319 }
320
321 if (printError) {
322 coutE(InputArguments) << ClassName() << "::" << GetName() << ":lookupType: no match for index "
323 << index << std::endl;
324 }
325
326 return nullptr;
327}
328
329
330
331////////////////////////////////////////////////////////////////////////////////
332/// Find our type corresponding to the specified label, or return 0 for no match.
333/// \deprecated RooCatType is not used, any more. This function will create one and let it leak.
334/// Use lookupIndex() (preferred) or lookupName() instead.
335const RooCatType* RooAbsCategory::lookupType(const char* label, bool printError) const
336{
337 for (const auto& type : stateNames()) {
338 if(type.first == label)
339 return retrieveLegacyState(type.second);
340 }
341
342 // Try if label represents integer number
343 char* endptr ;
345 if (endptr==label+strlen(label)) {
346 return lookupType(idx);
347 }
348
349 if (printError) {
350 coutE(InputArguments) << ClassName() << "::" << GetName() << ":lookupType: no match for label "
351 << label << std::endl;
352 }
353 return nullptr;
354}
355
356
357////////////////////////////////////////////////////////////////////////////////
358/// Check if given state is defined for this object
359
361{
362 return hasIndex(value.getVal()) ;
363}
364
365
366
367////////////////////////////////////////////////////////////////////////////////
368/// Create a table matching the shape of this category
369
371{
372 return new Roo1DTable(GetName(),label,*this) ;
373}
374
375
376
377////////////////////////////////////////////////////////////////////////////////
378/// Read object contents from stream (dummy for now)
379
380bool RooAbsCategory::readFromStream(std::istream&, bool, bool)
381{
382 return false ;
383}
384
385
386
387////////////////////////////////////////////////////////////////////////////////
388/// Write object contents to ostream
389
390void RooAbsCategory::writeToStream(std::ostream& os, bool /* compact */) const
391{
392 os << getCurrentLabel() ;
393}
394
395
396
397////////////////////////////////////////////////////////////////////////////////
398/// Print value (label name)
399
400void RooAbsCategory::printValue(std::ostream& os) const
401{
402 os << getCurrentLabel() << "(idx = " << getCurrentIndex() << ")" << std::endl;
403}
404
405
406
407////////////////////////////////////////////////////////////////////////////////
408/// Print info about this object to the specified stream. In addition to the info
409/// from RooAbsArg::printStream() we add:
410///
411/// Shape : label, index, defined types
412
413void RooAbsCategory::printMultiline(std::ostream& os, Int_t contents, bool verbose, TString indent) const
414{
415 RooAbsArg::printMultiline(os,contents,verbose,indent);
416
417 os << indent << "--- RooAbsCategory ---" << std::endl;
418 if (stateNames().empty()) {
419 os << indent << " ** No values defined **" << std::endl;
420 return;
421 }
422 os << indent << " Value = " << getCurrentIndex() << " \"" << getCurrentLabel() << ')' << std::endl;
423 os << indent << " Possible states:" << std::endl;
424 indent.Append(" ");
425 for (const auto& type : stateNames()) {
426 os << indent << type.first << '\t' << type.second << "\n";
427 }
428}
429
430
431
432////////////////////////////////////////////////////////////////////////////////
433/// Attach the category index and label to as branches to the given vector store
434
440
441
442
443
444////////////////////////////////////////////////////////////////////////////////
445/// Attach the category index and label as branches to the given
446/// TTree. The index field will be attached as integer with name
447/// `<name>_idx`. If a branch `<name>` exists, it attaches to this branch.
449{
450 // First check if there is an integer branch matching the category name
451 std::string cleanName = cleanBranchName().Data();
452 TBranch* branch = tree.GetBranch(cleanName.c_str());
453 if (!branch) {
454 cleanName += "_idx";
455 branch = tree.GetBranch(cleanName.c_str());
456 }
457
458 if (branch) {
459 TLeaf* leaf = static_cast<TLeaf*>(branch->GetListOfLeaves()->At(0));
460
461 // Check that leaf is _not_ an array
462 Int_t dummy ;
463 TLeaf* counterLeaf = leaf->GetLeafCounter(dummy) ;
464 if (counterLeaf) {
465 coutE(Eval) << "RooAbsCategory::attachToTree(" << GetName() << ") ERROR: TTree branch " << GetName()
466 << " is an array and cannot be attached to a RooAbsCategory" << std::endl;
467 return ;
468 }
469
470 const std::string typeName = leaf->GetTypeName();
471
472
473 // For different type names, store a function to attach
474 std::map<std::string, std::function<std::unique_ptr<TreeReadBuffer>()>> typeMap {
475 {"Float_t", [&](){ return createTreeReadBuffer<Float_t >(cleanName, tree); }},
476 {"Double_t", [&](){ return createTreeReadBuffer<Double_t >(cleanName, tree); }},
477 {"UChar_t", [&](){ return createTreeReadBuffer<UChar_t >(cleanName, tree); }},
478 {"Boolt_", [&](){ return createTreeReadBuffer<Bool_t >(cleanName, tree); }},
479 {"Char_t", [&](){ return createTreeReadBuffer<Char_t >(cleanName, tree); }},
480 {"UInt_t", [&](){ return createTreeReadBuffer<UInt_t >(cleanName, tree); }},
481 {"Long64_t", [&](){ return createTreeReadBuffer<Long64_t >(cleanName, tree); }},
482 {"ULong64_t", [&](){ return createTreeReadBuffer<ULong64_t>(cleanName, tree); }},
483 {"Short_t", [&](){ return createTreeReadBuffer<Short_t >(cleanName, tree); }},
484 {"UShort_t", [&](){ return createTreeReadBuffer<UShort_t >(cleanName, tree); }},
485 };
486
487 auto typeDetails = typeMap.find(typeName);
488 if (typeDetails != typeMap.end()) {
489 coutI(DataHandling) << "RooAbsCategory::attachToTree(" << GetName() << ") TTree " << typeName << " branch \"" << cleanName
490 << "\" will be converted to int." << std::endl;
491 _treeReadBuffer = typeDetails->second().release();
492 } else {
493 if (_treeReadBuffer) {
494 delete _treeReadBuffer;
495 }
496 _treeReadBuffer = nullptr;
497
498 if (typeName == "Int_t") {
499 tree.SetBranchAddress(cleanName.c_str(), &_currentIndex);
500 }
501 else {
502 coutE(InputArguments) << "RooAbsCategory::attachToTree(" << GetName() << ") data type " << typeName << " is not supported." << std::endl;
503 }
504 }
505 } else {
506 void* ptr = &_currentIndex;
507 tree.Branch(cleanName.c_str(), ptr, (cleanName + "/I").c_str(), bufSize);
508 }
509}
510
511
512
513////////////////////////////////////////////////////////////////////////////////
514/// Fill tree branches associated with current object with current value
515
517{
518 // First determine if branch is taken
519 TBranch* idxBranch = t.GetBranch((std::string(GetName()) + "_idx").c_str()) ;
520 if (!idxBranch) {
521 coutF(DataHandling) << "RooAbsCategory::fillTreeBranch(" << GetName() << ") ERROR: not attached to tree" << std::endl;
522 throw std::runtime_error("RooAbsCategory::fillTreeBranch(): Category is not attached to a tree.");
523 }
524
525 idxBranch->Fill() ;
526}
527
528
529
530////////////////////////////////////////////////////////////////////////////////
531/// (De)activate associate tree branch
532
534{
535 TBranch* branch = t.GetBranch(Form("%s_idx",GetName())) ;
536 if (branch) {
537 t.SetBranchStatus(Form("%s_idx",GetName()),active?true:false) ;
538 }
539}
540
541
542
543////////////////////////////////////////////////////////////////////////////////
544/// Explicitly synchronize RooAbsCategory internal cache
545
550
551
552
553////////////////////////////////////////////////////////////////////////////////
554/// Copy the cached value from given source and raise dirty flag.
555/// It is the callers responsibility to ensure that the sources
556/// cache is clean(valid) before this function is called, e.g. by
557/// calling syncCache() on the source.
558
559void RooAbsCategory::copyCache(const RooAbsArg *source, bool /*valueOnly*/, bool setValDirty)
560{
561 auto other = static_cast<const RooAbsCategory*>(source);
562 assert(dynamic_cast<const RooAbsCategory*>(source));
563
564 _currentIndex = other->_treeReadBuffer ? *other->_treeReadBuffer : other->_currentIndex;
565
566 if (setValDirty) {
568 }
569}
570
571
572////////////////////////////////////////////////////////////////////////////////
573/// Overwrite the value stored in this object's cache.
574/// This can be used to fake a computation that resulted in `value`.
575/// \param[in] value Value to write. The argument is reinterpreted as a category state.
576/// If such a state does not exist, this will create undefined behaviour.
577/// \param[in] notifyClients If true, notify users of this object that its value changed.
578/// This is the default.
580 _currentIndex = static_cast<value_type>(value);
581
582 if (notifyClients) {
584 _valueDirty = false;
585 }
586}
587
588
589////////////////////////////////////////////////////////////////////////////////
590/// Return name and index of the `n`th defined state. When states are defined using
591/// defineType() or operator[], the order of insertion is tracked, to mimic the behaviour
592/// before modernising the category classes.
593/// When directly manipulating the map with state names using states(), the order of insertion
594/// is not known, so alphabetical ordering as usual for std::map is used. The latter is faster.
595/// \param[in] n Number of state to be retrieved.
596/// \return A pair with name and index.
597const std::map<std::string, RooAbsCategory::value_type>::value_type& RooAbsCategory::getOrdinal(unsigned int n) const {
598 // Retrieve state names, trigger possible recomputation
599 auto& theStateNames = stateNames();
600
601 if (n >= theStateNames.size())
602 return invalidCategory();
603
604 if (theStateNames.size() != _insertionOrder.size())
605 return *std::next(theStateNames.begin(), n);
606
607 const auto item = theStateNames.find(_insertionOrder[n]);
608 if (item != theStateNames.end())
609 return *item;
610
611 return invalidCategory();
612}
613
614
615////////////////////////////////////////////////////////////////////////////////
616/// Return ordinal number of the current state.
618 // Retrieve state names, trigger possible recomputation
619 auto& theStateNames = stateNames();
620
621 // If we don't have the full history of inserted state names, have to go by map ordering:
622 if (theStateNames.size() != _insertionOrder.size()) {
623 const auto currentIndex = getCurrentIndex();
624 for (auto it = theStateNames.begin(); it != theStateNames.end(); ++it) {
625 if (it->second == currentIndex)
626 return std::distance(theStateNames.begin(), it);
627 }
628 }
629
630 // With full insertion history, find index of current label:
631 auto item = std::find(_insertionOrder.begin(), _insertionOrder.end(), getCurrentLabel());
632 assert(item != _insertionOrder.end());
633
634 return item - _insertionOrder.begin();
635}
636
637
638////////////////////////////////////////////////////////////////////////////////
639/// Create a RooCategory fundamental object with our properties.
640
642{
643 // Add and precalculate new category column
644 auto fund = std::make_unique<RooCategory>(newname?newname:GetName(),GetTitle()) ;
645
646 // Copy states
647 for (const auto& type : stateNames()) {
648 fund->defineStateUnchecked(type.first, type.second);
649 }
650
651 return RooFit::makeOwningPtr<RooAbsArg>(std::move(fund));
652}
653
654
655
656////////////////////////////////////////////////////////////////////////////////
657/// Determine if category has 2 or 3 states with index values -1,0,1
658
660{
661 const auto& theStateNames = stateNames();
662
663 if (theStateNames.size() > 3 || theStateNames.size() < 2) return false;
664 if (mustHaveZero && theStateNames.size() != 3) return false;
665
666 for (const auto& type : theStateNames) {
667 if (std::abs(type.second)>1)
668 return false;
669 }
670
671 return true;
672}
673
674/// \deprecated Use begin() and end() instead.
675/// \note Using this iterator creates useless RooCatType instances, which will leak
676/// unless deleted by the user.
680
681const RooCatType* RooAbsCategory::defineType(const char* label) {
682 defineState(label);
683 return retrieveLegacyState(stateNames()[label]);
684}
685
686const RooCatType* RooAbsCategory::defineType(const char* label, int index) {
687 defineState(label, index);
689}
690
695
696/// Return the legacy RooCatType corresponding to `index`. If it doesn't exist, create one.
698 auto result = _legacyStates.find(index);
699 if (result == _legacyStates.end()) {
700 result = _legacyStates.emplace(index,
701 std::make_unique<RooCatType>(lookupName(index).c_str(), index)).first;
702 }
703
704 return result->second.get();
705}
706
707
709 const auto& theStateNames = stateNames();
710
711 if (theStateNames.empty())
712 return 0;
713
714 return 1 + std::max_element(theStateNames.begin(), theStateNames.end(),
715 [](auto const& left, auto const& right) { return left.second < right.second; })->second;
716}
#define coutI(a)
#define coutF(a)
#define coutE(a)
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 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 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
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2489
const_iterator begin() const
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:77
void setShapeDirty()
Notify that a shape-like property (e.g. binning) has changed.
Definition RooAbsArg.h:436
bool isShapeDirty() const
Definition RooAbsArg.h:357
void clearValueDirty() const
Definition RooAbsArg.h:543
bool _valueDirty
Definition RooAbsArg.h:652
void setValueDirty()
Mark the element dirty. This forces a re-evaluation when a value is requested.
Definition RooAbsArg.h:431
void printMultiline(std::ostream &os, Int_t contents, bool verbose=false, TString indent="") const override
Implement multi-line detailed printing.
TString cleanBranchName() const
Construct a mangled name from the actual name that is free of any math symbols that might be interpre...
bool isValueDirty() const
Definition RooAbsArg.h:362
A space to attach TBranches.
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.
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.
value_type nextAvailableStateIndex() const
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.
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.
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.
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.
void clearTypes()
Delete all currently defined states.
void printValue(std::ostream &os) const override
Print value (label name)
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.
A TTree is a list of TBranches.
Definition TBranch.h:93
Iterator abstract base class.
Definition TIterator.h:30
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition TLeaf.h:57
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:48
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:225
Basic string class.
Definition TString.h:139
const char * Data() const
Definition TString.h:376
A TTree represents a columnar dataset.
Definition TTree.h:79
virtual void SetBranchStatus(const char *bname, bool status=true, UInt_t *found=nullptr)
Set branch status to Process or DoNotProcess.
Definition TTree.cxx:8527
virtual TBranch * GetBranch(const char *name)
Return pointer to the branch with the given name in this tree or its friends.
Definition TTree.cxx:5287
const Int_t n
Definition legend1.C:16
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