TTree
class description - source file - inheritance tree
private:
protected:
const char* GetNameByIndex(TString& varexp, Int_t* index, Int_t colindex) const
virtual void MakeIndex(TString& varexp, Int_t* index)
public:
TTree TTree()
TTree TTree(const char* name, const char* title, Int_t splitlevel = 99)
TTree TTree(TTree&)
virtual void ~TTree()
virtual TFriendElement* AddFriend(const char* treename, const char* filename)
virtual void AddTotBytes(Int_t tot)
virtual void AddZipBytes(Int_t zip)
virtual void AutoSave()
virtual Int_t Branch(TList* list, Int_t bufsize = 32000, Int_t splitlevel = 99)
virtual Int_t Branch(const char* folder, Int_t bufsize = 32000, Int_t splitlevel = 99)
virtual TBranch* Branch(const char* name, void* address, const char* leaflist, Int_t bufsize = 32000)
virtual TBranch* Branch(const char* name, void* clonesaddress, Int_t bufsize = 32000, Int_t splitlevel = 1)
virtual TBranch* Branch(const char* name, const char* classname, void* addobj, Int_t bufsize = 32000, Int_t splitlevel = 99)
virtual TBranch* BranchOld(const char* name, const char* classname, void* addobj, Int_t bufsize = 32000, Int_t splitlevel = 1)
virtual TBranch* Bronch(const char* name, const char* classname, void* addobj, Int_t bufsize = 32000, Int_t splitlevel = 99)
virtual void Browse(TBrowser* b)
virtual void BuildIndex(const char* majorname, const char* minorname)
TStreamerInfo* BuildStreamerInfo(TClass* cl, void* pointer = 0)
static TClass* Class()
virtual TTree* CloneTree(Int_t nentries = -1, Option_t* option)
virtual void CopyAddresses(TTree* tree)
virtual Int_t CopyEntries(TTree* tree, Int_t nentries = -1)
virtual TTree* CopyTree(const char* selection, Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
Int_t Debug() const
virtual void Delete(Option_t* option)
virtual void Draw(Option_t* opt)
virtual Int_t Draw(const char* varexp, TCut selection, Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual Int_t Draw(const char* varexp, const char* selection, Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual void DropBuffers(Int_t nbytes)
virtual Int_t Fill()
virtual TBranch* FindBranch(const char* name)
virtual TLeaf* FindLeaf(const char* name)
virtual Int_t Fit(const char* funcname, const char* varexp, const char* selection, Option_t* option, Option_t* goption, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual TBranch* GetBranch(const char* name)
static Int_t GetBranchStyle()
virtual Int_t GetChainEntryNumber(Int_t entry) const
virtual Int_t GetChainOffset() const
TFile* GetCurrentFile() const
Int_t GetDebugMax() const
Int_t GetDebugMin() const
TDirectory* GetDirectory() const
virtual Stat_t GetEntries() const
virtual Stat_t GetEntriesFriend() const
virtual Int_t GetEntry(Int_t entry = 0, Int_t getall = 0)
virtual Int_t GetEntryNumber(Int_t entry) const
virtual Int_t GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const
virtual Int_t GetEntryNumberWithIndex(Int_t major, Int_t minor) const
virtual Int_t GetEntryWithIndex(Int_t major, Int_t minor)
virtual Int_t GetEstimate() const
Int_t GetEvent(Int_t entry = 0, Int_t getall = 0)
TEventList* GetEventList() const
TH1* GetHistogram()
virtual Int_t* GetIndex()
virtual Double_t* GetIndexValues()
virtual TIterator* GetIteratorOnAllLeaves(Bool_t dir = kIterForward)
virtual TLeaf* GetLeaf(const char* name)
virtual TObjArray* GetListOfBranches()
virtual TList* GetListOfFriends() const
virtual TObjArray* GetListOfLeaves()
virtual Int_t GetMakeClass() const
virtual Int_t GetMaxEntryLoop() const
virtual Double_t GetMaximum(const char* columname)
virtual Int_t GetMaxVirtualSize() const
virtual Double_t GetMinimum(const char* columname)
virtual Int_t GetNbranches()
virtual Int_t GetPacketSize() const
TVirtualTreePlayer* GetPlayer()
virtual Int_t GetReadEntry() const
virtual Int_t GetReadEvent() const
virtual Int_t GetScanField() const
TTreeFormula* GetSelect()
virtual Int_t GetSelectedRows()
virtual Int_t GetTimerInterval() const
virtual Stat_t GetTotBytes() const
virtual TTree* GetTree() const
virtual Int_t GetTreeNumber() const
virtual Int_t GetUpdate() const
virtual Double_t* GetV1()
virtual Double_t* GetV2()
virtual Double_t* GetV3()
TTreeFormula* GetVar1()
TTreeFormula* GetVar2()
TTreeFormula* GetVar3()
TTreeFormula* GetVar4()
virtual Double_t* GetW()
virtual Stat_t GetZipBytes() const
virtual void IncrementTotalBuffers(Int_t nbytes)
virtual TClass* IsA() const
virtual Bool_t IsFolder() const
virtual Int_t LoadTree(Int_t entry)
virtual void Loop(Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual Int_t MakeClass(const char* classname = 0, Option_t* option)
virtual Int_t MakeCode(const char* filename = 0)
virtual Int_t MakeSelector(const char* selector = 0)
Bool_t MemoryFull(Int_t nbytes)
virtual Bool_t Notify()
TPrincipal* Principal(const char* varexp, const char* selection, Option_t* option = np, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual void Print(Option_t* option) const
virtual Int_t Process(const char* filename, Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual Int_t Process(TSelector* selector, Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual Int_t Project(const char* hname, const char* varexp, const char* selection, Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual TSQLResult* Query(const char* varexp, const char* selection, Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual void Reset(Option_t* option)
virtual Int_t Scan(const char* varexp, const char* selection, Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual void SetAutoSave(Int_t autos = 10000000)
virtual void SetBasketSize(const char* bname, Int_t buffsize = 16000)
virtual void SetBranchAddress(const char* bname, void* add)
virtual void SetBranchStatus(const char* bname, Bool_t status = 1)
static void SetBranchStyle(Int_t style = 1)
virtual void SetChainOffset(Int_t offset = 0)
virtual void SetDebug(Int_t level = 1, Int_t min = 0, Int_t max = 9999999)
virtual void SetDirectory(TDirectory* dir)
virtual void SetEstimate(Int_t nentries = 10000)
virtual void SetEventList(TEventList* list)
virtual void SetMakeClass(Int_t make)
virtual void SetMaxEntryLoop(Int_t maxev = 1000000000)
virtual void SetMaxVirtualSize(Int_t size = 0)
virtual void SetName(const char* name)
virtual void SetObject(const char* name, const char* title)
virtual void SetScanField(Int_t n = 50)
virtual void SetTimerInterval(Int_t msec = 333)
virtual void SetUpdate(Int_t freq = 0)
virtual void Show(Int_t entry = -1)
virtual void ShowMembers(TMemberInspector& insp, char* parent)
virtual void StartViewer()
virtual void Streamer(TBuffer& b)
void StreamerNVirtual(TBuffer& b)
virtual Int_t UnbinnedFit(const char* funcname, const char* varexp, const char* selection, Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual void UseCurrentStyle()
private:
protected:
Stat_t fEntries Number of entries
Stat_t fTotBytes Total number of bytes in all branches before compression
Stat_t fZipBytes Total number of bytes in all branches after compression
Stat_t fSavedBytes Number of autosaved bytes
Int_t fTimerInterval Timer interval in milliseconds
Int_t fScanField Number of runs before prompting in Scan
Int_t fUpdate Update frequency for EntryLoop
Int_t fMaxEntryLoop Maximum number of entries to process
Int_t fMaxVirtualSize Maximum total size of buffers kept in memory
Int_t fAutoSave Autosave tree when fAutoSave bytes produced
Int_t fEstimate Number of entries to estimate histogram limits
Int_t fChainOffset ! Offset of 1st entry of this Tree in a TChain
Int_t fReadEntry ! Number of the entry being processed
Int_t fTotalBuffers ! Total number of bytes in branch buffers
Int_t fPacketSize ! Number of entries in one packet for parallel root
Int_t fNfill ! Local for EntryLoop
Int_t fDebug ! Debug level
Int_t fDebugMin ! First entry number to debug
Int_t fDebugMax ! Last entry number to debug
Int_t fMakeClass ! not zero when processing code generated by MakeClass
TDirectory* fDirectory ! Pointer to directory holding this tree
TObjArray fBranches List of Branches
TObjArray fLeaves Direct pointers to individual branch leaves
TEventList* fEventList ! Pointer to event selection list (if one)
TArrayD fIndexValues Sorted index values
TArrayI fIndex Index of sorted values
TList* fFriends pointer to list of friend elements
TVirtualTreePlayer* fPlayer ! Pointer to current Tree player
static Int_t fgBranchStyle Old/New branch style
public:
static const enum TObject:: kForceRead
See also
-
TChain, TNtuple, TNtupleD
TTree
a TTree object has a header with a name and a title.
It consists of a list of independent branches (TBranch). Each branch
has its own definition and list of buffers. Branch buffers may be
automatically written to disk or kept in memory until the Tree attribute
fMaxVirtualSize is reached.
Variables of one branch are written to the same buffer.
A branch buffer is automatically compressed if the file compression
attribute is set (default).
Branches may be written to different files (see TBranch::SetFile).
The ROOT user can decide to make one single branch and serialize one
object into one single I/O buffer or to make several branches.
Making one single branch and one single buffer can be the right choice
when one wants to process only a subset of all entries in the tree.
(you know for example the list of entry numbers you want to process).
Making several branches is particularly interesting in the data analysis
phase, when one wants to histogram some attributes of an object (entry)
without reading all the attributes.
/*
*/
==> TTree *tree = new TTree(name, title, maxvirtualsize)
Creates a Tree with name and title. Maxvirtualsize is by default 64Mbytes,
maxvirtualsize = 64000000(default) means: Keeps as many buffers in memory until
the sum of all buffers is greater than 64 Megabyte. When this happens,
memory buffers are written to disk and deleted until the size of all
buffers is again below the threshold.
maxvirtualsize = 0 means: keep only one buffer in memory.
Various kinds of branches can be added to a tree:
A - simple structures or list of variables. (may be for C or Fortran structures)
B - any object (inheriting from TObject). (we expect this option be the most frequent)
C - a ClonesArray. (a specialized object for collections of same class objects)
==> Case A
======
TBranch *branch = tree->Branch(branchname,address, leaflist, bufsize)
* address is the address of the first item of a structure
* leaflist is the concatenation of all the variable names and types
separated by a colon character :
The variable name and the variable type are separated by a slash (/).
The variable type may be 0,1 or 2 characters. If no type is given,
the type of the variable is assumed to be the same as the previous
variable. If the first variable does not have a type, it is assumed
of type F by default. The list of currently supported types is given below:
- C : a character string terminated by the 0 character
- B : an 8 bit signed integer (Char_t)
- b : an 8 bit unsigned integer (UChar_t)
- S : a 16 bit signed integer (Short_t)
- s : a 16 bit unsigned integer (UShort_t)
- I : a 32 bit signed integer (Int_t)
- i : a 32 bit unsigned integer (UInt_t)
- F : a 32 bit floating point (Float_t)
- D : a 64 bit floating point (Double_t)
==> Case B
======
TBranch *branch = tree->Branch(branchname,className,object, bufsize, splitlevel)
object is the address of a pointer to an existing object (derived from TObject).
if splitlevel=0, the object is serialized in the branch buffer.
if splitlevel=1 (default), this branch will automatically be split
into subbranches, with one subbranch for each data member or object
of the object itself. In case the object member is a TClonesArray,
the mechanism described in case C is applied to this array.
if splitlevel=2 ,this branch will automatically be split
into subbranches, with one subbranch for each data member or object
of the object itself. In case the object member is a TClonesArray,
it is processed as a TObject*, only one branch.
==> Case C
======
TBranch *branch = tree->Branch(branchname,clonesarray, bufsize, splitlevel)
clonesarray is the address of a pointer to a TClonesArray.
The TClonesArray is a direct access list of objects of the same class.
For example, if the TClonesArray is an array of TTrack objects,
this function will create one subbranch for each data member of
the object TTrack.
==> branch->SetAddress(Void *address)
In case of dynamic structures changing with each entry for example, one must
redefine the branch address before filling the branch again.
This is done via the TBranch::SetAddress member function.
==> tree->Fill()
loops on all defined branches and for each branch invokes the Fill function.
See also the class TNtuple (a simple Tree with branches of floats)
Adding a Branch to an Existing Tree
===================================
You may want to add a branch to an existing tree. For example,
if one variable in the tree was computed with a certain algorithm,
you may want to try another algorithm and compare the results.
One solution is to add a new branch, fill it, and save the tree.
The code below adds a simple branch to an existing tree.
Note the kOverwrite option in the Write method, it overwrites the
existing tree. If it is not specified, two copies of the tree headers
are saved.
void tree3AddBranch(){
TFile f("tree3.root","update");
Float_t new_v;
TTree *t3 = (TTree*)f->Get("t3");
TBranch *newBranch = t3->Branch("new_v",&new_v,"new_v/F");
//read the number of entries in the t3
Int_t nentries = (Int_t)t3->GetEntries();
for (Int_t i = 0; i < nentries; i++){
new_v= gRandom->Gaus(0,1);
newBranch->Fill();
}
// save only the new version of the tree
t3->Write("",TObject::kOverwrite);
}
Adding a branch is often not possible because the tree is in a read-only
file and you do not have permission to save the modified tree with the
new branch. Even if you do have the permission, you risk loosing the
original tree with an unsuccessful attempt to save the modification.
Since trees are usually large, adding a branch could extend it over the
2GB limit. In this case, the attempt to write the tree fails, and the
original data is erased.
In addition, adding a branch to a tree enlarges the tree and increases
the amount of memory needed to read an entry, and therefore decreases
the performance.
For these reasons, ROOT offers the concept of friends for trees (and chains).
We encourage you to use TTree::AddFriend rather than adding a branch manually.
/*
*/
=============================================================================
______________________________________________________________________________
*-*-*-*-*-*-*A simple example with histograms and a tree*-*-*-*-*-*-*-*-*-*
*-* ===========================================
This program creates :
- a one dimensional histogram
- a two dimensional histogram
- a profile histogram
- a tree
These objects are filled with some random numbers and saved on a file.
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
#include "TFile.h"
#include "TH1.h"
#include "TH2.h"
#include "TProfile.h"
#include "TRandom.h"
#include "TTree.h"
//______________________________________________________________________________
main(int argc, char **argv)
{
// Create a new ROOT binary machine independent file.
// Note that this file may contain any kind of ROOT objects, histograms,trees
// pictures, graphics objects, detector geometries, tracks, events, etc..
// This file is now becoming the current directory.
TFile hfile("htree.root","RECREATE","Demo ROOT file with histograms & trees");
// Create some histograms and a profile histogram
TH1F *hpx = new TH1F("hpx","This is the px distribution",100,-4,4);
TH2F *hpxpy = new TH2F("hpxpy","py ps px",40,-4,4,40,-4,4);
TProfile *hprof = new TProfile("hprof","Profile of pz versus px",100,-4,4,0,20);
// Define some simple structures
typedef struct {Float_t x,y,z;} POINT;
typedef struct {
Int_t ntrack,nseg,nvertex;
UInt_t flag;
Float_t temperature;
} EVENTN;
static POINT point;
static EVENTN eventn;
// Create a ROOT Tree
TTree *tree = new TTree("T","An example of ROOT tree with a few branches");
tree->Branch("point",&point,"x:y:z");
tree->Branch("eventn",&eventn,"ntrack/I:nseg:nvertex:flag/i:temperature/F");
tree->Branch("hpx","TH1F",&hpx,128000,0);
Float_t px,py,pz;
static Float_t p[3];
//--------------------Here we start a loop on 1000 events
for ( Int_t i=0; i<1000; i++) {
gRandom->Rannor(px,py);
pz = px*px + py*py;
Float_t random = gRandom->::Rndm(1);
// Fill histograms
hpx->Fill(px);
hpxpy->Fill(px,py,1);
hprof->Fill(px,pz,1);
// Fill structures
p[0] = px;
p[1] = py;
p[2] = pz;
point.x = 10*(random-1);;
point.y = 5*random;
point.z = 20*random;
eventn.ntrack = Int_t(100*random);
eventn.nseg = Int_t(2*eventn.ntrack);
eventn.nvertex = 1;
eventn.flag = Int_t(random+0.5);
eventn.temperature = 20+random;
// Fill the tree. For each event, save the 2 structures and 3 objects
// In this simple example, the objects hpx, hprof and hpxpy are slightly
// different from event to event. We expect a big compression factor!
tree->Fill();
}
//--------------End of the loop
tree->Print();
// Save all objects in this file
hfile.Write();
// Close the file. Note that this is automatically done when you leave
// the application.
hfile.Close();
return 0;
}
TTree(): TNamed()
*-*-*-*-*-*-*-*-*-*-*Default Tree constructor*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-* ========================
TTree(const char *name,const char *title, Int_t splitlevel)
:TNamed(name,title)
*-*-*-*-*-*-*-*-*-*Normal Tree constructor*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-* ======================
The Tree is created in the current directory
Use the various functions Branch below to add branches to this Tree.
If the first character of title is a "/", the function assumes a folder name.
In this case, it creates automatically branches following the folder hierarchy.
splitlevel may be used in this case to control the split level.
~TTree()
*-*-*-*-*-*-*-*-*-*-*Tree destructor*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-* =================
TFriendElement* AddFriend(const char *treename, const char *filename)
Add a TFriendElement to the list of friends
A TFriendElement TF describes a TTree object TF in a file.
When a TFriendElement TF is added to the the list of friends of an
existing TTree T, any variable from TF can be referenced in a query
to T.
A tree keeps a list of friends. In the context of a tree (or a chain),
friendship means unrestricted access to the friends data. In this way
it is much like adding another branch to the tree without taking the risk
of damaging it. To add a friend to the list, you can use the TTree::AddFriend
method. The tree in the diagram below has two friends (friend_tree1 and
friend_tree2) and now has access to the variables a,b,c,i,j,k,l and m.
/*
*/
The AddFriend method has two parameters, the first is the tree name and the
second is the name of the ROOT file where the friend tree is saved.
AddFriend automatically opens the friend file. If no file name is given,
the tree called ft1 is assumed to be in the same file as the original tree.
tree.AddFriend("ft1","friendfile1.root");
If the friend tree has the same name as the original tree, you can give it
an alias sin the context of the friendship:
tree.AddFriend("tree1 = tree","friendfile1.root");
Once the tree has friends, we can use TTree::Draw as if the friend's
variables were in the original tree. To specify which tree to use in
the Draw method, use the syntax:
<treeName>.<branchname>.<varname>
If the variablename is enough to uniquely identify the variable, you can
leave out the tree and/or branch name.
For example, these commands generate a 3-d scatter plot of variable "var"
in the TTree tree versus variable v1 in TTree ft1 versus variable v2 in
TTree ft2.
tree.AddFriend("ft1","friendfile1.root");
tree.AddFriend("ft2","friendfile2.root");
tree.Draw("var:ft1.v1:ft2.v2");
/*
*/
The picture illustrates the access of the tree and its friends with a
Draw command.
When AddFriend is called, the ROOT file is automatically opened and the
friend tree (ft1) is read into memory. The new friend (ft1) is added to
the list of friends of tree.
The number of entries in the friend must be equal or greater to the number
of entries of the original tree. If the friend tree has fewer entries a
warning is given and the missing entries are not included in the histogram.
To retrieve the list of friends from a tree use TTree::GetListOfFriends.
When the tree is written to file (TTree::Write), the friends list is saved
with it. And when the tree is retrieved, the trees on the friends list are
also retrieved and the friendship restored.
When a tree is deleted, the elements of the friend list are also deleted.
It is possible to declare a friend tree that has the same internal
structure (same branches and leaves) as the original tree, and compare the
same values by specifying the tree.
tree.Draw("var:ft1.var:ft2.var")
void AutoSave()
*-*-*-*-*-*-*-*-*-*-*AutoSave tree header every fAutoSave bytes*-*-*-*-*-*
*-* ==========================================
When large Trees are produced, it is safe to activate the AutoSave
procedure. Some branches may have buffers holding many entries.
AutoSave is automatically called by TTree::Fill when the number of bytes
generated since the previous AutoSave is greater than fAutoSave bytes.
This function may also be invoked by the user, for example every
N entries.
Each AutoSave generates a new key on the file.
Once the key with the tree header has been written, the previous cycle
(if any) is deleted.
Note that calling TTree::AutoSave too frequently (or similarly calling
TTree::SetAutoSave with a small value) is an expensive operation.
You should make tests for your own application to find a compromize
between speed and the quantity of information you may loose in case of
a job crash.
In case your program crashes before closing the file holding this tree,
the file will be automatically recovered when you will connect the file
in UPDATE mode.
The Tree will be recovered at the status corresponding to the last AutoSave.
Int_t Branch(TList *list, Int_t bufsize, Int_t splitlevel)
This new function creates one branch for each element in the list.
The function returns the total number of branches created.
Int_t Branch(const char *foldername, Int_t bufsize, Int_t splitlevel)
This function creates one branch for each element in the folder.
The function returns the total number of branches created.
TBranch* Branch(const char *name, void *address, const char *leaflist,Int_t bufsize)
*-*-*-*-*-*-*-*-*-*-*Create a new TTree Branch*-*-*-*-*-*-*-*-*-*-*-*-*
*-* =========================
This Branch constructor is provided to support non-objects in
a Tree. The variables described in leaflist may be simple variables
or structures.
See the two following constructors for writing objects in a Tree.
By default the branch buffers are stored in the same file as the Tree.
use TBranch::SetFile to specify a different file
TBranch* Branch(const char *name, void *clonesaddress, Int_t bufsize, Int_t splitlevel)
Special constructor for TClonesArray.
Note that this function is only provided for backward compatibility.
The Branch or Bronch methods can automatically detect the case of TClonesArray.
name: global name of this BranchClones
bufsize: buffersize in bytes of each individual data member buffer
clonesaddress is the address of a pointer to a TClonesArray.
This Tree option is provided in case each entry consists of one
or more arrays of same class objects (tracks, hits,etc).
This function creates as many branches as there are public data members
in the objects pointed by the TClonesArray. Note that these data members
can be only basic data types, not pointers or objects.
BranchClones have the following advantages compared to the two other
solutions (Branch and BranchObject).
- When reading the Tree data, it is possible to read selectively
a subset of one object (may be just one single data member).
- This solution minimizes the number of objects created/destructed.
- Data members of the same type are consecutive in the basket buffers,
therefore optimizing the compression algorithm.
- Array processing notation becomes possible in the query language.
By default the branch buffers are stored in the same file as the Tree.
use TBranch::SetFile to specify a different file
By default the two members of TObject (fBits and fUniqueID) are stored
on individual branches. If the splitlevel > 1, these two branches
will not be created.
TBranch* Branch(const char *name, const char *classname, void *addobj, Int_t bufsize, Int_t splitlevel)
create a new branch with the object of class classname at address addobj.
WARNING:
Starting with Root version 3.01, the Branch function uses the new style
branches (TBranchElement). To get the old behaviour, you can:
- call BranchOld or
- call TTree::SetBranchStyle(0)
Note that with the new style, classname does not need to derive from TObject.
It must derived from TObject if the branch style has been set to 0 (old)
Use splitlevel < 0 instead of splitlevel=0 when the class
has a custom Streamer
TBranch* BranchOld(const char *name, const char *classname, void *addobj, Int_t bufsize, Int_t splitlevel)
*-*-*-*-*-*-*-*-*-*-*Create a new TTree BranchObject*-*-*-*-*-*-*-*-*-*-*-*
*-* ===============================
Build a TBranchObject for an object of class classname.
addobj is the address of a pointer to an object of class classname.
IMPORTANT: classname must derive from TObject.
The class dictionary must be available (ClassDef in class header).
This option requires access to the library where the corresponding class
is defined. Accessing one single data member in the object implies
reading the full object.
See the next Branch constructor for a more efficient storage
in case the entry consists of arrays of identical objects.
By default the branch buffers are stored in the same file as the Tree.
use TBranch::SetFile to specify a different file
IMPORTANT NOTE about branch names
In case two or more master branches contain subbranches with
identical names, one must add a "." (dot) character at the end
of the master branch name. This will force the name of the subbranch
to be master.subbranch instead of simply subbranch.
This situation happens when the top level object (say event)
has two or more members referencing the same class.
For example, if a Tree has two branches B1 and B2 corresponding
to objects of the same class MyClass, one can do:
tree.Branch("B1.","MyClass",&b1,8000,1);
tree.Branch("B2.","MyClass",&b2,8000,1);
if MyClass has 3 members a,b,c, the two instructions above will generate
subbranches called B1.a, B1.b ,B1.c, B2.a, B2.b, B2.c
TBranch* Bronch(const char *name, const char *classname, void *add, Int_t bufsize, Int_t splitlevel)
*-*-*-*-*-*-*-*-*-*-*Create a new TTree BranchElement*-*-*-*-*-*-*-*-*-*-*-*
*-* ================================
WARNING about this new function
===============================
This function is designed to replace the function TTree::Branch above.
This function is far more powerful than the Branch function.
It supports the full C++, including STL and has the same behaviour
in split or non-split mode. classname does not have to derive from TObject.
The function is based on the new TStreamerInfo.
Build a TBranchElement for an object of class classname.
addobj is the address of a pointer to an object of class classname.
The class dictionary must be available (ClassDef in class header).
This option requires access to the library where the corresponding class
is defined. Accessing one single data member in the object implies
reading the full object.
By default the branch buffers are stored in the same file as the Tree.
use TBranch::SetFile to specify a different file
IMPORTANT NOTE about branch names
In case two or more master branches contain subbranches with
identical names, one must add a "." (dot) character at the end
of the master branch name. This will force the name of the subbranch
to be master.subbranch instead of simply subbranch.
This situation happens when the top level object (say event)
has two or more members referencing the same class.
For example, if a Tree has two branches B1 and B2 corresponding
to objects of the same class MyClass, one can do:
tree.Branch("B1.","MyClass",&b1,8000,1);
tree.Branch("B2.","MyClass",&b2,8000,1);
if MyClass has 3 members a,b,c, the two instructions above will generate
subbranches called B1.a, B1.b ,B1.c, B2.a, B2.b, B2.c
Use splitlevel < 0 instead of splitlevel=0 when the class
has a custom Streamer
void Browse(TBrowser *b)
void BuildIndex(const char *majorname, const char *minorname)
Build an index table using the leaves with name: major & minor name
The index is built in the following way:
A pass on all entries is made using TTree::Draw
var1 = majorname
var2 = minorname
sel = majorname +minorname*1e-9
The standard result from TTree::Draw is stored in fV1, fV2 and fW
The array fW is sorted into fIndex
Once the index is computed, one can retrieve one entry via
TTree:GetEntryWithIndex(majornumber, minornumber)
Example:
tree.BuildIndex("Run","Event"); //creates an index using leaves Run and Event
tree.GetEntryWithIndex(1234,56789); //reads entry corresponding to
Run=1234 and Event=56789
Note that majorname and minorname may be expressions using original
Tree variables eg: "run-90000", "event +3*xx"
In case an expression is specified, the equivalent expression must be computed
when calling GetEntryWithIndex.
Note that once the index is built, it can be saved with the TTree object
with tree.Write(); //if the file has been open in "update" mode.
The most convenient place to create the index is at the end of
the filling process just before saving the Tree header.
If a previous index was computed, it is redefined by this new call.
Note that this function can also be applied to a TChain.
TStreamerInfo* BuildStreamerInfo(TClass *cl, void *pointer)
Build StreamerInfo for class cl
pointer is an optional argument that may contain a pointer to an object of cl
TTree* CloneTree(Int_t nentries, Option_t *option)
Create a clone of this tree and copy nentries
By default copy all entries
option is reserved for future use
plan to implement option "ACTIVE" to copy only active branches
IMPORTANT: Before invoking this function, the branch addresses
of this TTree must have been set if one or more branches
is not a basic type.
For examples of CloneTree, see tutorials
-copytree:
Example of Root macro to copy a subset of a Tree to a new Tree
The input file has been generated by the program in $ROOTSYS/test/Event
with Event 1000 1 1 1
-copytree2:
Example of Root macro to copy a subset of a Tree to a new Tree
One branch of the new Tree is written to a separate file
The input file has been generated by the program in $ROOTSYS/test/Event
with Event 1000 1 1 1
void CopyAddresses(TTree *tree)
Set branch addresses of tree equal to the ones of this tree
Int_t CopyEntries(TTree *tree, Int_t nentries)
Copy nentries from tree to this tree
By default copy all entries
Return number of bytes copied to this tree.
TTree* CopyTree(const char *selection, Option_t *option, Int_t nentries, Int_t firstentry)
*-*-*-*-*-*-*-*-*copy a Tree with selection*-*-*-*-*-*
*-* ==========================
IMPORTANT: Before invoking this function, the branch addresses
of this TTree must have been set if one or more branches
is not a basic type.
For examples of CloneTree, see tutorials
-copytree:
Example of Root macro to copy a subset of a Tree to a new Tree
The input file has been generated by the program in $ROOTSYS/test/Event
with Event 1000 1 1 1
-copytree2:
Example of Root macro to copy a subset of a Tree to a new Tree
One branch of the new Tree is written to a separate file
The input file has been generated by the program in $ROOTSYS/test/Event
with Event 1000 1 1 1
void Delete(Option_t *option)
*-*-*-*-*-*-*-*-*Delete this tree from memory or/and disk
*-* ========================================
if option == "all" delete Tree object from memory AND from disk
all baskets on disk are deleted. All keys with same name
are deleted.
if option =="" only Tree object in memory is deleted.
Int_t Draw(const char *varexp, TCut selection, Option_t *option, Int_t nentries, Int_t firstentry)
*-*-*-*-*-*-*-*-*-*-*Draw expression varexp for specified entries-*-*-*-*-*
*-* ===========================================
This function accepts TCut objects as arguments.
Useful to use the string operator +
example:
ntuple.Draw("x",cut1+cut2+cut3);
Int_t Draw(const char *varexp, const char *selection, Option_t *option,Int_t nentries, Int_t firstentry)
*-*-*-*-*-*-*-*-*-*-*Draw expression varexp for specified entries-*-*-*-*-*
*-* ===========================================
varexp is an expression of the general form e1:e2:e3
where e1,etc is a formula referencing a combination of the columns
Example:
varexp = x simplest case: draw a 1-Dim distribution of column named x
= sqrt(x) : draw distribution of sqrt(x)
= x*y/z
= y:sqrt(x) 2-Dim dsitribution of y versus sqrt(x)
Note that the variables e1, e2 or e3 may contain a selection.
example, if e1= x*(y<0), the value histogrammed will be x if y<0
and will be 0 otherwise.
selection is an expression with a combination of the columns.
In a selection all the C++ operators are authorized.
The value corresponding to the selection expression is used as a weight
to fill the histogram.
If the expression includes only boolean operations, the result
is 0 or 1. If the result is 0, the histogram is not filled.
In general, the expression may be of the form:
value*(boolean expression)
if boolean expression is true, the histogram is filled with
a weight = value.
Examples:
selection1 = "x<y && sqrt(z)>3.2"
selection2 = "(x+y)*(sqrt(z)>3.2)"
selection1 returns a weigth = 0 or 1
selection2 returns a weight = x+y if sqrt(z)>3.2
returns a weight = 0 otherwise.
option is the drawing option
see TH1::Draw for the list of all drawing options.
If option contains the string "goff", no graphics is generated.
nentries is the number of entries to process (default is all)
first is the first entry to process (default is 0)
This function returns the number of selected entries. It returns -1
if an error occurs.
Drawing expressions using arrays and array elements
===================================================
Let assumes, a leaf fMatrix, on the branch fEvent, which is a 3 by 3 array,
or a TClonesArray.
In a TTree::Draw expression you can now access fMatrix using the following
syntaxes:
String passed What is used for each entry of the tree
"fMatrix" the 9 elements of fMatrix
"fMatrix[][]" the 9 elements of fMatrix
"fMatrix[2][2]" only the elements fMatrix[2][2]
"fMatrix[1]" the 3 elements fMatrix[1][0], fMatrix[1][1] and fMatrix[1][2]
"fMatrix[1][]" the 3 elements fMatrix[1][0], fMatrix[1][1] and fMatrix[1][2]
"fMatrix[][0]" the 3 elements fMatrix[0][0], fMatrix[1][0] and fMatrix[2][0]
"fEvent.fMatrix...." same as "fMatrix..." (unless there is more than one leaf named fMatrix!).
In summary, if a specific index is not specified for a dimension, TTree::Draw
will loop through all the indices along this dimension. Leaving off the
last (right most) dimension of specifying then with the two characters '[]'
is equivalent. For variable size arrays (and TClonesArray) the range
of the first dimension is recalculated for each entry of the tree.
TTree::Draw also now properly handling operations involving 2 or more arrays.
Let assume a second matrix fResults[5][2], here are a sample of some
of the possible combinations, the number of elements they produce and
the loop used:
expression element(s) Loop
"fMatrix[2][1] - fResults[5][2]" one no loop
"fMatrix[2][] - fResults[5][2]" three on 2nd dim fMatrix
"fMatrix[2][] - fResults[5][]" two on both 2nd dimensions
"fMatrix[][2] - fResults[][1]" three on both 1st dimensions
"fMatrix[][2] - fResults[][]" six on both 1st and 2nd dimensions of
fResults
"fMatrix[][2] - fResults[3][]" two on 1st dim of fMatrix and 2nd of
fResults (at the same time)
"fMatrix[][] - fResults[][]" six on 1st dim then on 2nd dim
In summary, TTree::Draw loops through all un-specified dimensions. To
figure out the range of each loop, we match each unspecified dimension
from left to right (ignoring ALL dimensions for which an index has been
specified), in the equivalent loop matched dimensions use the same index
and are restricted to the smallest range (of only the matched dimensions).
When involving variable arrays, the range can of course be different
for each entry of the tree.
So the loop equivalent to "fMatrix[][2] - fResults[3][]" is:
for (Int_t i0; i < min(3,2); i++) {
use the value of (fMatrix[i0][2] - fMatrix[3][i0])
}
So the loop equivalent to "fMatrix[][2] - fResults[][]" is:
for (Int_t i0; i < min(3,5); i++) {
for (Int_t i1; i1 < 2; i1++) {
use the value of (fMatrix[i0][2] - fMatrix[i0][i1])
}
}
So the loop equivalent to "fMatrix[][] - fResults[][]" is:
for (Int_t i0; i < min(3,5); i++) {
for (Int_t i1; i1 < min(3,2); i1++) {
use the value of (fMatrix[i0][i1] - fMatrix[i0][i1])
}
}
Saving the result of Draw to an histogram
=========================================
By default the temporary histogram created is called htemp.
One can retrieve a pointer to this histogram with:
TH1F *htemp = (TH1F*)gPad->GetPrimitive("htemp");
If varexp0 contains >>hnew (following the variable(s) name(s),
the new histogram created is called hnew and it is kept in the current
directory (and also the current pad).
Example:
tree.Draw("sqrt(x)>>hsqrt","y>0")
will draw sqrt(x) and save the histogram as "hsqrt" in the current
directory.
TH1F *hnew = (TH1F*)gDirectory->Get("hnew");
By default, the specified histogram is reset.
To continue to append data to an existing histogram, use "+" in front
of the histogram name;
tree.Draw("sqrt(x)>>+hsqrt","y>0")
will not reset hsqrt, but will continue filling.
Making a Profile histogram
==========================
In case of a 2-Dim expression, one can generate a TProfile histogram
instead of a TH2F histogram by specyfying option=prof or option=profs.
The option=prof is automatically selected in case of y:x>>pf
where pf is an existing TProfile histogram.
Saving the result of Draw to a TEventList
=========================================
TTree::Draw can be used to fill a TEventList object (list of entry numbers)
instead of histogramming one variable.
If varexp0 has the form >>elist , a TEventList object named "elist"
is created in the current directory. elist will contain the list
of entry numbers satisfying the current selection.
Example:
tree.Draw(">>yplus","y>0")
will create a TEventList object named "yplus" in the current directory.
In an interactive session, one can type (after TTree::Draw)
yplus.Print("all")
to print the list of entry numbers in the list.
By default, the specified entry list is reset.
To continue to append data to an existing list, use "+" in front
of the list name;
tree.Draw(">>+yplus","y>0")
will not reset yplus, but will enter the selected entries at the end
of the existing list.
Using a TEventList as Input
===========================
Once a TEventList object has been generated, it can be used as input
for TTree::Draw. Use TTree::SetEventList to set the current event list
Example:
TEventList *elist = (TEventList*)gDirectory->Get("yplus");
tree->SetEventList(elist);
tree->Draw("py");
Note: Use tree->SetEventList(0) if you do not want use the list as input.
How to obtain more info from TTree::Draw
========================================
Once TTree::Draw has been called, it is possible to access useful
information still stored in the TTree object via the following functions:
-GetSelectedRows() // return the number of entries accepted by the
//selection expression. In case where no selection
//was specified, returns the number of entries processed.
-GetV1() //returns a pointer to the double array of V1
-GetV2() //returns a pointer to the double array of V2
-GetV3() //returns a pointer to the double array of V3
-GetW() //returns a pointer to the double array of Weights
//where weight equal the result of the selection expression.
where V1,V2,V3 correspond to the expressions in
TTree::Draw("V1:V2:V3",selection);
Example:
Root > ntuple->Draw("py:px","pz>4");
Root > TGraph *gr = new TGraph(ntuple->GetSelectedRows(),
ntuple->GetV2(), ntuple->GetV1());
Root > gr->Draw("ap"); //draw graph in current pad
creates a TGraph object with a number of points corresponding to the
number of entries selected by the expression "pz>4", the x points of the graph
being the px values of the Tree and the y points the py values.
Important note: By default TTree::Draw creates the arrays obtained
with GetV1, GetV2, GetV3, GetW with a length corresponding to the
parameter fEstimate. By default fEstimate=10000 and can be modified
via TTree::SetEstimate. A possible recipee is to do
tree->SetEstimate(tree->GetEntries());
You must call SetEstimate if the expected number of selected rows
is greater than 10000.
You can use the option "goff" to turn off the graphics output
of TTree::Draw in the above example.
Automatic interface to TTree::Draw via the TTreeViewer
======================================================
A complete graphical interface to this function is implemented
in the class TTreeViewer.
To start the TTreeViewer, three possibilities:
- select TTree context menu item "StartViewer"
- type the command "TTreeViewer TV(treeName)"
- execute statement "tree->StartViewer();"
void DropBuffers(Int_t)
*-*-*-*-*Drop branch buffers to accomodate nbytes below MaxVirtualsize*-*-*-*
Int_t Fill()
*-*-*-*-*Fill all branches of a Tree*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-* ===========================
This function loops on all the branches of this tree.
For each branch, it copies to the branch buffer (basket) the current
values of the leaves data types.
If a leaf is a simple data type, a simple conversion to a machine
independent format has to be done.
TBranch* FindBranch(const char* branchname)
TLeaf* FindLeaf(const char* searchname)
Int_t Fit(const char *funcname ,const char *varexp, const char *selection,Option_t *option ,Option_t *goption,Int_t nentries, Int_t firstentry)
*-*-*-*-*-*-*-*-*Fit a projected item(s) from a Tree*-*-*-*-*-*-*-*-*-*
*-* ======================================
funcname is a TF1 function.
See TTree::Draw for explanations of the other parameters.
By default the temporary histogram created is called htemp.
If varexp contains >>hnew , the new histogram created is called hnew
and it is kept in the current directory.
The function returns the number of selected entries.
Example:
tree.Fit(pol4,sqrt(x)>>hsqrt,y>0)
will fit sqrt(x) and save the histogram as "hsqrt" in the current
directory.
See also TTree::UnbinnedFit
TBranch* GetBranch(const char *name)
Return pointer to the branch with name in this Tree or the list
of friends of this tree.
Int_t GetBranchStyle()
static function returning the current branch style
style = 0 old Branch
style = 1 new Bronch
TFile* GetCurrentFile() const
*-*-*-*-*-*Return pointer to the current file*-*-*-*-*-*-*-*
*-* ==================================
Stat_t GetEntriesFriend() const
return number of entries of this Tree if not zero
otherwise return the number of entries in the first friend Tree.
Int_t GetEntry(Int_t entry, Int_t getall)
*-*-*-*-*-*Read all branches of entry and return total number of bytes*-*-*
*-* ===========================================================
getall = 0 : get only active branches
getall = 1 : get all branches
The function returns the number of bytes read from the input buffer.
If entry does not exist or an I/O error occurs, the function returns 0.
Int_t GetEntryNumber(Int_t entry) const
*-*-*-*-*-*Return entry number corresponding to entry*-*-*
*-* ==========================================
if no selection list returns entry
else returns the entry number corresponding to the list index=entry
Int_t GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const
Return entry number corresponding to major and minor number
Note that this function returns only the entry number, not the data
To read the data corresponding to an entry number, use TTree::GetEntryWithIndex
the BuildIndex function has created a table of Double_t* of sorted values
corresponding to val = major + minor*1e-9;
The function performs binary search in this sorted table.
If it finds a pair that maches val, it returns directly the
index in the table.
If an entry corresponding to major and minor is not found, the function
returns the index of the major,minor pair immediatly lower than the
requested value, ie it will return -1 if the pair is lower than
the first entry in the index.
See also GetEntryNumberWithIndex
Int_t GetEntryNumberWithIndex(Int_t major, Int_t minor) const
Return entry number corresponding to major and minor number
Note that this function returns only the entry number, not the data
To read the data corresponding to an entry number, use TTree::GetEntryWithIndex
the BuildIndex function has created a table of Double_t* of sorted values
corresponding to val = major + minor*1e-9;
The function performs binary search in this sorted table.
If it finds a pair that maches val, it returns directly the
index in the table, otherwise it returns -1.
See also GetEntryNumberWithBestIndex
Int_t GetEntryWithIndex(Int_t major, Int_t minor)
Return entry corresponding to major and minor number
For example:
Int_t run = 1234;
Int_t event = 345;
Int_t serial= tree.GetEntryNumberWithIndex(run,event);
now the variable serial is in the range [0,nentries] and one can do
tree.GetEntry(serial);
TIterator* GetIteratorOnAllLeaves(Bool_t dir)
Creates a new iterator that will go through all the leaves on the tree
itself and its friend.
TLeaf* GetLeaf(const char *name)
Return pointer to the 1st Leaf named name in any Branch of this Tree
or any branch in the list of friend trees.
Double_t GetMaximum(const char *columname)
*-*-*-*-*-*-*-*-*Return maximum of column with name columname*-*-*-*-*-*-*
*-* ============================================
Double_t GetMinimum(const char *columname)
*-*-*-*-*-*-*-*-*Return minimum of column with name columname*-*-*-*-*-*-*
*-* ============================================
const char* GetNameByIndex(TString &varexp, Int_t *index,Int_t colindex) const
*-*-*-*-*-*-*-*-*Return name corresponding to colindex in varexp*-*-*-*-*-*
*-* ===============================================
varexp is a string of names separated by :
index is an array with pointers to the start of name[i] in varexp
TVirtualTreePlayer* GetPlayer()
Load the TTreePlayer (if not already done)
Pointer to player is fPlayer
Int_t LoadTree(Int_t entry)
*-*-*-*-*-*-*-*-*Set current Tree entry
*-* ======================
void Loop(Option_t *option, Int_t nentries, Int_t firstentry)
*-*-*-*-*-*-*-*-*Loop on nentries of this tree starting at firstentry
*-* ===================================================
Int_t MakeSelector(const char *selector)
====>
*-*-*-*-*-*-*Generate skeleton selector class for this Tree*-*-*-*-*-*-*
*-* ==============================================
The following files are produced: selector.h and selector.C
if selector is NULL, selector will be nameoftree.
The generated code in selector.h includes the following:
- Identification of the original Tree and Input file name
- Definition of selector class (data and functions)
- the following class functions:
- constructor and destructor
- void Begin(TTree *tree)
- void Init(TTree *tree)
- Bool_t Notify()
- Bool_t ProcessCut(Int-t entry)
- void ProcessFill(Int-t entry)
- void Terminate
The class selector derives from TSelector.
The generated code in selector.C includes empty functions defined above:
To use this function:
- connect your Tree file (eg: TFile f("myfile.root");)
- T->MakeSelector("myselect");
where T is the name of the Tree in file myfile.root
and myselect.h, myselect.C the name of the files created by this function.
In a Root session, you can do:
Root > T->Process("select.C")
====>
Int_t MakeClass(const char *classname, Option_t *option)
====>
*-*-*-*-*-*-*Generate skeleton analysis class for this Tree*-*-*-*-*-*-*
*-* ==============================================
The following files are produced: classname.h and classname.C
if classname is NULL, classname will be nameoftree.
When the option "anal" is specified, the function generates the
analysis class described in TTree::makeAnal.
The generated code in classname.h includes the following:
- Identification of the original Tree and Input file name
- Definition of analysis class (data and functions)
- the following class functions:
-constructor (connecting by default the Tree file)
-GetEntry(Int_t entry)
-Init(TTree *tree) to initialize a new TTree
-Show(Int_t entry) to read and Dump entry
The generated code in classname.C includes only the main
analysis function Loop.
To use this function:
- connect your Tree file (eg: TFile f("myfile.root");)
- T->MakeClass("MyClass");
where T is the name of the Tree in file myfile.root
and MyClass.h, MyClass.C the name of the files created by this function.
In a Root session, you can do:
Root > .L MyClass.C
Root > MyClass t
Root > t.GetEntry(12); // Fill t data members with entry number 12
Root > t.Show(); // Show values of entry 12
Root > t.Show(16); // Read and show values of entry 16
Root > t.Loop(); // Loop on all entries
====>
Int_t MakeCode(const char *filename)
====>
*-*-*-*-*-*-*-*-*Generate skeleton function for this Tree*-*-*-*-*-*-*
*-* ========================================
The function code is written on filename
if filename is NULL, filename will be nameoftree.C
The generated code includes the following:
- Identification of the original Tree and Input file name
- Connection of the Tree file
- Declaration of Tree variables
- Setting of branches addresses
- a skeleton for the entry loop
To use this function:
- connect your Tree file (eg: TFile f("myfile.root");)
- T->MakeCode("anal.C");
where T is the name of the Tree in file myfile.root
and anal.C the name of the file created by this function.
NOTE: Since the implementation of this function, a new and better
function TTree::MakeClass has been developped.
Author: Rene Brun
====>
void MakeIndex(TString &varexp, Int_t *index)
*-*-*-*-*-*-*-*-*Build Index array for names in varexp*-*-*-*-*-*-*-*-*-*-*
*-* =====================================
Bool_t MemoryFull(Int_t nbytes)
*-*-*-*-*-*Check if adding nbytes to memory we are still below MaxVirtualsize
*-* ==================================================================
Bool_t Notify()
function called when loading a new class library
TPrincipal* Principal(const char *varexp, const char *selection, Option_t *option, Int_t nentries, Int_t firstentry)
*-*-*-*-*-*-*-*-*Interface to the Principal Components Analysis class*-*-*
*-* ====================================================
Create an instance of TPrincipal
Fill it with the selected variables
if option "n" is specified, the TPrincipal object is filled with
normalized variables.
If option "p" is specified, compute the principal components
If option "p" and "d" print results of analysis
If option "p" and "h" generate standard histograms
If option "p" and "c" generate code of conversion functions
return a pointer to the TPrincipal object. It is the user responsability
to delete this object.
The option default value is "np"
see TTree::Draw for explanation of the other parameters.
The created object is named "principal" and a reference to it
is added to the list of specials Root objects.
you can retrieve a pointer to the created object via:
TPrincipal *principal =
(TPrincipal*)gROOT->GetListOfSpecials()->FindObject("principal");
void Print(Option_t *option) const
Print a summary of the Tree contents. In case options are "p" or "pa"
print information about the TPacketGenerator ("pa" is equivalent to
TPacketGenerator::Print("all")).
Wildcarding can be used to print only a subset of the branches
eg, T.Print("Elec*") will print all branches with name starting with "Elec"
Int_t Process(const char *filename,Option_t *option,Int_t nentries, Int_t firstentry)
*-*-*-*-*-*-*-*-*Process this tree executing the code in filename*-*-*-*-*
*-* ================================================
The code in filename is loaded (interpreted or compiled , see below)
filename must contain a valid class implementation derived from TSelector.
where TSelector has the following member functions:
void TSelector::Begin(). This function is called before looping on the
events in the Tree. The user can create his histograms in this function.
Bool_t TSelector::ProcessCut(Int_t entry). This function is called
before processing entry. It is the user's responsability to read
the corresponding entry in memory (may be just a partial read).
The function returns kTRUE if the entry must be processed,
kFALSE otherwise.
void TSelector::ProcessFill(Int_t entry). This function is called for
all selected events. User fills histograms in this function.
void TSelector::Terminate(). This function is called at the end of
the loop on all events.
void TTreeProcess::Begin(). This function is called before looping on the
events in the Tree. The user can create his histograms in this function.
if filename is of the form file.C, the file will be interpreted.
if filename is of the form file.C++, the file file.C will be compiled
and dynamically loaded.
if filename is of the form file.C+, the file file.C will be compiled
and dynamically loaded. At next call, if file.C is older than file.o
and file.so, the file.C is not compiled, only file.so is loaded.
The function returns the number of processed entries. It returns -1
in case of an error.
Int_t Process(TSelector *selector,Option_t *option, Int_t nentries, Int_t firstentry)
*-*-*-*-*-*-*-*-*Process this tree executing the code in selector*-*-*-*-*
*-* ================================================
The TSelector class has the following member functions:
void TSelector::Begin(). This function is called before looping on the
events in the Tree. The user can create his histograms in this function.
Bool_t TSelector::ProcessCut(Int_t entry). This function is called
before processing entry. It is the user's responsability to read
the corresponding entry in memory (may be just a partial read).
The function returns kTRUE if the entry must be processed,
kFALSE otherwise.
void TSelector::ProcessFill(Int_t entry). This function is called for
all selected events. User fills histograms in this function.
void TSelector::Terminate(). This function is called at the end of
the loop on all events.
void TTreeProcess::Begin(). This function is called before looping on the
events in the Tree. The user can create his histograms in this function.
Int_t Project(const char *hname, const char *varexp, const char *selection, Option_t *option,Int_t nentries, Int_t firstentry)
*-*-*-*-*-*-*-*-*Make a projection of a Tree using selections*-*-*-*-*-*-*
*-* =============================================
Depending on the value of varexp (described in Draw) a 1-D,2-D,etc
projection of the Tree will be filled in histogram hname.
Note that the dimension of hname must match with the dimension of varexp.
TSQLResult* Query(const char *varexp, const char *selection, Option_t *option, Int_t nentries, Int_t firstentry)
Loop on Tree & return TSQLResult object containing entries following selection
void Reset(Option_t *option)
*-*-*-*-*-*-*-*Reset buffers and entries count in all branches/leaves*-*-*
*-* ======================================================
Int_t Scan(const char *varexp, const char *selection, Option_t *option, Int_t nentries, Int_t firstentry)
*-*-*-*-*-*-*-*-*Loop on Tree & print entries following selection*-*-*-*-*-*
*-* ===============================================
void SetBasketSize(const char *bname, Int_t buffsize)
*-*-*-*-*-*-*-*-*Set branc(es) basket size*-*-*-*-*-*-*-*
*-* =========================
bname is the name of a branch.
if bname="*", apply to all branches.
if bname="xxx*", apply to all branches with name starting with xxx
see TRegexp for wildcarding options
buffsize = branc basket size
void SetBranchAddress(const char *bname, void *add)
*-*-*-*-*-*-*-*-*Set branch address*-*-*-*-*-*-*-*
*-* ==================
If object is a TTree, this function is only an interface to TBranch::SetAddress
Function overloaded by TChain.
void SetBranchStatus(const char *bname, Bool_t status)
*-*-*-*-*-*-*-*-*Set branch status Process or DoNotProcess*-*-*-*-*-*-*-*
*-* =========================================
bname is the name of a branch.
if bname="*", apply to all branches.
if bname="xxx*", apply to all branches with name starting with xxx
see TRegexp for wildcarding options
status = 1 branch will be processed
= 0 branch will not be processed
void SetBranchStyle(Int_t style)
static function setting the current branch style
style = 0 old Branch
style = 1 new Bronch
void SetDebug(Int_t level, Int_t min, Int_t max)
Set the debug level and the debug range
for entries in the debug range, the functions TBranchElement::Fill
and TBranchElement::GetEntry will print the number of bytes filled
or read for each branch.
void SetDirectory(TDirectory *dir)
Remove reference to this tree from current directory and add
reference to new directory dir. dir can be 0 in which case the tree
does not belong to any directory.
void SetEstimate(Int_t n)
*-*-*-*-*-*-*-*-*Set number of entries to estimate variable limits*-*-*-*
*-* ================================================
void SetName(const char *name)
Change the name of this Tree
void SetObject(const char *name, const char *title)
Change the name and title of this Tree
void Show(Int_t entry)
*-*-*-*-*-*Print values of all active leaves for entry*-*-*-*-*-*-*-*
*-* ===========================================
if entry==-1, print current entry (default)
void StartViewer()
*-*-*-*-*-*-*-*-*Start the TTreeViewer on this TTree*-*-*-*-*-*-*-*-*-*
*-* ===================================
ww is the width of the canvas in pixels
wh is the height of the canvas in pixels
void Streamer(TBuffer &b)
*-*-*-*-*-*-*-*-*Stream a class object*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-* =========================================
Int_t UnbinnedFit(const char *funcname ,const char *varexp, const char *selection,Option_t *option ,Int_t nentries, Int_t firstentry)
*-*-*-*-*-*Unbinned fit of one or more variable(s) from a Tree*-*-*-*-*-*
*-* ===================================================
funcname is a TF1 function.
See TTree::Draw for explanations of the other parameters.
Fit the variable varexp using the function funcname using the
selection cuts given by selection.
The list of fit options is given in parameter option.
option = "Q" Quiet mode (minimum printing)
= "V" Verbose mode (default is between Q and V)
= "E" Perform better Errors estimation using Minos technique
= "M" More. Improve fit results
You can specify boundary limits for some or all parameters via
func->SetParLimits(p_number, parmin, parmax);
if parmin>=parmax, the parameter is fixed
Note that you are not forced to fix the limits for all parameters.
For example, if you fit a function with 6 parameters, you can do:
func->SetParameters(0,3.1,1.e-6,0.1,-8,100);
func->SetParLimits(4,-10,-4);
func->SetParLimits(5, 1,1);
With this setup, parameters 0->3 can vary freely
Parameter 4 has boundaries [-10,-4] with initial value -8
Parameter 5 is fixed to 100.
For the fit to be meaningful, the function must be self-normalized.
i.e. It must have the same integral regardless of the parameter
settings. Otherwise the fit will effectively just maximize the
area.
In practice it is convenient to have a normalization variable
which is fixed for the fit. e.g.
TF1* f1 = new TF1("f1", "gaus(0)/sqrt(2*3.14159)/[2]", 0, 5);
f1->SetParameters(1, 3.1, 0.01);
f1->SetParLimits(0, 1, 1); // fix the normalization parameter to 1
data->UnbinnedFit("f1", "jpsimass", "jpsipt>3.0");
1, 2 and 3 Dimensional fits are supported.
See also TTree::Fit
void UseCurrentStyle()
*-*-*-*-*-*Replace current attributes by current style*-*-*-*-*
*-* ===========================================
Inline Functions
void AddTotBytes(Int_t tot)
void AddZipBytes(Int_t zip)
Int_t Debug() const
Int_t Draw(const char* varexp, const char* selection, Option_t* option, Int_t nentries = 1000000000, Int_t firstentry = 0)
Int_t GetChainEntryNumber(Int_t entry) const
Int_t GetChainOffset() const
Int_t GetDebugMax() const
Int_t GetDebugMin() const
TDirectory* GetDirectory() const
Stat_t GetEntries() const
Int_t GetEstimate() const
Int_t GetEvent(Int_t entry = 0, Int_t getall = 0)
TEventList* GetEventList() const
TH1* GetHistogram()
Int_t* GetIndex()
Double_t* GetIndexValues()
TObjArray* GetListOfBranches()
TObjArray* GetListOfLeaves()
TList* GetListOfFriends() const
Int_t GetMakeClass() const
Int_t GetMaxEntryLoop() const
Int_t GetMaxVirtualSize() const
Int_t GetNbranches()
Int_t GetPacketSize() const
Int_t GetReadEntry() const
Int_t GetReadEvent() const
Int_t GetScanField() const
TTreeFormula* GetSelect()
Int_t GetSelectedRows()
Int_t GetTimerInterval() const
TTree* GetTree() const
Int_t GetUpdate() const
Int_t GetTreeNumber() const
TTreeFormula* GetVar1()
TTreeFormula* GetVar2()
TTreeFormula* GetVar3()
TTreeFormula* GetVar4()
Double_t* GetV1()
Double_t* GetV2()
Double_t* GetV3()
Double_t* GetW()
Stat_t GetTotBytes() const
Stat_t GetZipBytes() const
void IncrementTotalBuffers(Int_t nbytes)
Bool_t IsFolder() const
void SetAutoSave(Int_t autos = 10000000)
void SetChainOffset(Int_t offset = 0)
void SetEventList(TEventList* list)
void SetMakeClass(Int_t make)
void SetMaxEntryLoop(Int_t maxev = 1000000000)
void SetMaxVirtualSize(Int_t size = 0)
void SetScanField(Int_t n = 50)
void SetTimerInterval(Int_t msec = 333)
void SetUpdate(Int_t freq = 0)
TClass* Class()
TClass* IsA() const
void ShowMembers(TMemberInspector& insp, char* parent)
void StreamerNVirtual(TBuffer& b)
TTree TTree(TTree&)
Author: Rene Brun 12/01/96
Last update: root/tree:$Name: $:$Id: TTree.cxx,v 1.87 2001/08/13 08:54:42 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
ROOT page - Class index - Top of the page
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.