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
36namespace std {
37 using ::string;
38 using ::vector;
39}
40#endif
41
42const Int_t kMAXCODES = kMAXFOUND; // must be the same as kMAXFOUND in TFormulaOld
43const Int_t kMAXFORMDIM = 5; // Maximum number of array dimensions support in TTreeFormula
44
45class TTree;
46class TArrayI;
47class TMethodCall;
48class TLeafObject;
49class TDataMember;
52class TFormLeafInfo;
53class TBranchElement;
54class TAxis;
56
57
59
61
62protected:
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,
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);
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
165private:
166 // Not implemented yet
167 TTreeFormula(const TTreeFormula&) = delete;
169
170 template<typename T> T GetConstant(Int_t k);
171
172public:
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
int Int_t
Definition: CPyCppyy.h:43
unsigned int UInt_t
Definition: CPyCppyy.h:44
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
unsigned char UChar_t
Definition: RtypesCore.h:38
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
#define ClassDef(name, id)
Definition: Rtypes.h:325
#define BIT(n)
Definition: Rtypes.h:85
const Int_t kMAXCODES
Definition: TTreeFormula.h:42
const Int_t kMAXFORMDIM
Definition: TTreeFormula.h:43
The FORMULA class (ROOT version 5)
Definition: TFormula.h:65
Array of integers (32 bits per element).
Definition: TArrayI.h:27
Class to manage histogram axis.
Definition: TAxis.h:30
A Branch for the case of an object.
A TTree is a list of TBranches.
Definition: TBranch.h:89
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
All ROOT classes may have RTTI (run time type identification) support added.
Definition: TDataMember.h:31
A helper class to implement reading a data member on a variable size array inside a TClonesArray obje...
This class is a small helper class to implement reading a data member on an object stored in a TTree.
Definition: TFormLeafInfo.h:49
A TLeaf for a general object derived from TObject.
Definition: TLeafObject.h:31
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition: TLeaf.h:57
A doubly linked list.
Definition: TList.h:44
Method or function calling interface.
Definition: TMethodCall.h:37
An array of TObjects.
Definition: TObjArray.h:37
EStatusBits
Definition: TObject.h:57
Basic string class.
Definition: TString.h:136
Used to coordinate one or more TTreeFormula objects.
Used to pass a selection expression to the Tree drawing routine.
Definition: TTreeFormula.h:58
virtual void ResetLoading()
Tell the formula that we are going to request a new entry.
UChar_t fHasMultipleVarDim[kMAXCODES]
True if the corresponding variable is an array with more than one variable dimension.
Definition: TTreeFormula.h:115
Int_t fMultiplicity
Indicator of the variability of the formula.
Definition: TTreeFormula.h:100
virtual TTree * GetTree() const
Definition: TTreeFormula.h:210
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,...
virtual Int_t DefinedVariable(TString &variable, Int_t &action)
Check if name is in the list of Tree/Branch leaves.
Int_t DefineAlternate(const char *expression)
This method check for treat the case where expression contains $Atl and load up both fAliases and fEx...
virtual TLeaf * GetLeaf(Int_t n) const
Return leaf corresponding to serial number n.
TAxis * fAxis
! pointer to histogram axis if this is a string
Definition: TTreeFormula.h:122
virtual ~TTreeFormula()
Tree Formula default destructor.
void Convert(UInt_t fromVersion)
virtual Bool_t IsLeafString(Int_t code) const
Return TRUE if the leaf or data member corresponding to code is a string.
Int_t fNindex
Size of fIndex.
Definition: TTreeFormula.h:101
virtual LongDouble_t EvalInstanceLD(Int_t i=0, const char *stringStack[]=0)
Definition: TTreeFormula.h:183
Int_t fNcodes
Number of leaves referenced in formula.
Definition: TTreeFormula.h:98
virtual Long64_t EvalInstance64(Int_t i=0, const char *stringStack[]=0)
Definition: TTreeFormula.h:182
TObjArray fExternalCuts
! List of TCutG and TEntryList used in the formula
Definition: TTreeFormula.h:106
virtual Int_t GetNcodes() const
Definition: TTreeFormula.h:193
virtual Double_t GetValueFromMethod(Int_t i, TLeaf *leaf) const
Return result of a leafobject method.
virtual const char * EvalStringInstance(Int_t i=0)
Eval the instance as a string.
void Init(const char *name, const char *formula)
Initialization called from the constructors.
virtual Bool_t StringToNumber(Int_t code)
Try to 'demote' a string into an array bytes.
Int_t * fLookupType
[fNindex] Array indicating how each leaf should be looked-up
Definition: TTreeFormula.h:102
T EvalInstance(Int_t i=0, const char *stringStack[]=0)
Evaluate this treeformula.
virtual Bool_t IsString() const
Return TRUE if the formula is a string.
virtual void SetTree(TTree *tree)
Definition: TTreeFormula.h:208
std::vector< std::string > fAliasesUsed
! List of aliases used during the parsing of the expression.
Definition: TTreeFormula.h:128
Int_t fCodes[kMAXCODES]
List of leaf numbers referenced in formula.
Definition: TTreeFormula.h:96
virtual char * PrintValue(Int_t mode=0) const
Return value of variable as a string.
Int_t RegisterDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim *multidim=0)
This method stores the dimension information for later usage.
Int_t fIndexes[kMAXCODES][kMAXFORMDIM]
Index of array selected by user for each leaf.
Definition: TTreeFormula.h:119
TTreeFormulaManager * GetManager() const
Definition: TTreeFormula.h:189
virtual Int_t GetMultiplicity() const
Definition: TTreeFormula.h:191
Int_t fCumulSizes[kMAXCODES][kMAXFORMDIM]
Accumulated sizes of lower dimensions for each leaf after variable dimensions has been calculated.
Definition: TTreeFormula.h:118
Bool_t fDidBooleanOptimization
! True if we executed one boolean optimization since the last time instance number 0 was evaluated
Definition: TTreeFormula.h:123
TList * fDimensionSetup
! list of dimension setups, for delayed creation of the dimension information.
Definition: TTreeFormula.h:127
virtual void SetAxis(TAxis *axis=0)
Set the axis (in particular get the type).
virtual Bool_t Notify()
This method must be overridden to handle object notification.
Definition: TTreeFormula.h:203
virtual Double_t EvalInstance(Int_t i=0, const char *stringStack[]=0)
Definition: TTreeFormula.h:181
void ResetDimensions()
Populate the TTreeFormulaManager with the dimension information.
Int_t fNdimensions[kMAXCODES]
Number of array dimensions in each leaf.
Definition: TTreeFormula.h:113
TTree * fTree
! Pointer to Tree
Definition: TTreeFormula.h:95
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 ...
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...
Bool_t IsQuickLoad() const
Definition: TTreeFormula.h:201
TMethodCall * GetMethodCall(Int_t code) const
Return methodcall corresponding to code.
virtual void UpdateFormulaLeaves()
This function is called TTreePlayer::UpdateFormulaLeaves, itself called by TChain::LoadTree when a ne...
virtual Bool_t SwitchToFormLeafInfo(Int_t code)
Convert the underlying lookup method from the direct technique (dereferencing the address held by the...
Bool_t LoadCurrentDim()
Calculate the actual dimension for the current entry.
Bool_t fQuickLoad
! If true, branch GetEntry is only called when the entry number changes.
Definition: TTreeFormula.h:110
Bool_t fHasCast
Record whether the formula contain a cast operation or not.
Definition: TTreeFormula.h:99
TObjArray fAliases
! List of TTreeFormula for each alias used.
Definition: TTreeFormula.h:107
T GetConstant(Int_t k)
virtual void * EvalObject(Int_t i=0)
Evaluate this treeformula.
TObjArray fLeafNames
List of TNamed describing leaves.
Definition: TTreeFormula.h:108
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.
void LoadBranches()
Make sure that all the branches have been loaded properly.
virtual TClass * EvalClass() const
Evaluate the class of this treeformula.
Int_t GetRealInstance(Int_t instance, Int_t codeindex)
Now let calculate what physical instance we really need.
TFormLeafInfo * GetLeafInfo(Int_t code) const
Return DataMember corresponding to code.
TObjArray fDataMembers
! List of leaf data members
Definition: TTreeFormula.h:104
TTreeFormula(const TTreeFormula &)=delete
TTreeFormula * fVarIndexes[kMAXCODES][kMAXFORMDIM]
Pointer to a variable index.
Definition: TTreeFormula.h:120
LongDouble_t * fConstLD
! local version of fConsts able to store bigger numbers
Definition: TTreeFormula.h:130
Int_t fFixedSizes[kMAXCODES][kMAXFORMDIM]
Physical sizes of lower dimensions for each leaf.
Definition: TTreeFormula.h:114
virtual Int_t GetNdata()
Return number of available instances in the formula.
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...
RealInstanceCache fRealInstanceCache
! Cache accelerating the GetRealInstance function
Definition: TTreeFormula.h:132
Int_t ParseWithLeaf(TLeaf *leaf, const char *expression, Bool_t final, UInt_t paran_level, TObjArray &castqueue, Bool_t useLeafCollectionObject, const char *fullExpression)
Decompose 'expression' as pointing to something inside the leaf Returns:
TObjArray fMethods
! List of leaf method calls
Definition: TTreeFormula.h:105
Int_t fNdata[kMAXCODES]
! This caches the physical number of element in the leaf or data member.
Definition: TTreeFormula.h:97
void SetQuickLoad(Bool_t quick)
Definition: TTreeFormula.h:207
TObjArray fLeaves
! List of leaf used in this formula.
Definition: TTreeFormula.h:103
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.
TTreeFormula & operator=(const TTreeFormula &)=delete
virtual void * GetValuePointerFromMethod(Int_t i, TLeaf *leaf) const
Return result of a leafobject method.
TObjArray fBranches
! List of branches to read. Similar to fLeaves but duplicates are zeroed out.
Definition: TTreeFormula.h:109
Bool_t fNeedLoading
! If true, the current entry has not been loaded yet.
Definition: TTreeFormula.h:111
TTreeFormulaManager * fManager
! The dimension coordinator.
Definition: TTreeFormula.h:124
A TTree represents a columnar dataset.
Definition: TTree.h:79
long double LongDouble_t
Definition: cpp_cppyy.h:15
long long Long64_t
Definition: cpp_cppyy.h:13
const Int_t n
Definition: legend1.C:16
double T(double x)
Definition: ChebyshevPol.h:34
static const std::string name("name")
static Roo_reg_AGKInteg1D instance
Definition: tree.py:1
const Int_t kMAXFOUND
Definition: TFormula.h:31