class TTreeFormula: public TFormula


 TTreeFormula now relies on a variety of TFormLeafInfo classes to handle the
 reading of the information.  Here is the list of theses classes:
   TFormLeafInfo
   TFormLeafInfoDirect
   TFormLeafInfoNumerical
   TFormLeafInfoClones
   TFormLeafInfoCollection
   TFormLeafInfoPointer
   TFormLeafInfoMethod
   TFormLeafInfoMultiVarDim
   TFormLeafInfoMultiVarDimDirect
   TFormLeafInfoCast

 The following method are available from the TFormLeafInfo interface:

  AddOffset(Int_t offset, TStreamerElement* element)
  GetCounterValue(TLeaf* leaf) : return the size of the array pointed to.
  GetObjectAddress(TLeafElement* leaf) : Returns the the location of the object pointed to.
  GetMultiplicity() : Returns info on the variability of the number of elements
  GetNdata(TLeaf* leaf) : Returns the number of elements
  GetNdata() : Used by GetNdata(TLeaf* leaf)
  GetValue(TLeaf *leaf, Int_t instance = 0) : Return the value
  GetValuePointer(TLeaf *leaf, Int_t instance = 0) : Returns the address of the value
  GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0) : Returns the address of the value of 'this' LeafInfo
  IsString()
  ReadValue(char *where, Int_t instance = 0) : Internal function to interpret the location 'where'
  Update() : react to the possible loading of a shared library.


Function Members (Methods)

public:
TTreeFormula()
TTreeFormula(const char* name, const char* formula, TTree* tree)
virtual~TTreeFormula()
voidTObject::AbstractMethod(const char* method) const
virtual voidTFormula::Analyze(const char* schain, Int_t& err, Int_t offset = 0)
virtual Bool_tTFormula::AnalyzeFunction(TString& chaine, Int_t& err, Int_t offset = 0)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTFormula::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual Int_tTNamed::Compare(const TObject* obj) const
virtual Int_tTFormula::Compile(const char* expression = "")
virtual voidTFormula::Copy(TObject& formula) const
virtual char*TFormula::DefinedString(Int_t code)
virtual Double_tTFormula::DefinedValue(Int_t code)
virtual Int_tDefinedVariable(TString& variable, Int_t& action)
virtual voidTObject::Delete(Option_t* option = "")
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() const
virtual TObject*TObject::DrawClone(Option_t* option = "") const
virtual voidTObject::Dump() const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual Double_tTFormula::Eval(Double_t x, Double_t y = 0, Double_t z = 0, Double_t t = 0) const
virtual TClass*EvalClass() const
virtual Double_tEvalInstance(Int_t i = 0, const char** stringStack = 0)
virtual void*EvalObject(Int_t i = 0)
virtual Double_tTFormula::EvalPar(const Double_t* x, const Double_t* params = 0)
virtual Double_tTFormula::EvalParOld(const Double_t* x, const Double_t* params = 0)
virtual const char*EvalStringInstance(Int_t i = 0)
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual TStringTFormula::GetExpFormula(Option_t* option = "") const
virtual const char*TObject::GetIconName() const
virtual TLeaf*GetLeaf(Int_t n) const
TFormLeafInfo*GetLeafInfo(Int_t code) const
virtual const TObject*TFormula::GetLinearPart(Int_t i)
TTreeFormulaManager*GetManager() const
TMethodCall*GetMethodCall(Int_t code) const
virtual Int_tGetMultiplicity() const
virtual const char*TNamed::GetName() const
virtual Int_tGetNcodes() const
virtual Int_tGetNdata()
virtual Int_tTFormula::GetNdim() const
virtual Int_tTFormula::GetNpar() const
virtual Int_tTFormula::GetNumber() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
Double_tTFormula::GetParameter(Int_t ipar) const
Double_tTFormula::GetParameter(const char* name) const
virtual Double_t*TFormula::GetParameters() const
virtual voidTFormula::GetParameters(Double_t* params)
virtual const char*TFormula::GetParName(Int_t ipar) const
virtual Int_tTFormula::GetParNumber(const char* name) const
virtual const char*TNamed::GetTitle() const
virtual TTree*GetTree() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() const
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
virtual Bool_tIsInteger(Bool_t fast = kTRUE) const
virtual Bool_tTFormula::IsLinear()
virtual Bool_tTFormula::IsNormalized()
Bool_tTObject::IsOnHeap() const
Bool_tIsQuickLoad() const
virtual Bool_tTNamed::IsSortable() const
virtual Bool_tIsString() const
Bool_tTObject::IsZombie() const
virtual voidTNamed::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tNotify()
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
voidTFormula::Optimize()
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTFormula::Print(Option_t* option = "") const
virtual char*PrintValue(Int_t mode = 0) const
virtual char*PrintValue(Int_t mode, Int_t instance, const char* decform = "9.9") const
virtual voidTFormula::ProcessLinear(TString& replaceformula)
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidResetLoading()
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") const
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
virtual voidSetAxis(TAxis* axis = 0)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
static voidTFormula::SetMaxima(Int_t maxop = 1000, Int_t maxpar = 1000, Int_t maxconst = 1000)
virtual voidTNamed::SetName(const char* name)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
virtual voidTFormula::SetNumber(Int_t number)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidTFormula::SetParameter(const char* name, Double_t parvalue)
virtual voidTFormula::SetParameter(Int_t ipar, Double_t parvalue)
virtual voidTFormula::SetParameters(const Double_t* params)
virtual voidTFormula::SetParameters(Double_t p0, Double_t p1, Double_t p2 = 0, Double_t p3 = 0, Double_t p4 = 0, Double_t p5 = 0, Double_t p6 = 0, Double_t p7 = 0, Double_t p8 = 0, Double_t p9 = 0, Double_t p10 = 0)
virtual voidTFormula::SetParName(Int_t ipar, const char* name)
virtual voidTFormula::SetParNames(const char* name0 = "p0", const char* name1 = "p1", const char* name2 = "p2", const char* name3 = "p3", const char* name4 = "p4", const char* name5 = "p5", const char* name6 = "p6", const char* name7 = "p7", const char* name8 = "p8", const char* name9 = "p9", const char* name10 = "p10")
voidSetQuickLoad(Bool_t quick)
virtual voidTNamed::SetTitle(const char* title = "")
virtual voidSetTree(TTree* tree)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual Int_tTNamed::Sizeof() const
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTFormula::Update()
virtual voidUpdateFormulaLeaves()
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
TTreeFormula(const char* name, const char* formula, TTree* tree, const vector<std::string>& aliases)
Bool_tBranchHasMethod(TLeaf* leaf, TBranch* branch, const char* method, const char* params, Long64_t readentry) const
voidTFormula::ClearFormula(Option_t* option = "")
virtual voidConvert(UInt_t fromVersion)
Int_tDefineAlternate(const char* expression)
voidDefineDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim* info, Int_t& virt_dim)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
virtual TClass*EvalClass(Int_t oper) const
Double_tTFormula::EvalParFast(const Double_t* x, const Double_t* params)
Double_tTFormula::EvalPrimitive(const Double_t* x, const Double_t* params)
Double_tTFormula::EvalPrimitive0(const Double_t* x, const Double_t* params)
Double_tTFormula::EvalPrimitive1(const Double_t* x, const Double_t* params)
Double_tTFormula::EvalPrimitive2(const Double_t* x, const Double_t* params)
Double_tTFormula::EvalPrimitive3(const Double_t* x, const Double_t* params)
Double_tTFormula::EvalPrimitive4(const Double_t* x, const Double_t* params)
Int_tFindLeafForExpression(const char* expression, TLeaf*& leaf, TString& leftover, Bool_t& final, UInt_t& paran_level, TObjArray& castqueue, vector<std::string>& aliasUsed, Bool_t& useLeafCollectionObject, const char* fullExpression)
Short_tTFormula::GetAction(Int_t code) const
Short_tTFormula::GetActionOptimized(Int_t code) const
Int_tTFormula::GetActionParam(Int_t code) const
Int_tTFormula::GetActionParamOptimized(Int_t code) const
TLeaf*GetLeafWithDatamember(const char* topchoice, const char* nextchice, Long64_t readentry) const
Int_t*TFormula::GetOper() const
Int_t*TFormula::GetOperOptimized() const
Int_tGetRealInstance(Int_t instance, Int_t codeindex)
virtual Double_tGetValueFromMethod(Int_t i, TLeaf* leaf) const
virtual void*GetValuePointerFromMethod(Int_t i, TLeaf* leaf) const
voidInit(const char* name, const char* formula)
virtual Bool_tIsLeafInteger(Int_t code) const
virtual Bool_tIsLeafString(Int_t code) const
virtual Bool_tIsString(Int_t oper) const
voidLoadBranches()
Bool_tLoadCurrentDim()
voidTFormula::MakePrimitive(const char* expr, Int_t pos)
voidTObject::MakeZombie()
Int_tParseWithLeaf(TLeaf* leaf, const char* expression, Bool_t final, UInt_t paran_level, TObjArray& castqueue, Bool_t useLeafCollectionObject, const char* fullExpression)
Int_tTFormula::PreCompile()
Int_tRegisterDimensions(Int_t code, TBranchElement* branch)
Int_tRegisterDimensions(Int_t code, TLeaf* leaf)
Int_tRegisterDimensions(const char* size, Int_t code)
Int_tRegisterDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim* multidim = 0)
Int_tRegisterDimensions(Int_t code, TFormLeafInfo* info, TFormLeafInfo* maininfo, Bool_t useCollectionObject)
voidResetDimensions()
voidTFormula::SetAction(Int_t code, Int_t value, Int_t param = 0)
voidTFormula::SetActionOptimized(Int_t code, Int_t value, Int_t param = 0)
virtual Bool_tSwitchToFormLeafInfo(Int_t code)
private:
TTreeFormula(const TTreeFormula&)
TTreeFormula&operator=(const TTreeFormula&)

Data Members

public:
enum { kIsCharacter
kMissingLeaf
kIsInteger
kDirect
kDataMember
kMethod
kIndexOfEntry
kEntries
kLength
kIteration
kLengthFunc
kSum
kEntryList
kTreeMember
kIndexOfLocalEntry
kAlias
kAliasString
kAlternate
kAlternateString
};
enum TFormula::[unnamed] { kEnd
kAdd
kSubstract
kMultiply
kDivide
kModulo
kcos
ksin
ktan
kacos
kasin
katan
katan2
kfmod
kpow
ksq
ksqrt
kstrstr
kmin
kmax
klog
kexp
klog10
kpi
kabs
ksign
kint
kSignInv
krndm
kAnd
kOr
kEqual
kNotEqual
kLess
kGreater
kLessThan
kGreaterThan
kNot
kcosh
ksinh
ktanh
kacosh
kasinh
katanh
kStringEqual
kStringNotEqual
kBitAnd
kBitOr
kLeftShift
kRightShift
kexpo
kxexpo
kyexpo
kzexpo
kxyexpo
kgaus
kxgaus
kygaus
kzgaus
kxygaus
klandau
kxlandau
kylandau
kzlandau
kxylandau
kpol
kxpol
kypol
kzpol
kParameter
kConstant
kBoolOptimize
kStringConst
kVariable
kFunctionCall
kData
kUnary
kBinary
kThree
kDefinedVariable
kDefinedString
kPlusD
kPlusDD
kMultD
kMultDD
kBoolOptimizeOr
kBoolOptimizeAnd
kBoolSet
kFDM
kFD0
kFD1
kFD2
kFD3
kNotGlobal
kNormalized
kLinear
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
public:
G__p2memfuncTFormula::fOptimal!pointer to optimal function
protected:
TObjArrayfAliases! List of TTreeFormula for each alias used.
vector<std::string>fAliasesUsed! List of aliases used during the parsing of the expression.
TBitsTFormula::fAlreadyFound! cache for information
TAxis*fAxis! pointer to histogram axis if this is a string
TObjArrayfBranches! List of branches to read. Similar to fLeaces but duplicates are zeroed out.
Short_tfCodes[500]List of leaf numbers referenced in formula
Double_t*TFormula::fConst[fNconst] Array of fNconst formula constants
Int_tfCumulSizes[500][5]Accumulated sizes of lower dimensions for each leaf after variable dimensions has been calculated
TObjArrayfDataMembers! List of leaf data members
Bool_tfDidBooleanOptimization! True if we executed one boolean optimization since the last time instance number 0 was evaluated
TList*fDimensionSetup! list of dimension setups, for delayed creation of the dimension information.
TString*TFormula::fExpr[fNoper] List of expressions
TString*TFormula::fExprOptimized![fNOperOptimized] List of expressions
Int_tfFixedSizes[500][5]Physical sizes of lower dimensions for each leaf
TObjArrayTFormula::fFunctionsArray of function calls to make
Bool_tfHasCastRecord whether the formula contain a cast operation or not
UChar_tfHasMultipleVarDim[500]True if the corresponding variable is an array with more than one variable dimension.
Int_tfIndexes[500][5]Index of array selected by user for each leaf
TObjArrayfLeafNamesList of TNamed describing leaves
TObjArrayfLeaves! List of leaf used in this formula.
TObjArrayTFormula::fLinearParts! Linear parts if the formula is linear (contains '|')
Int_t*fLookupType[fNindex] array indicating how each leaf should be looked-up
TTreeFormulaManager*fManager! The dimension coordinator.
TObjArrayfMethods! List of leaf method calls
Int_tfMultiplicityIndicator of the variability of the formula
Int_tTFormula::fNOperOptimized!Number of operators after optimization
TStringTNamed::fNameobject identifier
TString*TFormula::fNames[fNpar] Array of parameter names
Int_tfNcodesNumber of leaves referenced in formula
Int_tTFormula::fNconstNumber of constants
Int_tfNdata[500]! This caches the physical number of element in the leaf or datamember.
Int_tTFormula::fNdimDimension of function (1=1-Dim, 2=2-Dim,etc)
Int_tfNdimensions[500]Number of array dimensions in each leaf
Bool_tfNeedLoading! If true, the current entry has not been loaded yet.
Int_tfNindexSize of fIndex
Int_tTFormula::fNoperNumber of operators
Int_tTFormula::fNparNumber of parameters
Int_tTFormula::fNstringNumber of different constants character strings
Int_tTFormula::fNumberformula number identifier
Int_tTFormula::fNvalNumber of different variables in expression
TOperOffset*TFormula::fOperOffset![fNOperOptimized] Offsets of operrands
Int_t*TFormula::fOperOptimized![fNOperOptimized] List of operators. (See documentation for changes made at version 7)
Double_t*TFormula::fParams[fNpar] Array of fNpar parameters
TFormulaPrimitive**TFormula::fPredefined![fNPar] predefined function
Bool_tfQuickLoad! If true, branch GetEntry is only called when the entry number changes.
TStringTNamed::fTitleobject title
TTree*fTree! pointer to Tree
TTreeFormula*fVarIndexes[500][5]Pointer to a variable index.

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TTreeFormula(const TTreeFormula& )
 Tree Formula default constructor
TTreeFormula(const char* name, const char* formula, TTree* tree)
 Normal TTree Formula Constuctor
TTreeFormula(const char* name, const char* formula, TTree* tree, const vector<std::string>& aliases)
 Constructor used during the expansion of an alias
void Init(const char* name, const char* formula)
 Initialiation called from the constructors.
~TTreeFormula()
Tree Formula default destructor
*-*                  =================================
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
Int_t RegisterDimensions(const char *info, Int_t code)
 This method is used internally to decode the dimensions of the variables
Int_t RegisterDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim* multidim = 0)
 This method stores the dimension information for later usage.
Int_t RegisterDimensions(Int_t code, TFormLeafInfo* info, TFormLeafInfo* maininfo, Bool_t useCollectionObject)
 This method is used internally to decode the dimensions of the variables
Int_t RegisterDimensions(Int_t code, TBranchElement *branch)
 This method is used internally to decode the dimensions of the variables
Int_t RegisterDimensions(Int_t code, TLeaf *leaf)
 This method is used internally to decode the dimensions of the variables
Int_t DefineAlternate(const char* expression)
 This method check for treat the case where expression contains $Atl and load up
 both fAliases and fExpr.
 We return
   -1 in case of failure
   0 in case we did not find $Alt
   the action number in case of success.
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:
   -2  Error: some information is missing (message already printed)
   -1  Error: Syntax is incorrect (message already printed)
    0
    >0 the value returns is the action code.
Int_t FindLeafForExpression(const char* expression, TLeaf*& leaf, TString& leftover, Bool_t& final, UInt_t& paran_level, TObjArray& castqueue, vector<std::string>& aliasUsed, Bool_t& useLeafCollectionObject, const char* fullExpression)
 Look for the leaf corresponding to the start of expression.
 It returns the corresponding leaf if any.
 It also modify the following arguments:
   leftover: contain from expression that was not used to determine the leaf
   final:
   paran_level: number of un-matched open parenthesis
   cast_queue: list of cast to be done
   aliases: list of aliases used
 Return <0 in case of failure
 Return 0 if a leaf has been found
 Return 2 if info about the TTree itself has been requested.
Int_t DefinedVariable(TString& variable, Int_t& action)
-*Check if name is in the list of Tree/Branch leaves
*-*        ==================================================

   This member function redefines the function in TFormula
   If a leaf has a name corresponding to the argument name, then
   returns a new code.
   A TTreeFormula may contain more than one variable.
   For each variable referenced, the pointers to the corresponding
   branch and leaf is stored in the object arrays fBranches and fLeaves.

   name can be :
      - Leaf_Name (simple variable or data member of a ClonesArray)
      - Branch_Name.Leaf_Name
      - Branch_Name.Method_Name
      - Leaf_Name[index]
      - Branch_Name.Leaf_Name[index]
      - Branch_Name.Leaf_Name[index1]
      - Branch_Name.Leaf_Name[][index2]
      - Branch_Name.Leaf_Name[index1][index2]
   New additions:
      - Branch_Name.Leaf_Name[OtherLeaf_Name]
      - Branch_Name.Datamember_Name
      - '.' can be replaced by '->'
   and
      - Branch_Name[index1].Leaf_Name[index2]
      - Leaf_name[index].Action().OtherAction(param)
      - Leaf_name[index].Action()[val].OtherAction(param)

   The expected returns values are
     -2 :  the name has been recognized but won't be usable
     -1 :  the name has not been recognized
    >=0 :  the name has been recognized, return the internal code for this name.

TLeaf* GetLeafWithDatamember(const char* topchoice, const char* nextchice, Long64_t readentry) const
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 name provided in the argument.
Int_t GetRealInstance(Int_t instance, Int_t codeindex)
 Now let calculate what physical instance we really need.
 Some redundant code is used to speed up the cases where
 they are no dimensions.
 We know that instance is less that fCumulUsedSize[0] so
 we can skip the modulo when virt_dim is 0.
TClass* EvalClass(Int_t oper) const
  Evaluate the class of this treeformula

  If the 'value' of this formula is a simple pointer to an object,
  this function returns the TClass corresponding to its type.
TClass* EvalClass(Int_t oper) const
  Evaluate the class of the operation oper

  If the 'value' in the requested operation is a simple pointer to an object,
  this function returns the TClass corresponding to its type.
void* EvalObject(Int_t i = 0)
Evaluate this treeformula*-*-*-*-
*-*                  =========================

  Return the address of the object pointed to by the formula.
  Return 0 if the formula is not a single object
  The object type can be retrieved using by call EvalClass();
const char* EvalStringInstance(Int_t i = 0)
 Eval the instance as a string.
Double_t EvalInstance(Int_t i = 0, const char** stringStack = 0)
Evaluate this treeformula*-*-*-*-
*-*                  =========================

TFormLeafInfo * GetLeafInfo(Int_t code) const
-*-*Return DataMember corresponding to code
*-*            =======================================

  function called by TLeafObject::GetValue
  with the value of fLookupType computed in TTreeFormula::DefinedVariable
TLeaf * GetLeaf(Int_t n) const
-*-*Return leaf corresponding to serial number n
*-*            ============================================

TMethodCall * GetMethodCall(Int_t code) const
-*-*Return methodcall corresponding to code
*-*            =======================================

  function called by TLeafObject::GetValue
  with the value of fLookupType computed in TTreeFormula::DefinedVariable
Int_t GetNdata()
*-*Return number of available instances in the formula
*-*            ===================================================

Double_t GetValueFromMethod(Int_t i, TLeaf* leaf) const
 Return result of a leafobject method.
void* GetValuePointerFromMethod(Int_t i, TLeaf* leaf) const
 Return result of a leafobject method.
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, the generated histogram is forced
 to have an integer bin width
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 type integer, the generated histogram is
 forced to have an integer bin width
Bool_t IsString(Int_t oper) const
 return TRUE if the formula is a string
Bool_t IsString(Int_t oper) const
 (fOper[i]>=105000 && fOper[i]<110000) || fOper[i] == kStrings)
Bool_t IsLeafString(Int_t code) const
 return TRUE if the leaf or data member corresponding to code is a string
char * PrintValue(Int_t mode = 0) const
 Return value of variable as a string

      mode = -2 : Print line with ***
      mode = -1 : Print column names
      mode = 0  : Print column values
char * PrintValue(Int_t mode, Int_t instance, const char* decform = "9.9") const
 Return value of variable as a string

      mode = -2 : Print line with ***
      mode = -1 : Print column names
      mode = 0  : Print column values
  decform contains the requested format (with the same convention as printf).

void ResetLoading()
 Tell the formula that we are going to request a new entry.
void SetAxis(TAxis* axis = 0)
 Set the axis (in particular get the type).
void Streamer(TBuffer& b)
 Stream an object of class TTreeFormula.
void UpdateFormulaLeaves()
 this function is called TTreePlayer::UpdateFormulaLeaves, itself
 called by TChain::LoadTree when a new Tree is loaded.
 Because Trees in a TChain may have a different list of leaves, one
 must update the leaves numbers in the TTreeFormula used by the TreePlayer.
void ResetDimensions()
 Populate the TTreeFormulaManager with the dimension information.
void LoadBranches()
 Make sure that all the branches have been loaded properly.
Bool_t LoadCurrentDim()
void Convert(UInt_t fromVersion)
 Convert the fOper of a TTTreeFormula version fromVersion to the current in memory version
Bool_t SwitchToFormLeafInfo(Int_t code)
 Convert the underlying lookup method from the direct technique
 (dereferencing the address held by the branch) to the method using
 TFormLeafInfo.  This is in particular usefull in the case where we
 need to append an additional TFormLeafInfo (for example to call a
 method).
 Return false if the switch was unsuccessfull (basically in the
 case of an old style split tree).
TTreeFormula(const char* name, const char* formula, TTree* tree, const vector<std::string>& aliases)
TTreeFormula& operator=(const TTreeFormula& )
TTreeFormulaManager* GetManager()
{ return fManager; }
Int_t GetMultiplicity()
{return fMultiplicity;}
Int_t GetNcodes()
{return fNcodes;}
Bool_t IsQuickLoad()
{ return fQuickLoad; }
Bool_t Notify()
{ UpdateFormulaLeaves(); return kTRUE; }
void SetQuickLoad(Bool_t quick)
{ fQuickLoad = quick; }
void SetTree(TTree* tree)
{fTree = tree;}
TTree* GetTree()
{return fTree;}

Author: Rene Brun 19/01/96
Last update: root/treeplayer:$Id: TTreeFormula.h 20882 2007-11-19 11:31:26Z rdm $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.