ROOT logo
ROOT » TREE » TREE » TChain

class TChain: public TTree


TChain

A chain is a collection of files containg TTree objects.
When the chain is created, the first parameter is the default name
for the Tree to be processed later on.

Enter a new element in the chain via the TChain::Add function.
Once a chain is defined, one can use the normal TTree functions
to Draw,Scan,etc.

Use TChain::SetBranchStatus to activate one or more branches for all
the trees in the chain.


Function Members (Methods)

public:
TChain()
TChain(const char* name, const char* title = "")
virtual~TChain()
voidTObject::AbstractMethod(const char* method) const
virtual Int_tAdd(TChain* chain)
virtual Int_tAdd(const char* name, Long64_t nentries = kBigNumber)
virtual voidTTree::AddBranchToCache(const char* bname, Bool_t subbranches = kFALSE)
virtual voidTTree::AddBranchToCache(TBranch* branch, Bool_t subbranches = kFALSE)
virtual Int_tAddFile(const char* name, Long64_t nentries = kBigNumber, const char* tname = "")
virtual Int_tAddFileInfoList(TCollection* list, Long64_t nfiles = kBigNumber)
virtual TFriendElement*AddFriend(const char* chainname, const char* dummy = "")
virtual TFriendElement*AddFriend(const char* chainname, TFile* dummy)
virtual TFriendElement*AddFriend(TTree* chain, const char* alias = "", Bool_t warn = kFALSE)
virtual voidTTree::AddTotBytes(Int_t tot)
virtual voidTTree::AddZipBytes(Int_t zip)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual Long64_tTTree::AutoSave(Option_t* option = "")
virtual Int_tTTree::Branch(TList* list, Int_t bufsize = 32000, Int_t splitlevel = 99)
virtual Int_tTTree::Branch(const char* folder, Int_t bufsize = 32000, Int_t splitlevel = 99)
virtual Int_tTTree::Branch(TCollection* list, Int_t bufsize = 32000, Int_t splitlevel = 99, const char* name = "")
virtual TBranch*TTree::Branch(const char* name, void* address, const char* leaflist, Int_t bufsize = 32000)
TBranch*TTree::Branch(const char* name, char* address, const char* leaflist, Int_t bufsize = 32000)
TBranch*TTree::Branch(const char* name, long address, const char* leaflist, Int_t bufsize = 32000)
TBranch*TTree::Branch(const char* name, int address, const char* leaflist, Int_t bufsize = 32000)
TBranch*TTree::Branch(const char* name, void** obj, Int_t bufsize = 32000, Int_t splitlevel = 99)
TBranch*TTree::Branch(const char* name, const char* classname, void** obj, Int_t bufsize = 32000, Int_t splitlevel = 99)
virtual TBranch*TTree::BranchOld(const char* name, const char* classname, void* addobj, Int_t bufsize = 32000, Int_t splitlevel = 1)
virtual TBranch*TTree::BranchRef()
virtual TBranch*TTree::Bronch(const char* name, const char* classname, void* addobj, Int_t bufsize = 32000, Int_t splitlevel = 99)
virtual voidBrowse(TBrowser*)
virtual Int_tTTree::BuildIndex(const char* majorname, const char* minorname = "0")
TStreamerInfo*TTree::BuildStreamerInfo(TClass* cl, void* pointer = 0, Bool_t canOptimize = kTRUE)
virtual voidCanDeleteRefs(Bool_t flag = kTRUE)
virtual TFile*TTree::ChangeFile(TFile* file)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTNamed::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual TTree*TTree::CloneTree(Long64_t nentries = -1, Option_t* option = "")
virtual Int_tTNamed::Compare(const TObject* obj) const
virtual voidTNamed::Copy(TObject& named) const
virtual voidTTree::CopyAddresses(TTree*, Bool_t undo = kFALSE)
virtual Long64_tTTree::CopyEntries(TTree* tree, Long64_t nentries = -1, Option_t* option = "")
virtual TTree*TTree::CopyTree(const char* selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)
virtual TBasket*TTree::CreateBasket(TBranch*)
virtual voidCreatePackets()
Int_tTTree::Debug() const
virtual voidTTree::Delete(Option_t* option = "")MENU
virtual voidDirectoryAutoAdd(TDirectory*)
Int_tTAttLine::DistancetoLine(Int_t px, Int_t py, Double_t xp1, Double_t yp1, Double_t xp2, Double_t yp2)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidDraw(Option_t* opt)
virtual Long64_tDraw(const char* varexp, const TCut& selection, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)
virtual Long64_tDraw(const char* varexp, const char* selection, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)MENU
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTTree::DropBaskets()
virtual voidTTree::DropBranchFromCache(const char* bname, Bool_t subbranches = kFALSE)
virtual voidTTree::DropBranchFromCache(TBranch* branch, Bool_t subbranches = kFALSE)
virtual voidTTree::DropBuffers(Int_t nbytes)
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
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 Int_tFill()
virtual voidTNamed::FillBuffer(char*& buffer)
virtual TBranch*FindBranch(const char* name)
virtual TLeaf*FindLeaf(const char* name)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual Int_tTTree::Fit(const char* funcname, const char* varexp, const char* selection = "", Option_t* option = "", Option_t* goption = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)MENU
virtual Int_tTTree::FlushBaskets() const
virtual const char*GetAlias(const char* aliasName) const
virtual Long64_tTTree::GetAutoFlush() const
virtual Long64_tTTree::GetAutoSave() const
virtual TBranch*GetBranch(const char* name)
virtual TBranchRef*TTree::GetBranchRef() const
virtual Bool_tGetBranchStatus(const char* branchname) const
static Int_tTTree::GetBranchStyle()
virtual Long64_tTTree::GetCacheSize() const
virtual Long64_tGetChainEntryNumber(Long64_t entry) const
virtual Long64_tTTree::GetChainOffset() const
virtual TTree::TClusterIteratorGetClusterIterator(Long64_t firstentry)
TFile*TTree::GetCurrentFile() const
Long64_tTTree::GetDebugMax() const
Long64_tTTree::GetDebugMin() const
Int_tTTree::GetDefaultEntryOffsetLen() const
TDirectory*TTree::GetDirectory() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual Long64_tGetEntries() const
virtual Long64_tGetEntries(const char* sel)
virtual Long64_tTTree::GetEntriesFast() const
virtual Long64_tTTree::GetEntriesFriend() const
virtual Int_tGetEntry(Long64_t entry = 0, Int_t getall = 0)
virtual TEntryList*TTree::GetEntryList()
virtual Long64_tGetEntryNumber(Long64_t entry) const
virtual Long64_tTTree::GetEntryNumberWithBestIndex(Int_t major, Int_t minor = 0) const
virtual Long64_tTTree::GetEntryNumberWithIndex(Int_t major, Int_t minor = 0) const
virtual Int_tGetEntryWithIndex(Int_t major, Int_t minor = 0)
virtual Long64_tTTree::GetEstimate() const
Int_tTTree::GetEvent(Long64_t entry = 0, Int_t getall = 0)
TEventList*TTree::GetEventList() const
TFile*GetFile() const
virtual Int_tTTree::GetFileNumber() const
virtual Color_tTAttFill::GetFillColor() const
virtual Style_tTAttFill::GetFillStyle() const
virtual TTree*TTree::GetFriend(const char*) const
virtual const char*TTree::GetFriendAlias(TTree*) const
TH1*TTree::GetHistogram()
virtual const char*TObject::GetIconName() const
virtual Int_t*TTree::GetIndex()
virtual Double_t*TTree::GetIndexValues()
virtual TIterator*TTree::GetIteratorOnAllLeaves(Bool_t dir = kIterForward)
virtual TLeaf*GetLeaf(const char* name)
virtual TLeaf*GetLeaf(const char* branchname, const char* leafname)
virtual Color_tTAttLine::GetLineColor() const
virtual Style_tTAttLine::GetLineStyle() const
virtual Width_tTAttLine::GetLineWidth() const
virtual TList*TTree::GetListOfAliases() const
virtual TObjArray*GetListOfBranches()
virtual TList*TTree::GetListOfClones()
TObjArray*GetListOfFiles() const
virtual TList*TTree::GetListOfFriends() const
virtual TObjArray*GetListOfLeaves()
Int_tTTree::GetMakeClass() const
virtual Color_tTAttMarker::GetMarkerColor() const
virtual Size_tTAttMarker::GetMarkerSize() const
virtual Style_tTAttMarker::GetMarkerStyle() const
virtual Long64_tTTree::GetMaxEntryLoop() const
virtual Double_tGetMaximum(const char* columname)
static Long64_tTTree::GetMaxTreeSize()
virtual Long64_tTTree::GetMaxVirtualSize() const
virtual Double_tGetMinimum(const char* columname)
virtual const char*TNamed::GetName() const
virtual Int_tGetNbranches()
TObject*TTree::GetNotify() const
Int_tGetNtrees() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
virtual Int_tTTree::GetPacketSize() const
TVirtualTreePlayer*TTree::GetPlayer()
virtual Long64_tGetReadEntry() const
virtual Long64_tTTree::GetReadEvent() const
virtual Int_tTTree::GetScanField() const
TTreeFormula*TTree::GetSelect()
virtual Long64_tTTree::GetSelectedRows()
TList*GetStatus() const
virtual Int_tTTree::GetTimerInterval() const
virtual const char*TNamed::GetTitle() const
virtual Long64_tTTree::GetTotBytes() const
TBuffer*TTree::GetTransientBuffer(Int_t size)
virtual TTree*GetTree() const
virtual TVirtualIndex*TTree::GetTreeIndex() const
virtual Int_tGetTreeNumber() const
Long64_t*GetTreeOffset() const
Int_tGetTreeOffsetLen() const
virtual UInt_tTObject::GetUniqueID() const
virtual Int_tTTree::GetUpdate() const
virtual TList*TTree::GetUserInfo()
virtual Double_t*TTree::GetV1()
virtual Double_t*TTree::GetV2()
virtual Double_t*TTree::GetV3()
virtual Double_t*TTree::GetV4()
virtual Double_t*TTree::GetVal(Int_t i)
TTreeFormula*TTree::GetVar(Int_t i)
TTreeFormula*TTree::GetVar1()
TTreeFormula*TTree::GetVar2()
TTreeFormula*TTree::GetVar3()
TTreeFormula*TTree::GetVar4()
virtual Double_t*TTree::GetW()
virtual Double_tGetWeight() const
virtual Long64_tTTree::GetZipBytes() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
virtual voidTTree::IncrementTotalBuffers(Int_t nbytes)
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() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTTree::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTNamed::IsSortable() const
virtual Bool_tTAttFill::IsTransparent() const
Bool_tTObject::IsZombie() const
virtual Int_tLoadBaskets(Long64_t maxmemory)
virtual Long64_tLoadTree(Long64_t entry)
virtual Long64_tTTree::LoadTreeFriend(Long64_t entry, TTree* T)
voidLookup(Bool_t force = kFALSE)
virtual voidLoop(Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)MENU
virtual voidls(Option_t* option = "") const
virtual Int_tTTree::MakeClass(const char* classname = 0, Option_t* option = "")
virtual Int_tTTree::MakeCode(const char* filename = 0)
virtual Int_tTTree::MakeProxy(const char* classname, const char* macrofilename = 0, const char* cutfilename = 0, const char* option = 0, Int_t maxUnrolling = 3)
virtual Int_tTTree::MakeSelector(const char* selector = 0)
voidTObject::MayNotUse(const char* method) const
Bool_tTTree::MemoryFull(Int_t nbytes)
virtual Long64_tMerge(const char* name, Option_t* option = "")
virtual Long64_tMerge(TCollection* list, Option_t* option = "")
virtual Long64_tMerge(TCollection* list, TFileMergeInfo* info)
virtual Long64_tMerge(TFile* file, Int_t basketsize, Option_t* option = "")
static TTree*TTree::MergeTrees(TList* list, Option_t* option = "")
virtual voidTAttLine::Modify()
virtual Bool_tTTree::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
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)
virtual voidTTree::OptimizeBaskets(ULong64_t maxMemory = 10000000, Float_t minComp = 1.1, Option_t* option = "")
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
TPrincipal*TTree::Principal(const char* varexp = "", const char* selection = "", Option_t* option = "np", Long64_t nentries = 1000000000, Long64_t firstentry = 0)
virtual voidPrint(Option_t* option = "") const
virtual voidTTree::PrintCacheStats(Option_t* option = "") const
virtual Long64_tProcess(const char* filename, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)MENU
virtual Long64_tProcess(void* selector, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)MENU
virtual Long64_tTTree::Project(const char* hname, const char* varexp, const char* selection = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)
virtual TSQLResult*TTree::Query(const char* varexp = "", const char* selection = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)
virtual Int_tTObject::Read(const char* name)
virtual Long64_tTTree::ReadFile(const char* filename, const char* branchDescriptor = "", char delimiter = ' ')
virtual Long64_tTTree::ReadStream(istream& inputStream, const char* branchDescriptor = "", char delimiter = ' ')
virtual voidRecursiveRemove(TObject* obj)
virtual voidTTree::Refresh()
virtual voidTTree::RemoveFriend(TTree*)
virtual voidReset(Option_t* option = "")
virtual voidResetAfterMerge(TFileMergeInfo*)
virtual voidTAttFill::ResetAttFill(Option_t* option = "")
virtual voidTAttLine::ResetAttLine(Option_t* option = "")
virtual voidTAttMarker::ResetAttMarker(Option_t* toption = "")
voidTObject::ResetBit(UInt_t f)
virtual voidResetBranchAddress(TBranch*)
virtual voidResetBranchAddresses()
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTAttFill::SaveFillAttributes(ostream& out, const char* name, Int_t coldef = 1, Int_t stydef = 1001)
virtual voidTAttLine::SaveLineAttributes(ostream& out, const char* name, Int_t coldef = 1, Int_t stydef = 1, Int_t widdef = 1)
virtual voidTAttMarker::SaveMarkerAttributes(ostream& out, const char* name, Int_t coldef = 1, Int_t stydef = 1, Int_t sizdef = 1)
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
virtual Long64_tScan(const char* varexp = "", const char* selection = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)MENU
virtual Bool_tTTree::SetAlias(const char* aliasName, const char* aliasFormula)
virtual voidSetAutoDelete(Bool_t autodel = kTRUE)
virtual voidTTree::SetAutoFlush(Long64_t autof = 30000000)
virtual voidTTree::SetAutoSave(Long64_t autos = 300000000)
virtual voidTTree::SetBasketSize(const char* bname, Int_t buffsize = 16000)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual Int_tSetBranchAddress(const char* bname, void* add, TBranch** ptr = 0)
virtual Int_tSetBranchAddress(const char* bname, void* add, TClass* realClass, EDataType datatype, Bool_t isptr)
virtual Int_tSetBranchAddress(const char* bname, void* add, TBranch** ptr, TClass* realClass, EDataType datatype, Bool_t isptr)
virtual voidSetBranchStatus(const char* bname, Bool_t status = 1, UInt_t* found = 0)
static voidTTree::SetBranchStyle(Int_t style = 1)
virtual voidTTree::SetCacheEntryRange(Long64_t first, Long64_t last)
virtual voidTTree::SetCacheLearnEntries(Int_t n = 10)
virtual voidTTree::SetCacheSize(Long64_t cachesize = -1)
virtual voidTTree::SetChainOffset(Long64_t offset = 0)
virtual voidTTree::SetCircular(Long64_t maxEntries)
virtual voidTTree::SetDebug(Int_t level = 1, Long64_t min = 0, Long64_t max = 9999999)MENU
virtual voidTTree::SetDefaultEntryOffsetLen(Int_t newdefault, Bool_t updateExisting = kFALSE)
virtual voidSetDirectory(TDirectory* dir)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
virtual Long64_tTTree::SetEntries(Long64_t n = -1)
virtual voidSetEntryList(TEntryList* elist, Option_t* opt = "")
virtual voidSetEntryListFile(const char* filename = "", Option_t* opt = "")
virtual voidTTree::SetEstimate(Long64_t nentries = 10000)
virtual voidSetEventList(TEventList* evlist)
virtual voidTTree::SetFileNumber(Int_t number = 0)
virtual voidTAttFill::SetFillAttributes()MENU
virtual voidTAttFill::SetFillColor(Color_t fcolor)
virtual voidTAttFill::SetFillStyle(Style_t fstyle)
virtual voidTAttLine::SetLineAttributes()MENU
virtual voidTAttLine::SetLineColor(Color_t lcolor)
virtual voidTAttLine::SetLineStyle(Style_t lstyle)
virtual voidTAttLine::SetLineWidth(Width_t lwidth)
virtual voidSetMakeClass(Int_t make)
virtual voidTAttMarker::SetMarkerAttributes()MENU
virtual voidTAttMarker::SetMarkerColor(Color_t tcolor = 1)
virtual voidTAttMarker::SetMarkerSize(Size_t msize = 1)
virtual voidTAttMarker::SetMarkerStyle(Style_t mstyle = 1)
virtual voidTTree::SetMaxEntryLoop(Long64_t maxev = 1000000000)MENU
static voidTTree::SetMaxTreeSize(Long64_t maxsize = 1900000000)
virtual voidTTree::SetMaxVirtualSize(Long64_t size = 0)MENU
virtual voidTTree::SetName(const char* name)MENU
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
virtual voidTTree::SetNotify(TObject* obj)
virtual voidTTree::SetObject(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidSetPacketSize(Int_t size = 100)
virtual voidTTree::SetParallelUnzip(Bool_t opt = kTRUE, Float_t RelSize = -1)
virtual voidSetProof(Bool_t on = kTRUE, Bool_t refresh = kFALSE, Bool_t gettreeheader = kFALSE)
virtual voidTTree::SetScanField(Int_t n = 50)MENU
virtual voidTTree::SetTimerInterval(Int_t msec = 333)
virtual voidTNamed::SetTitle(const char* title = "")MENU
virtual voidTTree::SetTreeIndex(TVirtualIndex* index)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidTTree::SetUpdate(Int_t freq = 0)
virtual voidSetWeight(Double_t w = 1, Option_t* option = "")
virtual voidTTree::Show(Long64_t entry = -1, Int_t lenmax = 20)
virtual voidShowMembers(TMemberInspector& insp)
virtual Int_tTNamed::Sizeof() const
virtual voidTTree::StartViewer()MENU
virtual voidTTree::StopCacheLearningPhase()
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 Int_tTTree::UnbinnedFit(const char* funcname, const char* varexp, const char* selection = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)
virtual voidUseCache(Int_t maxCacheSize = 10, Int_t pageSize = 0)
virtual voidTTree::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTTree::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTTree::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
voidTTree::AddClone(TTree*)
virtual TBranch*TTree::BranchImp(const char* branchname, TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel)
virtual TBranch*TTree::BranchImp(const char* branchname, const char* classname, TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel)
virtual TBranch*TTree::BranchImpRef(const char* branchname, const char* classname, TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel)
virtual TBranch*TTree::BranchImpRef(const char* branchname, TClass* ptrClass, EDataType datatype, void* addobj, Int_t bufsize, Int_t splitlevel)
virtual TBranch*TTree::BronchExec(const char* name, const char* classname, void* addobj, Bool_t isptrptr, Int_t bufsize, Int_t splitlevel)
virtual Int_tTTree::CheckBranchAddressType(TBranch* branch, TClass* ptrClass, EDataType datatype, Bool_t ptr)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
virtual TLeaf*TTree::GetLeafImpl(const char* branchname, const char* leafname)
charTTree::GetNewlineValue(istream& inputStream)
voidTTree::ImportClusterRanges(TTree* fromtree)
virtual voidTTree::KeepCircular()
voidTObject::MakeZombie()
voidReleaseChainProof()
Int_tTTree::SetBranchAddressImp(TBranch* branch, void* addr, TBranch** ptr)
private:
TChain(const TChain&)
TChain&operator=(const TChain&)

Data Members

protected:
TList*TTree::fAliasesList of aliases for expressions based on the tree branches.
Long64_tTTree::fAutoFlushAutoflush tree when fAutoFlush entries written
Long64_tTTree::fAutoSaveAutosave tree when fAutoSave bytes produced
TBranchRef*TTree::fBranchRefBranch supporting the TRefTable (if any)
TObjArrayTTree::fBranchesList of Branches
Long64_tTTree::fCacheSize! Maximum size of file buffers
Bool_tfCanDeleteRefs! If true, TProcessIDs are deleted when closing a file
Long64_tTTree::fChainOffset! Offset of 1st entry of this Tree in a TChain
TList*TTree::fClones! List of cloned trees which share our addresses
Long64_t*TTree::fClusterRangeEnd[fNClusterRange] Last entry of a cluster range.
Long64_t*TTree::fClusterSize[fNClusterRange] Number of entries in each cluster for a given range.
Int_tTTree::fDebug! Debug level
Long64_tTTree::fDebugMax! Last entry number to debug
Long64_tTTree::fDebugMin! First entry number to debug
Int_tTTree::fDefaultEntryOffsetLenInitial Length of fEntryOffset table in the basket buffers
TDirectory*TTree::fDirectory! Pointer to directory holding this tree
Long64_tTTree::fEntriesNumber of entries
TEntryList*TTree::fEntryList! Pointer to event selection list (if one)
Long64_tTTree::fEstimateNumber of entries to estimate histogram limits
TEventList*TTree::fEventList! Pointer to event selection list (if one)
TFile*fFile! Pointer to current file (We own the file).
Int_tTTree::fFileNumber! current file number (if file extensions)
TObjArray*fFiles-> List of file names containing the trees (TChainElement, owned)
Color_tTAttFill::fFillColorfill area color
Style_tTAttFill::fFillStylefill area style
Long64_tTTree::fFlushedBytesNumber of autoflushed bytes
UInt_tTTree::fFriendLockStatus! Record which method is locking the friend recursion
TList*TTree::fFriendspointer to list of friend elements
TArrayITTree::fIndexIndex of sorted values
TArrayDTTree::fIndexValuesSorted index values
TObjArrayTTree::fLeavesDirect pointers to individual branch leaves
Color_tTAttLine::fLineColorline color
Style_tTAttLine::fLineStyleline style
Width_tTAttLine::fLineWidthline width
Int_tTTree::fMakeClass! not zero when processing code generated by MakeClass
Color_tTAttMarker::fMarkerColorMarker color index
Size_tTAttMarker::fMarkerSizeMarker size
Style_tTAttMarker::fMarkerStyleMarker style
Int_tTTree::fMaxClusterRange! Memory allocated for the cluster range.
Long64_tTTree::fMaxEntriesMaximum number of entries in case of circular buffers
Long64_tTTree::fMaxEntryLoopMaximum number of entries to process
Long64_tTTree::fMaxVirtualSizeMaximum total size of buffers kept in memory
Int_tTTree::fNClusterRangeNumber of Cluster range in addition to the one defined by 'AutoFlush'
TStringTNamed::fNameobject identifier
Int_tTTree::fNfill! Local for EntryLoop
TObject*TTree::fNotify! Object to be notified when loading a Tree
Int_tfNtreesNumber of trees
Int_tTTree::fPacketSize! Number of entries in one packet for parallel root
TVirtualTreePlayer*TTree::fPlayer! Pointer to current Tree player
TChain*fProofChain! chain proxy when going to be processed by PROOF
Long64_tTTree::fReadEntry! Number of the entry being processed
Long64_tTTree::fSavedBytesNumber of autosaved bytes
Int_tTTree::fScanFieldNumber of runs before prompting in Scan
TList*fStatus-> List of active/inactive branches (TChainElement, owned)
Int_tTTree::fTimerIntervalTimer interval in milliseconds
TStringTNamed::fTitleobject title
Long64_tTTree::fTotBytesTotal number of bytes in all branches before compression
Long64_tTTree::fTotalBuffers! Total number of bytes in branch buffers
TBuffer*TTree::fTransientBuffer! Pointer to the current transient buffer.
TTree*fTree! Pointer to current tree (Note: We do *not* own this tree.)
TVirtualIndex*TTree::fTreeIndexPointer to the tree Index (if any)
Int_tfTreeNumber! Current Tree number in fTreeOffset table
Long64_t*fTreeOffset[fTreeOffsetLen] Array of variables
Int_tfTreeOffsetLenCurrent size of fTreeOffset array
Int_tTTree::fUpdateUpdate frequency for EntryLoop
TList*TTree::fUserInfopointer to a list of user objects associated to this Tree
Double_tTTree::fWeightTree weight (see TTree::SetWeight)
Long64_tTTree::fZipBytesTotal number of bytes in all branches after compression
static Int_tTTree::fgBranchStyleOld/New branch style
static Long64_tTTree::fgMaxTreeSizeMaximum size of a file containg a Tree

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TChain()
 -- Default constructor.
TChain(const char* name, const char* title = "")
 -- Create a chain.

   A TChain is a collection of TFile objects.
    the first parameter "name" is the name of the TTree object
    in the files added with Add.
   Use TChain::Add to add a new element to this chain.

   In case the Tree is in a subdirectory, do, eg:
     TChain ch("subdir/treename");

    Example:
  Suppose we have 3 files f1.root, f2.root and f3.root. Each file
  contains a TTree object named "T".
     TChain ch("T");  creates a chain to process a Tree called "T"
     ch.Add("f1.root");
     ch.Add("f2.root");
     ch.Add("f3.root");
     ch.Draw("x");
       The Draw function above will process the variable "x" in Tree "T"
       reading sequentially the 3 files in the chain ch.

   The TChain data structure
       Each TChainElement has a name equal to the tree name of this TChain
       and a title equal to the file name. So, to loop over the
       TFiles that have been added to this chain:

         TObjArray *fileElements=chain->GetListOfFiles();
         TIter next(fileElements);
         TChainElement *chEl=0;
         while (( chEl=(TChainElement*)next() )) {
            TFile f(chEl->GetTitle());
            ... do something with f ...
         }
~TChain()
 -- Destructor.
Int_t Add(TChain* chain)
 -- Add all files referenced by the passed chain to this chain.
 The function returns the total number of files connected.
Int_t Add(const char* name, Long64_t nentries = kBigNumber)
 -- Add a new file to this chain.

 Argument name may have the following format:
   //machine/file_name.root/subdir/tree_name
 machine, subdir and tree_name are optional. If tree_name is missing,
 the chain name will be assumed.
 In the file name part (but not in preceding directories) wildcarding
 notation may be used, eg. specifying "xxx*.root" adds all files starting
 with xxx in the current file system directory.
 NB. To add all the files of a TChain to a chain, use Add(TChain *chain).

    A- if nentries <= 0, the file is connected and the tree header read
       in memory to get the number of entries.

    B- if (nentries > 0, the file is not connected, nentries is assumed to be
       the number of entries in the file. In this case, no check is made that
       the file exists and the Tree existing in the file. This second mode
       is interesting in case the number of entries in the file is already stored
       in a run data base for example.

    C- if (nentries == kBigNumber) (default), the file is not connected.
       the number of entries in each file will be read only when the file
       will need to be connected to read an entry.
       This option is the default and very efficient if one process
       the chain sequentially. Note that in case TChain::GetEntry(entry)
       is called and entry refers to an entry in the 3rd file, for example,
       this forces the Tree headers in the first and second file
       to be read to find the number of entries in these files.
       Note that if one calls TChain::GetEntriesFast() after having created
       a chain with this default, GetEntriesFast will return kBigNumber!
       TChain::GetEntries will force of the Tree headers in the chain to be
       read to read the number of entries in each Tree.


    D- The TChain data structure
       Each TChainElement has a name equal to the tree name of this TChain
       and a title equal to the file name. So, to loop over the
       TFiles that have been added to this chain:

         TObjArray *fileElements=chain->GetListOfFiles();
         TIter next(fileElements);
         TChainElement *chEl=0;
         while (( chEl=(TChainElement*)next() )) {
            TFile f(chEl->GetTitle());
            ... do something with f ...
         }

 Return value:

 If nentries>0 (including the default of kBigNumber) and no
 wildcarding is used, ALWAYS returns 1 without regard to whether
 the file exists or contains the correct tree.

 If wildcarding is used, regardless of the value of nentries,
 returns the number of files matching the name without regard to
 whether they contain the correct tree.

 If nentries<=0 and wildcarding is not used, return 1 if the file
 exists and contains the correct tree and 0 otherwise.
Int_t AddFile(const char* name, Long64_t nentries = kBigNumber, const char* tname = "")
 -- Add a new file to this chain.

    If tname is specified, the chain will load the tree named tname
    from the file, otherwise the original treename specified in the
    TChain constructor will be used.

 A. If nentries <= 0, the file is opened and the tree header read
    into memory to get the number of entries.

 B. If nentries > 0, the file is not opened, and nentries is assumed
    to be the number of entries in the file. In this case, no check
    is made that the file exists nor that the tree exists in the file.
    This second mode is interesting in case the number of entries in
    the file is already stored in a run database for example.

 C. If nentries == kBigNumber (default), the file is not opened.
    The number of entries in each file will be read only when the file
    is opened to read an entry.  This option is the default and very
    efficient if one processes the chain sequentially.  Note that in
    case GetEntry(entry) is called and entry refers to an entry in the
    third file, for example, this forces the tree headers in the first
    and second file to be read to find the number of entries in those
    files.  Note that if one calls GetEntriesFast() after having created
    a chain with this default, GetEntriesFast() will return kBigNumber!
    Using the GetEntries() function instead will force all of the tree
    headers in the chain to be read to read the number of entries in
    each tree.

 D. The TChain data structure
    Each TChainElement has a name equal to the tree name of this TChain
    and a title equal to the file name. So, to loop over the
    TFiles that have been added to this chain:

      TObjArray *fileElements=chain->GetListOfFiles();
      TIter next(fileElements);
      TChainElement *chEl=0;
      while (( chEl=(TChainElement*)next() )) {
         TFile f(chEl->GetTitle());
         ... do something with f ...
      }

 The function returns 1 if the file is successfully connected, 0 otherwise.
Int_t AddFileInfoList(TCollection* list, Long64_t nfiles = kBigNumber)
 Add all files referenced in the list to the chain. The object type in the
 list must be either TFileInfo or TObjString or TUrl .
 The function return 1 if successful, 0 otherwise.
TFriendElement* AddFriend(const char* chainname, const char* dummy = "")
 -- Add a TFriendElement to the list of friends of this chain.

 A TChain has a list of friends similar to a tree (see TTree::AddFriend).
 You can add a friend to a chain with the TChain::AddFriend method, and you
 can retrieve the list of friends with TChain::GetListOfFriends.
 This example has four chains each has 20 ROOT trees from 20 ROOT files.

 TChain ch("t"); // a chain with 20 trees from 20 files
 TChain ch1("t1");
 TChain ch2("t2");
 TChain ch3("t3");
 Now we can add the friends to the first chain.

 ch.AddFriend("t1")
 ch.AddFriend("t2")
 ch.AddFriend("t3")


/* */

 The parameter is the name of friend chain (the name of a chain is always
 the name of the tree from which it was created).
 The original chain has access to all variable in its friends.
 We can use the TChain::Draw method as if the values in the friends were
 in the original chain.
 To specify the chain to use in the Draw method, use the syntax:

 <chainname>.<branchname>.<varname>
 If the variable name is enough to uniquely identify the variable, you can
 leave out the chain and/or branch name.
 For example, this generates a 3-d scatter plot of variable "var" in the
 TChain ch versus variable v1 in TChain t1 versus variable v2 in TChain t2.

 ch.Draw("var:t1.v1:t2.v2");
 When a TChain::Draw is executed, an automatic call to TTree::AddFriend
 connects the trees in the chain. When a chain is deleted, its friend
 elements are also deleted.

 The number of entries in the friend must be equal or greater to the number
 of entries of the original chain. If the friend has fewer entries a warning
 is given and the resulting histogram will have missing entries.
 For additional information see TTree::AddFriend.
TFriendElement* AddFriend(const char* chainname, TFile* dummy)
 -- Add the whole chain or tree as a friend of this chain.
TFriendElement* AddFriend(TTree* chain, const char* alias = "", Bool_t warn = kFALSE)
 -- Add the whole chain or tree as a friend of this chain.
void Browse(TBrowser* )
 -- Browse the contents of the chain.
void CanDeleteRefs(Bool_t flag = kTRUE)
 When closing a file during the chain processing, the file
 may be closed with option "R" if flag is set to kTRUE.
 by default flag is kTRUE.
 When closing a file with option "R", all TProcessIDs referenced by this
 file are deleted.
 Calling TFile::Close("R") might be necessary in case one reads a long list
 of files having TRef, writing some of the referenced objects or TRef
 to a new file. If the TRef or referenced objects of the file being closed
 will not be referenced again, it is possible to minimize the size
 of the TProcessID data structures in memory by forcing a delete of
 the unused TProcessID.
void CreatePackets()
 -- Initialize the packet descriptor string.
void DirectoryAutoAdd(TDirectory* )
 Override the TTree::DirectoryAutoAdd behavior:
 we never auto add.
Long64_t Draw(const char* varexp, const TCut& selection, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)
 Draw expression varexp for selected entries.
 Returns -1 in case of error or number of selected events in case of success.

 This function accepts TCut objects as arguments.
 Useful to use the string operator +, example:
    ntuple.Draw("x",cut1+cut2+cut3);

Long64_t Draw(const char* varexp, const char* selection, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)
 Process all entries in this chain and draw histogram corresponding to
 expression varexp.
 Returns -1 in case of error or number of selected events in case of success.
TBranch* FindBranch(const char* name)
 -- See TTree::GetReadEntry().
TLeaf* FindLeaf(const char* name)
 -- See TTree::GetReadEntry().
const char* GetAlias(const char* aliasName) const
 -- Returns the expanded value of the alias.  Search in the friends if any.
TBranch* GetBranch(const char* name)
 -- Return pointer to the branch name in the current tree.
Bool_t GetBranchStatus(const char* branchname) const
 -- See TTree::GetReadEntry().
TTree::TClusterIterator GetClusterIterator(Long64_t firstentry)
 Return an iterator over the cluster of baskets starting at firstentry.

 This iterator is not yet supported for TChain object.

Long64_t GetChainEntryNumber(Long64_t entry) const
 -- Return absolute entry number in the chain.
 The input parameter entry is the entry number in
 the current tree of this chain.
Long64_t GetEntries() const
 -- Return the total number of entries in the chain.
 In case the number of entries in each tree is not yet known,
 the offset table is computed.
Int_t GetEntry(Long64_t entry = 0, Int_t getall = 0)
 -- Get entry from the file to memory.

     getall = 0 : get only active branches
     getall = 1 : get all branches

 Return the total number of bytes read,
 0 bytes read indicates a failure.
Long64_t GetEntryNumber(Long64_t entry) const
 -- Return entry number corresponding to entry.

 if no TEntryList set returns entry
 else returns entry #entry from this entry list and
 also computes the global entry number (loads all tree headers)
Int_t GetEntryWithIndex(Int_t major, Int_t minor = 0)
 -- Return entry corresponding to major and minor number.

  The function returns the total number of bytes read.
  If the Tree has friend trees, the corresponding entry with
  the index values (major,minor) is read. Note that the master Tree
  and its friend may have different entry serial numbers corresponding
  to (major,minor).
TFile* GetFile() const
 -- Return a pointer to the current file.
 If no file is connected, the first file is automatically loaded.
TLeaf* GetLeaf(const char* branchname, const char* leafname)
 -- Return a pointer to the leaf name in the current tree.
TLeaf* GetLeaf(const char* name)
 -- Return a pointer to the leaf name in the current tree.
TObjArray* GetListOfBranches()
 -- Return a pointer to the list of branches of the current tree.

 Warning: If there is no current TTree yet, this routine will open the
     first in the chain.

 Returns 0 on failure.
TObjArray* GetListOfLeaves()
 -- Return a pointer to the list of leaves of the current tree.

 Warning: May set the current tree!

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.
Int_t GetNbranches()
 -- Return the number of branches of the current tree.

 Warning: May set the current tree!

Long64_t GetReadEntry() const
 -- See TTree::GetReadEntry().
Double_t GetWeight() const
 -- Return the chain weight.

 By default the weight is the weight of the current tree.
 However, if the weight has been set in TChain::SetWeight()
 with the option "global", then that weight will be returned.

 Warning: May set the current tree!

Int_t LoadBaskets(Long64_t maxmemory)
 -- Dummy function.
 It could be implemented and load all baskets of all trees in the chain.
 For the time being use TChain::Merge and TTree::LoadBasket
 on the resulting tree.
Long64_t LoadTree(Long64_t entry)
 -- Find the tree which contains entry, and set it as the current tree.

 Returns the entry number in that tree.

 The input argument entry is the entry serial number in the whole chain.

 In case of error, LoadTree returns a negative number:
   -1: The chain is empty.
   -2: The requested entry number of less than zero or too large for the chain.
       or too large for the large TTree.
   -3: The file corresponding to the entry could not be correctly open
   -4: The TChainElement corresponding to the entry is missing or
       the TTree is missing from the file.

 Note: This is the only routine which sets the value of fTree to
       a non-zero pointer.

void Lookup(Bool_t force = kFALSE)
 Check / locate the files in the chain.
 By default only the files not yet looked up are checked.
 Use force = kTRUE to check / re-check every file.
void Loop(Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)
 -- Loop on nentries of this chain starting at firstentry.  (NOT IMPLEMENTED)
void ls(Option_t* option = "") const
 -- List the chain.
Long64_t Merge(const char* name, Option_t* option = "")
 Merge all the entries in the chain into a new tree in a new file.

 See important note in the following function Merge().

 If the chain is expecting the input tree inside a directory,
 this directory is NOT created by this routine.

 So in a case where we have:

      TChain ch("mydir/mytree");
      ch.Merge("newfile.root");

 The resulting file will have not subdirectory. To recreate
 the directory structure do:

      TFile* file = TFile::Open("newfile.root", "RECREATE");
      file->mkdir("mydir")->cd();
      ch.Merge(file);

Long64_t Merge(TCollection* list, Option_t* option = "")
 Merge all chains in the collection.  (NOT IMPLEMENTED)
Long64_t Merge(TCollection* list, TFileMergeInfo* info)
 Merge all chains in the collection.  (NOT IMPLEMENTED)
Long64_t Merge(TFile* file, Int_t basketsize, Option_t* option = "")
 Merge all the entries in the chain into a new tree in the current file.

 Note: The "file" parameter is *not* the file where the new
       tree will be inserted.  The new tree is inserted into
       gDirectory, which is usually the most recently opened
       file, or the directory most recently cd()'d to.

 If option = "C" is given, the compression level for all branches
 in the new Tree is set to the file compression level.  By default,
 the compression level of all branches is the original compression
 level in the old trees.

 If basketsize > 1000, the basket size for all branches of the
 new tree will be set to basketsize.

 Example using the file generated in $ROOTSYS/test/Event
 merge two copies of Event.root

        gSystem.Load("libEvent");
        TChain ch("T");
        ch.Add("Event1.root");
        ch.Add("Event2.root");
        ch.Merge("all.root");

 If the chain is expecting the input tree inside a directory,
 this directory is NOT created by this routine.

 So if you do:

      TChain ch("mydir/mytree");
      ch.Merge("newfile.root");

 The resulting file will not have subdirectories.  In order to
 preserve the directory structure do the following instead:

      TFile* file = TFile::Open("newfile.root", "RECREATE");
      file->mkdir("mydir")->cd();
      ch.Merge(file);

 If 'option' contains the word 'fast' the merge will be done without
 unzipping or unstreaming the baskets (i.e., a direct copy of the raw
 bytes on disk).

 When 'fast' is specified, 'option' can also contains a
 sorting order for the baskets in the output file.

 There is currently 3 supported sorting order:
    SortBasketsByOffset (the default)
    SortBasketsByBranch
    SortBasketsByEntry

 When using SortBasketsByOffset the baskets are written in
 the output file in the same order as in the original file
 (i.e. the basket are sorted on their offset in the original
 file; Usually this also means that the baskets are sorted
 on the index/number of the _last_ entry they contain)

 When using SortBasketsByBranch all the baskets of each
 individual branches are stored contiguously.  This tends to
 optimize reading speed when reading a small number (1->5) of
 branches, since all their baskets will be clustered together
 instead of being spread across the file.  However it might
 decrease the performance when reading more branches (or the full
 entry).

 When using SortBasketsByEntry the baskets with the lowest
 starting entry are written first.  (i.e. the baskets are
 sorted on the index/number of the first entry they contain).
 This means that on the file the baskets will be in the order
 in which they will be needed when reading the whole tree
 sequentially.

 IMPORTANT Note 1: AUTOMATIC FILE OVERFLOW

 When merging many files, it may happen that the resulting file
 reaches a size > TTree::fgMaxTreeSize (default = 1.9 GBytes).
 In this case the current file is automatically closed and a new
 file started.  If the name of the merged file was "merged.root",
 the subsequent files will be named "merged_1.root", "merged_2.root",
 etc.  fgMaxTreeSize may be modified via the static function
 TTree::SetMaxTreeSize.
 When in fast mode, the check and switch is only done in between each
 input file.

 IMPORTANT Note 2: The output file is automatically closed and deleted.

 This is required because in general the automatic file overflow described
 above may happen during the merge.
 If only the current file is produced (the file passed as first argument),
 one can instruct Merge to not close and delete the file by specifying
 the option "keep".

 The function returns the total number of files produced.
 To check that all files have been merged use something like:
    if (newchain->GetEntries()!=oldchain->GetEntries()) {
      ... not all the file have been copied ...
    }
void Print(Option_t* option = "") const
 -- Print the header information of each tree in the chain.
 See TTree::Print for a list of options.
Long64_t Process(const char* filename, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)
 Process all entries in this chain, calling functions in filename.
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
 See TTree::Process.
Long64_t Process(void* selector, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)
 Process this chain executing the code in selector.
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
void RecursiveRemove(TObject* obj)
 Make sure that obj (which is being deleted or will soon be) is no
 longer referenced by this TTree.
void Reset(Option_t* option = "")
 Resets the state of this chain.
void ResetAfterMerge(TFileMergeInfo* )
 Resets the state of this chain after a merge (keep the customization but
 forget the data).
Long64_t Scan(const char* varexp = "", const char* selection = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)
 -- Loop on tree and print entries passing selection.
 If varexp is 0 (or "") then print only first 8 columns.
 If varexp = "*" print all columns.
 Otherwise a columns selection can be made using "var1:var2:var3".
 See TTreePlayer::Scan for more information.
void SetAutoDelete(Bool_t autodel = kTRUE)
 -- Set the global branch kAutoDelete bit.

  When LoadTree loads a new Tree, the branches for which
  the address is set will have the option AutoDelete set
  For more details on AutoDelete, see TBranch::SetAutoDelete.
void ResetBranchAddress(TBranch* )
 -- Reset the addresses of the branch.
void ResetBranchAddresses()
 Reset the addresses of the branches.
Int_t SetBranchAddress(const char* bname, void* add, TBranch** ptr = 0)
 Set branch address.

      bname is the name of a branch.
      add is the address of the branch.

    Note: See the comments in TBranchElement::SetAddress() for a more
          detailed discussion of the meaning of the add parameter.

 IMPORTANT REMARK:
 In case TChain::SetBranchStatus is called, it must be called
 BEFORE calling this function.

 See TTree::CheckBranchAddressType for the semantic of the return value.
Int_t SetBranchAddress(const char* bname, void* add, TClass* realClass, EDataType datatype, Bool_t isptr)
 Check if bname is already in the status list, and if not, create a TChainElement object and set its address.
 See TTree::CheckBranchAddressType for the semantic of the return value.

    Note: See the comments in TBranchElement::SetAddress() for a more
          detailed discussion of the meaning of the add parameter.

Int_t SetBranchAddress(const char* bname, void* add, TBranch** ptr, TClass* realClass, EDataType datatype, Bool_t isptr)
 Check if bname is already in the status list, and if not, create a TChainElement object and set its address.
 See TTree::CheckBranchAddressType for the semantic of the return value.

    Note: See the comments in TBranchElement::SetAddress() for a more
          detailed discussion of the meaning of the add parameter.

void SetBranchStatus(const char* bname, Bool_t status = 1, UInt_t* found = 0)
 -- Set branch status to Process or DoNotProcess

      bname is the name of a branch. if bname="*", apply to all branches.
      status = 1  branch will be processed
             = 0  branch will not be processed
  See IMPORTANT REMARKS in TTree::SetBranchStatus and TChain::SetBranchAddress

  If found is not 0, the number of branch(es) found matching the regular
  expression is returned in *found AND the error message 'unknown branch'
  is suppressed.
void SetDirectory(TDirectory* dir)
 Remove reference to this chain from current directory and add
 reference to new directory dir. dir can be 0 in which case the chain
 does not belong to any directory.
void SetEntryList(TEntryList* elist, Option_t* opt = "")
Set the input entry list (processing the entries of the chain will then be
limited to the entries in the list)
This function finds correspondance between the sub-lists of the TEntryList
and the trees of the TChain
By default (opt=""), both the file names of the chain elements and
the file names of the TEntryList sublists are expanded to full path name.
If opt = "ne", the file names are taken as they are and not expanded
void SetEntryListFile(const char* filename = "", Option_t* opt = "")
 Set the input entry list (processing the entries of the chain will then be
 limited to the entries in the list). This function creates a special kind
 of entry list (TEntryListFromFile object) that loads lists, corresponding
 to the chain elements, one by one, so that only one list is in memory at a time.

 If there is an error opening one of the files, this file is skipped and the
 next file is loaded

 File naming convention:
 - by default, filename_elist.root is used, where filename is the
   name of the chain element
 - xxx$xxx.root - $ sign is replaced by the name of the chain element
 If the list name is not specified (by passing filename_elist.root/listname to
 the TChain::SetEntryList() function, the first object of class TEntryList
 in the file is taken.

 It is assumed, that there are as many list files, as there are elements in
 the chain and they are in the same order
void SetEventList(TEventList* evlist)
This function transfroms the given TEventList into a TEntryList

NOTE, that this function loads all tree headers, because the entry numbers
in the TEventList are global and have to be recomputed, taking into account
the number of entries in each tree.

The new TEntryList is owned by the TChain and gets deleted when the chain
is deleted. This TEntryList is returned by GetEntryList() function, and after
GetEntryList() function is called, the TEntryList is not owned by the chain
any more and will not be deleted with it.
void SetPacketSize(Int_t size = 100)
 -- Set number of entries per packet for parallel root.
void SetProof(Bool_t on = kTRUE, Bool_t refresh = kFALSE, Bool_t gettreeheader = kFALSE)
 Enable/Disable PROOF processing on the current default Proof (gProof).

 "Draw" and "Processed" commands will be handled by PROOF.
 The refresh and gettreeheader are meaningfull only if on == kTRUE.
 If refresh is kTRUE the underlying fProofChain (chain proxy) is always
 rebuilt (even if already existing).
 If gettreeheader is kTRUE the header of the tree will be read from the
 PROOF cluster: this is only needed for browsing and should be used with
 care because it may take a long time to execute.
void SetWeight(Double_t w = 1, Option_t* option = "")
 -- Set chain weight.

 The weight is used by TTree::Draw to automatically weight each
 selected entry in the resulting histogram.
  For example the equivalent of
     chain.Draw("x","w")
  is
     chain.SetWeight(w,"global");
     chain.Draw("x");

  By default the weight used will be the weight
  of each Tree in the TChain. However, one can force the individual
  weights to be ignored by specifying the option "global".
  In this case, the TChain global weight will be used for all Trees.
void Streamer(TBuffer& b)
 -- Stream a class object.
void UseCache(Int_t maxCacheSize = 10, Int_t pageSize = 0)
 -- Dummy function kept for back compatibility.
 The cache is now activated automatically when processing TTrees/TChain.
TChain(const TChain& )
TChain& operator=(const TChain& )
void ReleaseChainProof()
Long64_t Draw(const char* varexp, const TCut& selection, Option_t* option = "", Long64_t nentries = kBigNumber, Long64_t firstentry = 0)
Int_t Fill()
{ MayNotUse("Fill()"); return -1; }
Int_t GetNtrees() const
{ return fNtrees; }
Long64_t GetEntries() const
TObjArray * GetListOfFiles() const
                Warning, GetListOfFiles returns the list of TChainElements (not the list of files)
                see TChain::AddFile to see how to get the corresponding TFile objects
{return fFiles;}
TList * GetStatus() const
{ return fStatus; }
TTree * GetTree() const
{ return fTree; }
Int_t GetTreeNumber() const
{ return fTreeNumber; }
Long64_t * GetTreeOffset() const
{ return fTreeOffset; }
Int_t GetTreeOffsetLen() const
{ return fTreeOffsetLen; }
void SetMakeClass(Int_t make)
{ TTree::SetMakeClass(make); if (fTree) fTree->SetMakeClass(make);}