Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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);
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;
150 Int_t GetRealInstance(Int_t instance, Int_t codeindex);
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 RtypesCore.h:45
unsigned char UChar_t
Definition RtypesCore.h:38
bool Bool_t
Definition RtypesCore.h:63
double Double_t
Definition RtypesCore.h:59
long double LongDouble_t
Definition RtypesCore.h:61
long long Long64_t
Definition RtypesCore.h:73
const Bool_t kTRUE
Definition RtypesCore.h:91
#define ClassDef(name, id)
Definition Rtypes.h:325
#define BIT(n)
Definition Rtypes.h:85
char name[80]
Definition TGX11.cxx:110
const Int_t kMAXCODES
const Int_t kMAXFORMDIM
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.
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
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.
virtual void ResetLoading()
Tell the formula that we are going to request a new entry.
UChar_t fHasMultipleVarDim[kMAXCODES]
Int_t fMultiplicity
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...
TTreeFormulaManager * GetManager() const
virtual TLeaf * GetLeaf(Int_t n) const
Return leaf corresponding to serial number n.
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.
virtual LongDouble_t EvalInstanceLD(Int_t i=0, const char *stringStack[]=0)
Int_t fNcodes
This caches the physical number of element in the leaf or data member.
virtual Long64_t EvalInstance64(Int_t i=0, const char *stringStack[]=0)
TObjArray fExternalCuts
List of leaf method calls.
virtual Int_t GetNcodes() const
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)
Initialiation called from the constructors.
virtual Bool_t StringToNumber(Int_t code)
Try to 'demote' a string into an array bytes.
Int_t * fLookupType
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)
std::vector< std::string > fAliasesUsed
list of dimension setups, for delayed creation of the dimension information.
Int_t fCodes[kMAXCODES]
pointer to Tree
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]
virtual Int_t GetMultiplicity() const
Int_t fCumulSizes[kMAXCODES][kMAXFORMDIM]
Bool_t fDidBooleanOptimization
pointer to histogram axis if this is a string
TList * fDimensionSetup
The dimension coordinator.
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.
virtual Double_t EvalInstance(Int_t i=0, const char *stringStack[]=0)
void ResetDimensions()
Populate the TTreeFormulaManager with the dimension information.
Int_t fNdimensions[kMAXCODES]
If true, the current entry has not been loaded yet.
TTree * fTree
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
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
List of branches to read. Similar to fLeaves but duplicates are zeroed out.
virtual TTree * GetTree() const
Bool_t fHasCast
TObjArray fAliases
List of TCutG and TEntryList used in the formula.
T GetConstant(Int_t k)
virtual void * EvalObject(Int_t i=0)
Evaluate this treeformula.
TObjArray fLeafNames
List of TTreeFormula for each alias used.
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.
TTreeFormula & operator=(const TTreeFormula &)=delete
TFormLeafInfo * GetLeafInfo(Int_t code) const
Return DataMember corresponding to code.
TObjArray fDataMembers
List of leaf used in this formula.
TTreeFormula(const TTreeFormula &)=delete
TTreeFormula * fVarIndexes[kMAXCODES][kMAXFORMDIM]
LongDouble_t * fConstLD
List of aliases used during the parsing of the expression.
Int_t fFixedSizes[kMAXCODES][kMAXFORMDIM]
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
local version of fConsts able to store bigger numbers
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 data members.
Int_t fNdata[kMAXCODES]
void SetQuickLoad(Bool_t quick)
TObjArray fLeaves
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.
virtual void * GetValuePointerFromMethod(Int_t i, TLeaf *leaf) const
Return result of a leafobject method.
TObjArray fBranches
Bool_t fNeedLoading
If true, branch GetEntry is only called when the entry number changes.
TTreeFormulaManager * fManager
True if we executed one boolean optimization since the last time instance number 0 was evaluated.
A TTree represents a columnar dataset.
Definition TTree.h:79
const Int_t n
Definition legend1.C:16
Definition tree.py:1
const Int_t kMAXFOUND
Definition TFormula.h:31