library: libRooFit #include "RooAbsCategory.h"

# RooAbsCategory

class description - source file - inheritance tree (.pdf)

## class RooAbsCategory : public RooAbsArg

| Inheritance Chart:

`TObject`

<-

`TNamed`

`RooPrintable`

<-

`RooAbsArg`

<-

`RooAbsCategory`

<-

`RooAbsCategoryLValue`

<-

`RooCategory` |

`RooSuperCategory` |

`RooGenCategory` |

`RooMappedCategory` |

`RooMultiCategory` |

`RooThresholdCategory` |

This is an abstract class, constructors will not be documented.
Look at the header to check for available constructors.

        protected:

                virtual void attachToTree(TTree& t, Int_t bufSize = 32000)
                        void clearTypes()
                virtual void copyCache(const RooAbsArg* source)
           const RooCatType* defineType(const char* label) const
           const RooCatType* defineType(const char* label, Int_t index) const
           const RooCatType* defineTypeUnchecked(const char* label, Int_t index) const
          virtual RooCatType evaluate() const
                virtual void fillTreeBranch(TTree& t)
           const RooCatType* getOrdinal(UInt_t n) const
              virtual Bool_t isValid() const
              virtual Bool_t isValid(RooCatType value) const
                virtual void setTreeBranchStatus(TTree& t, Bool_t active)
                virtual void syncCache(const RooArgSet* set = 0)
                  RooCatType traceEval() const
              virtual Bool_t traceEvalHook(RooCatType) const

        public:

                      virtual ~RooAbsCategory()
               static TClass* Class()
           virtual RooAbsArg* createFundamental(const char* newname = "0") const
                  Roo1DTable* createTable(const char* label) const
                virtual Int_t getIndex() const
          virtual const char* getLabel() const
              virtual TClass* IsA() const
               virtual Bool_t isIntegrationSafeLValue(const RooArgSet*) const
                       Bool_t isSignType(Bool_t mustHaveZero = kFALSE) const
                       Bool_t isValidIndex(Int_t index) const
                       Bool_t isValidLabel(const char* label) const
            const RooCatType* lookupType(Int_t index, Bool_t printError = kFALSE) const
            const RooCatType* lookupType(const char* label, Bool_t printError = kFALSE) const
            const RooCatType* lookupType(const RooCatType& type, Bool_t printError = kFALSE) const
                        Int_t numTypes() const
                       Bool_t operator!=(Int_t index)
                       Bool_t operator!=(const char* label)
                       Bool_t operator!=(const RooAbsArg& other)
                       Bool_t operator==(Int_t index) const
                       Bool_t operator==(const char* label) const
               virtual Bool_t operator==(const RooAbsArg& other)
                 virtual void printToStream(ostream& os, RooPrintable::PrintOption opt = Standard, TString indent = ) const
               virtual Bool_t readFromStream(istream& is, Bool_t compact, Bool_t verbose = kFALSE)
                 virtual void ShowMembers(TMemberInspector& insp, char* parent)
                 virtual void Streamer(TBuffer& b)
                         void StreamerNVirtual(TBuffer& b)
                   TIterator* typeIterator() const
                 virtual void writeToStream(ostream& os, Bool_t compact) const

### Data Members

        protected:

          RooCatType _value     Current value
           TObjArray _types     Array of allowed values
          TIterator* _typeIter  !

## Class Description

     Implementation of RooAbsCategory may be derived, there no interface
     is provided to modify the contents, nor a public interface to define states.

~RooAbsCategory()

     Destructor

Int_t getIndex() const

     Return index number of current state

const char* getLabel() const

     Return label string of current state

RooCatType traceEval() const

     Recalculate current value and check validity of new result.

TIterator* typeIterator() const

     Return iterator over all defined states

Bool_t isValidIndex(Int_t index) const

     Check if state with given index is defined

Bool_t isValidLabel(const char* label) const

     Check if state with given name is defined

const RooCatType* defineType(const char* label)

     Define a new state with given name. The lowest available
     integer number is assigned as index value

const RooCatType* defineTypeUnchecked(const char* label, Int_t index)

const RooCatType* defineType(const char* label, Int_t index)

     Define new state with given name and index number.

void clearTypes()

     Delete all currently defined states

const RooCatType* lookupType(const RooCatType &other, Bool_t printError) const

     Find our type that matches the specified type, or return 0 for no match.

const RooCatType* lookupType(Int_t index, Bool_t printError) const

     Find our type corresponding to the specified index, or return 0 for no match.

const RooCatType* lookupType(const char* label, Bool_t printError) const

     Find our type corresponding to the specified label, or return 0 for no match.

Bool_t isValid() const

     Check if current value is a valid state

Bool_t isValid(RooCatType value) const

     Check if given state is defined for this object

Roo1DTable* createTable(const char *label) const

     Create a table matching the shape of this category

Bool_t readFromStream(istream&, Bool_t, Bool_t)

     Read object contents from stream (dummy for now)

void writeToStream(ostream& os, Bool_t compact) const

     Write object contents to stream

void printToStream(ostream& os, PrintOption opt, TString indent) const

     Print info about this object to the specified stream. In addition to the info
     from RooAbsArg::printToStream() we add:

         Shape : label, index, defined types

void attachToTree(TTree& t, Int_t bufSize)

     Attach the category index and label to as branches
     to the given TTree. The index field will be attached
     as integer with name <name>_idx, the label field will be attached
     as char[] with label <name>_lbl.

void fillTreeBranch(TTree& t)

     Attach object to a branch of given TTree

void setTreeBranchStatus(TTree& t, Bool_t active)

     (De)Activate associate tree branch

void syncCache(const RooArgSet*)

void copyCache(const RooAbsArg* source)

     Copy the cached value from given source and raise dirty flag.
     It is the callers responsability to unsure that the sources
     cache is clean before this function is called, e.g. by
     calling syncCache() on the source.

const RooCatType* getOrdinal(UInt_t n) const

     Return state definition of ordinal nth defined state,
     needed by the generator mechanism.

RooAbsArg* createFundamental(const char* newname) const

     Create a RooCategory fundamental object with our properties.

Bool_t isSignType(Bool_t mustHaveZero) const

     Determine if category has 2 or 3 states with index values -1,0,1

### Inline Functions

                 Bool_t operator==(Int_t index) const
                 Bool_t operator!=(Int_t index)
                 Bool_t operator==(const char* label) const
                 Bool_t operator!=(const char* label)
                 Bool_t operator==(const RooAbsArg& other)
                 Bool_t operator!=(const RooAbsArg& other)
                  Int_t numTypes() const
                 Bool_t isIntegrationSafeLValue(const RooArgSet*) const
                 Bool_t traceEvalHook(RooCatType) const
             RooCatType evaluate() const
                TClass* Class()
                TClass* IsA() const
                   void ShowMembers(TMemberInspector& insp, char* parent)
                   void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)

Last update: Tue Jun 28 18:09:02 2005
Copyright (c) 2000-2005, Regents of the University of California *