class TChain: public TTree

 -- Default constructor.

 -- 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 ...
         }

 -- Destructor.

 -- Add all files referenced by the passed chain to this chain.
 The function returns the total number of files connected.

 -- 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 ...
         }

 The function returns the total number of files connected.

 -- 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.

 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.

 -- 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.

 -- Add the whole chain or tree as a friend of this chain.

 -- Add the whole chain or tree as a friend of this chain.

 -- Browse the contents of the chain.

 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.

 -- Initialize the packet descriptor string.

 Override the TTree::DirectoryAutoAdd behavior:
 we never auto add.

 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);

 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.

 -- See TTree::GetReadEntry().

 -- See TTree::GetReadEntry().

 -- Returns the expanded value of the alias.  Search in the friends if any.

 -- Return pointer to the branch name in the current tree.

 -- See TTree::GetReadEntry().

 -- Return absolute entry number in the chain.
 The input parameter entry is the entry number in
 the current tree of this chain.

 -- 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.

 -- 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.

 -- 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)

 -- 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).

 -- Return a pointer to the current file.
 If no file is connected, the first file is automatically loaded.

 -- Return a pointer to the leaf name in the current tree.

 -- Return a pointer to the list of branches of the current tree.

 Warning: May set current tree!

 Returns 1 on success and 0 on failure.

 -- Return a pointer to the list of leaves of the current tree.

 Warning: May set the current tree!

 -- Return maximum of column with name columname.

 -- Return minimum of column with name columname.

 -- Return the number of branches of the current tree.

 Warning: May set the current tree!

 -- See TTree::GetReadEntry().

 -- 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!

 -- 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.

 -- 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.

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

 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.

 -- Loop on nentries of this chain starting at firstentry.  (NOT IMPLEMENTED)

 -- List the chain.

 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);

 Merge all chains in the collection.  (NOT IMPLEMENTED)

 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 ...
    }

 -- Print the header information of each tree in the chain.
 See TTree::Print for a list of options.

 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.

 -- Resets the state of this chain.

 -- 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.

 -- 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.

 -- Reset the addresses of the branch.

 Reset the addresses of the branches.

 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.

 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.

 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.

 -- 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.

 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.

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

 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

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.

 -- Set number of entries per packet for parallel root.

 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.

 -- 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.

 -- Stream a class object.

 -- Dummy function kept for back compatibility.
 The cache is now activated automatically when processing TTrees/TChain.

                Warning, GetListOfFiles returns the list of TChainElements (not the list of files)
                see TChain::AddFile to see how to get the corresponding TFile objects