Logo ROOT  
Reference Guide
TTreeFormula.h
Go to the documentation of this file.
1 // @(#)root/treeplayer:$Id$
2 // Author: Rene Brun 19/01/96
3 
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
12 
13 #ifndef ROOT_TTreeFormula
14 #define ROOT_TTreeFormula
15 
16 
17 
18 //////////////////////////////////////////////////////////////////////////
19 // //
20 // TTreeFormula //
21 // //
22 // The Tree formula class //
23 // //
24 //////////////////////////////////////////////////////////////////////////
25 
26 #include "v5/TFormula.h"
27 
28 #include "TLeaf.h"
29 
30 #include "TObjArray.h"
31 
32 #include <string>
33 #include <vector>
34 
35 #ifdef R__OLDHPACC
36 namespace std {
37  using ::string;
38  using ::vector;
39 }
40 #endif
41 
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
44 
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;
56 
57 
59 
60 friend class TTreeFormulaManager;
61 
62 protected:
63  enum EStatusBits {
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 {
76 
77  };
78  enum {
79  kAlias = 200,
80  kAliasString = 201,
81  kAlternate = 202,
83  kMinIf = 204,
84  kMaxIf = 205
85  };
86 
87  // Helper struct to hold a cache
88  // that can accelerate calculation of the RealIndex.
93  };
94 
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 data member.
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 fLeaves 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.
112 
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.
116 
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.
121 
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.
125 
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.
129 
130  LongDouble_t* fConstLD; //! local version of fConsts able to store bigger numbers
131 
132  RealInstanceCache fRealInstanceCache; //! Cache accelerating the GetRealInstance function
133 
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);
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);
147 
148  virtual Double_t GetValueFromMethod(Int_t i, TLeaf *leaf) const;
149  virtual void* GetValuePointerFromMethod(Int_t i, TLeaf *leaf) const;
151 
152  void LoadBranches();
154  void ResetDimensions();
155 
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);
162 
163  void Convert(UInt_t fromVersion);
164 
165 private:
166  // Not implemented yet
167  TTreeFormula(const TTreeFormula&) = delete;
168  TTreeFormula& operator=(const TTreeFormula&) = delete;
169 
170  template<typename T> T GetConstant(Int_t k);
171 
172 public:
173  TTreeFormula();
174  TTreeFormula(const char *name,const char *formula, TTree *tree);
175  virtual ~TTreeFormula();
176 
177  virtual Int_t DefinedVariable(TString &variable, Int_t &action);
178  virtual TClass* EvalClass() const;
179 
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); }
184 
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;
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();
212 
213  ClassDef(TTreeFormula, 10); //The Tree formula
214 };
215 
216 #endif
virtual Bool_t IsString() const
Return TRUE if the formula is a string.
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition: TLeaf.h:49
const Int_t kMAXFORMDIM
Definition: TTreeFormula.h:43
An array of TObjects.
Definition: TObjArray.h:37
virtual Bool_t IsLeafInteger(Int_t code) const
Return TRUE if the leaf corresponding to code is short, int or unsigned short, int When a leaf is of ...
long long Long64_t
Definition: RtypesCore.h:71
virtual Bool_t IsLeafString(Int_t code) const
Return TRUE if the leaf or data member corresponding to code is a string.
virtual void * GetValuePointerFromMethod(Int_t i, TLeaf *leaf) const
Return result of a leafobject method.
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
virtual Int_t DefinedVariable(TString &variable, Int_t &action)
Check if name is in the list of Tree/Branch leaves.
A TLeaf for a general object derived from TObject.
Definition: TLeafObject.h:31
#define BIT(n)
Definition: Rtypes.h:83
Bool_t IsQuickLoad() const
Definition: TTreeFormula.h:201
void DefineDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim *info, Int_t &virt_dim)
This method is used internally to decode the dimensions of the variables.
Basic string class.
Definition: TString.h:131
Int_t fNdimensions[kMAXCODES]
If true, the current entry has not been loaded yet.
Definition: TTreeFormula.h:113
int Int_t
Definition: RtypesCore.h:43
bool Bool_t
Definition: RtypesCore.h:61
T GetConstant(Int_t k)
STL namespace.
Int_t fMultiplicity
Definition: TTreeFormula.h:100
virtual void SetTree(TTree *tree)
Definition: TTreeFormula.h:208
virtual void * EvalObject(Int_t i=0)
Evaluate this treeformula.
Int_t fNdata[kMAXCODES]
Definition: TTreeFormula.h:97
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
void Init(const char *name, const char *formula)
Initialiation called from the constructors.
virtual Bool_t Notify()
This method must be overridden to handle object notification.
Definition: TTreeFormula.h:203
Bool_t LoadCurrentDim()
Calculate the actual dimension for the current entry.
void Convert(UInt_t fromVersion)
TObjArray fLeafNames
List of TTreeFormula for each alias used.
Definition: TTreeFormula.h:108
Used to coordinate one or more TTreeFormula objects.
virtual Bool_t SwitchToFormLeafInfo(Int_t code)
Convert the underlying lookup method from the direct technique (dereferencing the address held by the...
#define ClassDef(name, id)
Definition: Rtypes.h:322
TObjArray fExternalCuts
List of leaf method calls.
Definition: TTreeFormula.h:106
TTreeFormulaManager * GetManager() const
Definition: TTreeFormula.h:189
void ResetDimensions()
Populate the TTreeFormulaManager with the dimension information.
Int_t RegisterDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim *multidim=0)
This method stores the dimension information for later usage.
virtual TClass * EvalClass() const
Evaluate the class of this treeformula.
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
void LoadBranches()
Make sure that all the branches have been loaded properly.
virtual const char * EvalStringInstance(Int_t i=0)
Eval the instance as a string.
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:44
Bool_t BranchHasMethod(TLeaf *leaf, TBranch *branch, const char *method, const char *params, Long64_t readentry) const
Return the leaf (if any) of the tree with contains an object of a class having a method which has the...
UChar_t fHasMultipleVarDim[kMAXCODES]
Definition: TTreeFormula.h:115
virtual Double_t GetValueFromMethod(Int_t i, TLeaf *leaf) const
Return result of a leafobject method.
virtual Bool_t StringToNumber(Int_t code)
Try to &#39;demote&#39; a string into an array bytes.
TLeaf * GetLeafWithDatamember(const char *topchoice, const char *nextchice, Long64_t readentry) const
Return the leaf (if any) which contains an object containing a data member which has the name provide...
TMethodCall * GetMethodCall(Int_t code) const
Return methodcall corresponding to code.
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
Int_t ParseWithLeaf(TLeaf *leaf, const char *expression, Bool_t final, UInt_t paran_level, TObjArray &castqueue, Bool_t useLeafCollectionObject, const char *fullExpression)
Decompose &#39;expression&#39; as pointing to something inside the leaf Returns:
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 data member.
Definition: TTreeFormula.h:98
virtual char * PrintValue(Int_t mode=0) const
Return value of variable as a string.
unsigned int UInt_t
Definition: RtypesCore.h:44
TObjArray fAliases
List of TCutG and TEntryList used in the formula.
Definition: TTreeFormula.h:107
virtual void UpdateFormulaLeaves()
This function is called TTreePlayer::UpdateFormulaLeaves, itself called by TChain::LoadTree when a ne...
Int_t fCumulSizes[kMAXCODES][kMAXFORMDIM]
Definition: TTreeFormula.h:118
static Roo_reg_AGKInteg1D instance
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
long double LongDouble_t
Definition: RtypesCore.h:59
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
virtual Int_t GetNdata()
Return number of available instances in the formula.
Int_t GetRealInstance(Int_t instance, Int_t codeindex)
Now let calculate what physical instance we really need.
LongDouble_t * fConstLD
List of aliases used during the parsing of the expression.
Definition: TTreeFormula.h:130
virtual TLeaf * GetLeaf(Int_t n) const
Return leaf corresponding to serial number n.
TObjArray fLeaves
Definition: TTreeFormula.h:103
double Double_t
Definition: RtypesCore.h:57
Int_t DefineAlternate(const char *expression)
This method check for treat the case where expression contains $Atl and load up both fAliases and fEx...
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
Int_t fIndexes[kMAXCODES][kMAXFORMDIM]
Definition: TTreeFormula.h:119
EStatusBits
Definition: TObject.h:57
This class is a small helper class to implement reading a data member on an object stored in a TTree...
Definition: TFormLeafInfo.h:49
T EvalInstance(Int_t i=0, const char *stringStack[]=0)
Evaluate this treeformula.
TTree * fTree
Definition: TTreeFormula.h:95
virtual TTree * GetTree() const
Definition: TTreeFormula.h:210
Bool_t fQuickLoad
List of branches to read. Similar to fLeaves but duplicates are zeroed out.
Definition: TTreeFormula.h:110
TTreeFormula * fVarIndexes[kMAXCODES][kMAXFORMDIM]
Definition: TTreeFormula.h:120
TTreeFormulaManager * fManager
True if we executed one boolean optimization since the last time instance number 0 was evaluated...
Definition: TTreeFormula.h:124
virtual ~TTreeFormula()
Tree Formula default destructor.
Int_t * fLookupType
Definition: TTreeFormula.h:102
TFormLeafInfo * GetLeafInfo(Int_t code) const
Return DataMember corresponding to code.
TList * fDimensionSetup
The dimension coordinator.
Definition: TTreeFormula.h:127
virtual Bool_t IsInteger(Bool_t fast=kTRUE) const
Return TRUE if the formula corresponds to one single Tree leaf and this leaf is short, int or unsigned short, int When a leaf is of type integer or string, the generated histogram is forced to have an integer bin width.
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 represents a columnar dataset.
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:36
TTreeFormula & operator=(const TTreeFormula &)=delete
A TTree is a list of TBranches.
Definition: TBranch.h:91
const Bool_t kTRUE
Definition: RtypesCore.h:89
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)
Look for the leaf corresponding to the start of expression.
const Int_t n
Definition: legend1.C:16
Int_t fFixedSizes[kMAXCODES][kMAXFORMDIM]
Definition: TTreeFormula.h:114
Bool_t fNeedLoading
If true, branch GetEntry is only called when the entry number changes.
Definition: TTreeFormula.h:111
char name[80]
Definition: TGX11.cxx:109
virtual void ResetLoading()
Tell the formula that we are going to request a new entry.
Int_t fCodes[kMAXCODES]
pointer to Tree
Definition: TTreeFormula.h:96
virtual void SetAxis(TAxis *axis=0)
Set the axis (in particular get the type).