Logo ROOT   6.10/09
Reference Guide
Go to the documentation of this file.
1 // @(#)root/treeplayer:$Id$
2 // Author: Rene Brun 19/01/96
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 // ---------------------------------- TreeFormula.h
13 #ifndef ROOT_TTreeFormula
14 #define ROOT_TTreeFormula
18 //////////////////////////////////////////////////////////////////////////
19 // //
20 // TTreeFormula //
21 // //
22 // The Tree formula class //
23 // //
24 //////////////////////////////////////////////////////////////////////////
26 #include "v5/TFormula.h"
28 #include "TLeaf.h"
30 #include "TObjArray.h"
32 #include <string>
33 #include <vector>
35 #ifdef R__OLDHPACC
36 namespace std {
37  using ::string;
38  using ::vector;
39 }
40 #endif
42 const Int_t kMAXCODES = kMAXFOUND; // must be the same as kMAXFOUND in TFormulaOld
43 const Int_t kMAXFORMDIM = 5; // Maximum number of array dimensions support in TTreeFormula
45 class TTree;
46 class TArrayI;
47 class TMethodCall;
48 class TLeafObject;
49 class TDataMember;
50 class TStreamerElement;
52 class TFormLeafInfo;
53 class TBranchElement;
54 class TAxis;
60 friend class TTreeFormulaManager;
62 protected:
63  enum {
64  kIsCharacter = BIT(12),
65  kMissingLeaf = BIT(15), // true if some of the needed leaves are missing in the current TTree
66  kIsInteger = BIT(17), // true if the branch contains an integer variable
67  kNeedEntries = BIT(18) // true if the formula uses Entries$
68  };
69  enum {
70  kDirect, kDataMember, kMethod,
71  kIndexOfEntry, kEntries, kLength, kIteration, kLengthFunc, kSum, kEntryList,
74  kMin, kMax,
75  kLocalEntries
77  };
78  enum {
79  kAlias = 200,
80  kAliasString = 201,
81  kAlternate = 202,
82  kAlternateString = 203,
83  kMinIf = 204,
84  kMaxIf = 205
85  };
87  // Helper struct to hold a cache
88  // that can accelerate calculation of the RealIndex.
90  Int_t fInstanceCache = 0;
91  Int_t fLocalIndexCache = 0;
92  Int_t fVirtAccumCache = 0;
93  };
95  TTree *fTree; //! pointer to Tree
96  Int_t fCodes[kMAXCODES]; // List of leaf numbers referenced in formula
97  Int_t fNdata[kMAXCODES]; //! This caches the physical number of element in the leaf or datamember.
98  Int_t fNcodes; // Number of leaves referenced in formula
99  Bool_t fHasCast; // Record whether the formula contain a cast operation or not
100  Int_t fMultiplicity; // Indicator of the variability of the formula
101  Int_t fNindex; // Size of fIndex
102  Int_t *fLookupType; //[fNindex] array indicating how each leaf should be looked-up
103  TObjArray fLeaves; //! List of leaf used in this formula.
104  TObjArray fDataMembers; //! List of leaf data members
105  TObjArray fMethods; //! List of leaf method calls
106  TObjArray fExternalCuts; //! List of TCutG and TEntryList used in the formula
107  TObjArray fAliases; //! List of TTreeFormula for each alias used.
108  TObjArray fLeafNames; // List of TNamed describing leaves
109  TObjArray fBranches; //! List of branches to read. Similar to fLeaces but duplicates are zeroed out.
110  Bool_t fQuickLoad; //! If true, branch GetEntry is only called when the entry number changes.
111  Bool_t fNeedLoading; //! If true, the current entry has not been loaded yet.
113  Int_t fNdimensions[kMAXCODES]; //Number of array dimensions in each leaf
114  Int_t fFixedSizes[kMAXCODES][kMAXFORMDIM]; //Physical sizes of lower dimensions for each leaf
115  UChar_t fHasMultipleVarDim[kMAXCODES]; //True if the corresponding variable is an array with more than one variable dimension.
117  //the next line should have a mutable in front. See GetNdata()
118  Int_t fCumulSizes[kMAXCODES][kMAXFORMDIM]; //Accumulated sizes of lower dimensions for each leaf after variable dimensions has been calculated
119  Int_t fIndexes[kMAXCODES][kMAXFORMDIM]; //Index of array selected by user for each leaf
120  TTreeFormula *fVarIndexes[kMAXCODES][kMAXFORMDIM]; //Pointer to a variable index.
122  TAxis *fAxis; //! pointer to histogram axis if this is a string
123  Bool_t fDidBooleanOptimization; //! True if we executed one boolean optimization since the last time instance number 0 was evaluated
124  TTreeFormulaManager *fManager; //! The dimension coordinator.
126  // Helper members and function used during the construction and parsing
127  TList *fDimensionSetup; //! list of dimension setups, for delayed creation of the dimension information.
128  std::vector<std::string> fAliasesUsed; //! List of aliases used during the parsing of the expression.
130  LongDouble_t* fConstLD; //! local version of fConsts able to store bigger numbers
132  RealInstanceCache fRealInstanceCache; //! Cache accelerating the GetRealInstance function
134  TTreeFormula(const char *name, const char *formula, TTree *tree, const std::vector<std::string>& aliases);
135  void Init(const char *name, const char *formula);
136  Bool_t BranchHasMethod(TLeaf* leaf, TBranch* branch, const char* method,const char* params, Long64_t readentry) const;
137  Int_t DefineAlternate(const char* expression);
138  void DefineDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim * info, Int_t& virt_dim);
139  Int_t FindLeafForExpression(const char* expression, TLeaf *&leaf, TString &leftover, Bool_t &final, UInt_t &paran_level, TObjArray &castqueue, std::vector<std::string>& aliasUsed, Bool_t &useLeafCollectionObject, const char *fullExpression);
140  TLeaf* GetLeafWithDatamember(const char* topchoice, const char* nextchice, Long64_t readentry) const;
141  Int_t ParseWithLeaf(TLeaf *leaf, const char *expression, Bool_t final, UInt_t paran_level, TObjArray &castqueue, Bool_t useLeafCollectionObject, const char *fullExpression);
142  Int_t RegisterDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim * multidim = 0);
143  Int_t RegisterDimensions(Int_t code, TBranchElement *branch);
144  Int_t RegisterDimensions(Int_t code, TFormLeafInfo *info, TFormLeafInfo *maininfo, Bool_t useCollectionObject);
145  Int_t RegisterDimensions(Int_t code, TLeaf *leaf);
146  Int_t RegisterDimensions(const char *size, Int_t code);
148  virtual Double_t GetValueFromMethod(Int_t i, TLeaf *leaf) const;
149  virtual void* GetValuePointerFromMethod(Int_t i, TLeaf *leaf) const;
150  Int_t GetRealInstance(Int_t instance, Int_t codeindex);
152  void LoadBranches();
153  Bool_t LoadCurrentDim();
154  void ResetDimensions();
156  virtual TClass* EvalClass(Int_t oper) const;
157  virtual Bool_t IsLeafInteger(Int_t code) const;
158  virtual Bool_t IsString(Int_t oper) const;
159  virtual Bool_t IsLeafString(Int_t code) const;
160  virtual Bool_t SwitchToFormLeafInfo(Int_t code);
161  virtual Bool_t StringToNumber(Int_t code);
163  void Convert(UInt_t fromVersion);
165 private:
166  // Not implemented yet
167  TTreeFormula(const TTreeFormula&);
170  template<typename T> T GetConstant(Int_t k);
172 public:
173  TTreeFormula();
174  TTreeFormula(const char *name,const char *formula, TTree *tree);
175  virtual ~TTreeFormula();
177  virtual Int_t DefinedVariable(TString &variable, Int_t &action);
178  virtual TClass* EvalClass() const;
180  template<typename T> T EvalInstance(Int_t i=0, const char *stringStack[]=0);
181  virtual Double_t EvalInstance(Int_t i=0, const char *stringStack[]=0) {return EvalInstance<Double_t>(i, stringStack); }
182  virtual Long64_t EvalInstance64(Int_t i=0, const char *stringStack[]=0) {return EvalInstance<Long64_t>(i, stringStack); }
183  virtual LongDouble_t EvalInstanceLD(Int_t i=0, const char *stringStack[]=0) {return EvalInstance<LongDouble_t>(i, stringStack); }
185  virtual const char *EvalStringInstance(Int_t i=0);
186  virtual void* EvalObject(Int_t i=0);
187  // EvalInstance should be const. See comment on GetNdata()
188  TFormLeafInfo *GetLeafInfo(Int_t code) const;
189  TTreeFormulaManager*GetManager() const { return fManager; }
190  TMethodCall *GetMethodCall(Int_t code) const;
191  virtual Int_t GetMultiplicity() const {return fMultiplicity;}
192  virtual TLeaf *GetLeaf(Int_t n) const;
193  virtual Int_t GetNcodes() const {return fNcodes;}
194  virtual Int_t GetNdata();
195  //GetNdata should probably be const. However it need to cache some information about the actual dimension
196  //of arrays, so if GetNdata is const, the variables fUsedSizes and fCumulUsedSizes need to be declared
197  //mutable. We will be able to do that only when all the compilers supported for ROOT actually implemented
198  //the mutable keyword.
199  //NOTE: Also modify the code in PrintValue which current goes around this limitation :(
200  virtual Bool_t IsInteger(Bool_t fast=kTRUE) const;
201  Bool_t IsQuickLoad() const { return fQuickLoad; }
202  virtual Bool_t IsString() const;
203  virtual Bool_t Notify() { UpdateFormulaLeaves(); return kTRUE; }
204  virtual char *PrintValue(Int_t mode=0) const;
205  virtual char *PrintValue(Int_t mode, Int_t instance, const char *decform = "9.9") const;
206  virtual void SetAxis(TAxis *axis=0);
207  void SetQuickLoad(Bool_t quick) { fQuickLoad = quick; }
208  virtual void SetTree(TTree *tree) {fTree = tree;}
209  virtual void ResetLoading();
210  virtual TTree* GetTree() const {return fTree;}
211  virtual void UpdateFormulaLeaves();
213  ClassDef(TTreeFormula, 10); //The Tree formula
214 };
216 #endif
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition: TLeaf.h:32
const Int_t kMAXFORMDIM
Definition: TTreeFormula.h:43
An array of TObjects.
Definition: TObjArray.h:37
long long Long64_t
Definition: RtypesCore.h:69
TObjArray fBranches
Definition: TTreeFormula.h:109
virtual Double_t EvalInstance(Int_t i=0, const char *stringStack[]=0)
Definition: TTreeFormula.h:181
All ROOT classes may have RTTI (run time type identification) support added.
Definition: TDataMember.h:31
double T(double x)
Definition: ChebyshevPol.h:34
A TLeaf for a general object derived from TObject.
Definition: TLeafObject.h:31
#define BIT(n)
Definition: Rtypes.h:75
Bool_t IsQuickLoad() const
Definition: TTreeFormula.h:201
Basic string class.
Definition: TString.h:129
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
STL namespace.
Int_t fMultiplicity
Definition: TTreeFormula.h:100
virtual void SetTree(TTree *tree)
Definition: TTreeFormula.h:208
A helper class to implement reading a data member on a variable size array inside a TClonesArray obje...
Array of integers (32 bits per element).
Definition: TArrayI.h:27
virtual Bool_t Notify()
This method must be overridden to handle object notification.
Definition: TTreeFormula.h:203
TObjArray fLeafNames
List of TTreeFormula for each alias used.
Definition: TTreeFormula.h:108
Used to coordinate one or more TTreeFormula objects.
#define ClassDef(name, id)
Definition: Rtypes.h:297
TObjArray fExternalCuts
List of leaf method calls.
Definition: TTreeFormula.h:106
TTreeFormulaManager * GetManager() const
Definition: TTreeFormula.h:189
const Int_t kMAXFOUND
Definition: TFormula.h:31
Method or function calling interface.
Definition: TMethodCall.h:37
virtual Int_t GetNcodes() const
Definition: TTreeFormula.h:193
Used to pass a selection expression to the Tree drawing routine.
Definition: TTreeFormula.h:58
virtual Int_t GetMultiplicity() const
Definition: TTreeFormula.h:191
A doubly linked list.
Definition: TList.h:43
TObjArray fDataMembers
List of leaf used in this formula.
Definition: TTreeFormula.h:104
Class to manage histogram axis.
Definition: TAxis.h:30
const Int_t kMAXCODES
Definition: TTreeFormula.h:42
RealInstanceCache fRealInstanceCache
local version of fConsts able to store bigger numbers
Definition: TTreeFormula.h:132
Int_t fNcodes
This caches the physical number of element in the leaf or datamember.
Definition: TTreeFormula.h:98
unsigned int UInt_t
Definition: RtypesCore.h:42
TObjArray fAliases
List of TCutG and TEntryList used in the formula.
Definition: TTreeFormula.h:107
The ROOT global object gROOT contains a list of all defined classes.
Definition: TClass.h:71
long double LongDouble_t
Definition: RtypesCore.h:57
std::vector< std::string > fAliasesUsed
list of dimension setups, for delayed creation of the dimension information.
Definition: TTreeFormula.h:128
A Branch for the case of an object.
TAxis * fAxis
Definition: TTreeFormula.h:122
Bool_t fHasCast
Definition: TTreeFormula.h:99
LongDouble_t * fConstLD
List of aliases used during the parsing of the expression.
Definition: TTreeFormula.h:130
TObjArray fLeaves
Definition: TTreeFormula.h:103
double Double_t
Definition: RtypesCore.h:55
The FORMULA class (ROOT version 5)
Definition: TFormula.h:65
Bool_t fDidBooleanOptimization
pointer to histogram axis if this is a string
Definition: TTreeFormula.h:123
This class is a small helper class to implement reading a data member on an object stored in a TTree...
Definition: TFormLeafInfo.h:49
Binding & operator=(OUT(*fun)(void))
TTree * fTree
Definition: TTreeFormula.h:95
virtual TTree * GetTree() const
Definition: TTreeFormula.h:210
Bool_t fQuickLoad
List of branches to read. Similar to fLeaces but duplicates are zeroed out.
Definition: TTreeFormula.h:110
TTreeFormulaManager * fManager
True if we executed one boolean optimization since the last time instance number 0 was evaluated...
Definition: TTreeFormula.h:124
Int_t * fLookupType
Definition: TTreeFormula.h:102
TList * fDimensionSetup
The dimension coordinator.
Definition: TTreeFormula.h:127
virtual Long64_t EvalInstance64(Int_t i=0, const char *stringStack[]=0)
Definition: TTreeFormula.h:182
Definition: tree.py:1
TObjArray fMethods
List of leaf data members.
Definition: TTreeFormula.h:105
A TTree object has a header with a name and a title.
Definition: TTree.h:78
virtual LongDouble_t EvalInstanceLD(Int_t i=0, const char *stringStack[]=0)
Definition: TTreeFormula.h:183
void SetQuickLoad(Bool_t quick)
Definition: TTreeFormula.h:207
unsigned char UChar_t
Definition: RtypesCore.h:34
A TTree is a list of TBranches.
Definition: TBranch.h:57
const Bool_t kTRUE
Definition: RtypesCore.h:91
const Int_t n
Definition: legend1.C:16
Bool_t fNeedLoading
If true, branch GetEntry is only called when the entry number changes.
Definition: TTreeFormula.h:111