ROOT » MISC » TABLE » TTable

class TTable: public TDataSet


TTable

 Wraps the array of the plain C-structures (one C-structure per element)

class TTable provides the automatic schema evolution for
the derived "table" classes saved with ROOT format.

"Automatic Schema evolution" provides:
-  skipping data-member if it is not present for the current
implementation of the "table" but was present at the time the
table was written;
-  assign a default value ZERO for the brand-new data-members,
those were not in the structure when the object was written but
present now;
-  trace propely any change in the order of the data-members

To enjoy this class one has to derive one's own custom class:

St_dst_track_Table.h:

#ifndef STAF_St_dst_track_Table
#define STAF_St_dst_track_Table

#include "TTable.h"

 #include "dst_track.h"  the C-structure defintion may be kept
separately
typedef struct dst_track_st {
     float r0;             /* radius at start (cm). See also comments*
     float phi0;           /* azimuthal angle at start (deg)         *
     float z0;             /* z-coord. at start (cm)                 *
     float psi;            /* azimuthal angle of pT vector (deg)     *
     float tanl;           /* tan(dip) =pz/pt at start               *
     float invpt;          /* 1/pt at start (GeV/c)^(-1)             *
     float curvature;      /* Track curvature (1/cm)                 *
     float covar[15];      /* full covariance matrix                 *
     float chisq[2];       /* Chi-square per degree of freedom       *
     float x_first[3];     /* coord. of first measured point (cm)    *
     float x_last[3];      /* coord. of last measured point (cm)     *
     float length;         /* from first to last point (cm)          *
     float impact;         /* primary vertex (cm)                    *
     unsigned long map[2]; /* extrap. info. (see preceding comments)*
     int id;               /* Primary key (see comments)             *
     int iflag;            /* bitmask quality info. (see comments)   *
     int det_id;           /* Detector id information                *
     int method;           /* Track finding/fitting method, packed   *
     int pid;              /* Geant particle ID for assumed mass     *
     int n_point;          /* SVT, TPC, FTPC component #s are packed *
     int n_max_point;      /* SVT, TPC, FTPC component #s are packed *
     int n_fit_point;      /* SVT, TPC, FTPC component #s are packed *
     int icharge;          /* Particle charge in units of |e|        *
     int id_start_vertex;  /* final fit and primary track candidates *
} DST_TRACK_ST;

class St_dst_track : public TTable
{
public:
ClassDefTable(St_dst_track,dst_track_st)
ClassDef(St_dst_track,2) //C++ wrapper for <dst_track> StAF table
};
#endif


where the CPP macro defines several convinient methods for the
"table" class (see: $ROOTSYS/table/inc/Ttypes.h for details:

  #define ClassDefTable(className,structName)
    protected:
       static TTableDescriptor *fgColDescriptors;
       virtual TTableDescriptor *GetDescriptorPointer() const { return fgColDescriptors;}
       virtual void SetDescriptorPointer(TTableDescriptor *list) const { fgColDescriptors = list;}
    public:
      typedef structName* iterator;
      className() : TTable(_QUOTE_(className),sizeof(structName))    {SetType(_QUOTE_(structName));}
      className(const char *name) : TTable(name,sizeof(structName)) {SetType(_QUOTE_(structName));}
      className(Int_t n) : TTable(_QUOTE_(className),n,sizeof(structName)) {SetType(_QUOTE_(structName));}
      className(const char *name,Int_t n) : TTable(name,n,sizeof(structName)) {SetType(_QUOTE_(structName));}
      structName *GetTable(Int_t i=0) const { return ((structName *)GetArray())+i;}
      structName &operator[](Int_t i){ assert(i>=0 && i < GetNRows()); return *GetTable(i); }
      const structName &operator[](Int_t i) const { assert(i>=0 && i < GetNRows()); return *((const structName *)(GetTable(i))); }
      structName *begin() const  {                      return GetNRows()? GetTable(0):0;}
      structName *end()   const  {Int_t i = GetNRows(); return          i? GetTable(i):0;}

The class implementation file may 2 lines and look as follows:
(for the example above):

St_dst_track_Table.cxx:

#include "St_dst_track_Table.h"
TableClassImpl(St_dst_track, dst_track_st)

LinkDef.h

To provide ROOT I/O for this class TWO CINT dictonary entries
should be defined with your custom LinkDef.h file
1. First entry (as usually) for the class derived from TTable
for example:
#pragma C++ class St_dst_track
2. Second entry for the C-structure wrapped into the class.
Since C-structuire is not derived from TObject it must be
properly defined as "foreign" ROOT class
#pragma C++ class dst_track_st+;

meta-variables i$ and n$ introduced
where "i$" stands for the current row index
"n$" stands for the total number of rows
meta-variable can be used along the normal
table column names in the expressions (see for example
method TTable::Draw


Function Members (Methods)

public:
virtual~TTable()
voidTObject::AbstractMethod(const char* method) const
virtual voidTDataSet::Add(TDataSet* dataset)
virtual Int_tAddAt(const void* c)
virtual voidAddAt(const void* c, Int_t i)
virtual voidAddAt(TDataSet* dataset, Int_t idx = 0)
virtual voidTDataSet::AddAtAndExpand(TDataSet* dataset, Int_t idx = 0)
virtual voidTDataSet::AddFirst(TDataSet* dataset)
virtual voidTDataSet::AddLast(TDataSet* dataset)
virtual voidAdopt(Int_t n, void* array)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual Long_tAppendRows(const void* row, UInt_t nRows)
virtual voidAsString(void* buf, TTable::EColumnType type, Int_t width, ostream& out) const
const void*At(Int_t i) const
virtual voidBrowse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual TObject*TDataSet::Clone(const char* newname = "") const
virtual Int_tTNamed::Compare(const TObject* obj) const
virtual voidTNamed::Copy(TObject& named) const
Int_tCopyRows(const TTable* srcTable, Long_t srcRow = 0, Long_t dstRow = 0, Long_t nRows = 0, Bool_t expand = kFALSE)
virtual voidCopySet(TTable& array)
virtual voidDeleteRows(Long_t indx, UInt_t nRows = 1)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidDraw(Option_t* opt)
virtual TH1*Draw(TCut varexp, TCut selection, Option_t* option = "", Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual TH1*Draw(const char* varexp, const char* selection, Option_t* option = "", Int_t nentries = 1000000000, Int_t firstentry = 0)MENU
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
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 voidTNamed::FillBuffer(char*& buffer)
virtual TDataSet*TDataSet::Find(const char* path) const
virtual TDataSet*TDataSet::FindByName(const char* name, const char* path = "", Option_t* opt = "") const
virtual TDataSet*TDataSet::FindByPath(const char* path) const
virtual TDataSet*TDataSet::FindByTitle(const char* title, const char* path = "", Option_t* opt = "") const
virtual TObject*TDataSet::FindObject(const char* name) const
virtual TObject*TDataSet::FindObject(const TObject* o) const
virtual TDataSet*TDataSet::First() const
virtual voidFit(const char* formula, const char* varexp, const char* selection = "", Option_t* option = "", Option_t* goption = "", Int_t nentries = 1000000000, Int_t firstentry = 0)MENU
void*GetArray() const
virtual TSeqCollection*TDataSet::GetCollection() const
virtual const Char_t*GetColumnComment(Int_t columnIndex) const
virtual Int_tGetColumnIndex(const Char_t* columnName) const
virtual const Char_t*GetColumnName(Int_t columnIndex) const
virtual UInt_tGetColumnSize(Int_t columnIndex) const
virtual Int_tGetColumnSize(const Char_t* columnName = 0) const
virtual TTable::EColumnTypeGetColumnType(Int_t columnIndex) const
virtual TTable::EColumnTypeGetColumnType(const Char_t* columnName = 0) const
virtual UInt_tGetDimensions(Int_t columnIndex) const
virtual Int_tGetDimensions(const Char_t* columnName = 0) const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TObject::GetIconName() const
virtual const UInt_t*GetIndexArray(Int_t columnIndex) const
TList*TDataSet::GetList() const
virtual Int_tTDataSet::GetListSize() const
static TDataSet*TDataSet::GetMainSet()
TObject*TDataSet::GetMother() const
virtual const char*TNamed::GetName() const
virtual Long_tGetNRows() const
virtual UInt_tGetNumberOfColumns() const
TObjArray*TDataSet::GetObjArray() const
virtual TObject*TDataSet::GetObject() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual UInt_tGetOffset(Int_t columnIndex) const
virtual Int_tGetOffset(const Char_t* columnName = 0) const
virtual Option_t*TObject::GetOption() const
virtual TDataSet*TDataSet::GetParent() const
virtual TClass*GetRowClass() const
virtual TTableDescriptor*GetRowDescriptors() const
virtual Long_tGetRowSize() const
Int_tGetSize() const
virtual TTableDescriptor*GetTableDescriptors() const
virtual Long_tGetTableSize() const
virtual const char*TNamed::GetTitle() const
virtual const Char_t*GetType() const
static TTable::EColumnTypeGetTypeId(const char* typeName)
static const char*GetTypeName(TTable::EColumnType type)
virtual UInt_tGetTypeSize(Int_t columnIndex) const
virtual Int_tGetTypeSize(const Char_t* columnName = 0) const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual Long_tHasData() const
virtual ULong_tTNamed::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual Long_tInsertRows(const void* rows, Long_t indx, UInt_t nRows = 1)
virtual voidTObject::Inspect() constMENU
virtual TDataSet*TDataSet::Instance() const
static TDataSet*TDataSet::instance()
voidTDataSet::InvertAllMarks()MENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTDataSet::IsEmpty() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tIsFolder() const
virtual Bool_tTDataSet::IsMarked() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTNamed::IsSortable() const
virtual Bool_tTDataSet::IsThisDir(const char* dirname, int len = -1, int ignorecase = 0) const
Bool_tTObject::IsZombie() const
virtual TDataSet*TDataSet::Last() const
virtual voidTDataSet::ls(Option_t* option = "") const
virtual voidTDataSet::ls(Int_t depth) const
virtual Char_t*MakeExpression(const Char_t*[] expressions, Int_t nExpressions)
voidTDataSet::Mark()MENU
voidTDataSet::Mark(UInt_t flag, TDataSet::EBitOpt reset = kSet)
voidTDataSet::MarkAll()MENU
voidTObject::MayNotUse(const char* method) const
Int_tNaN()
static TTable*New(const Char_t* name, const Char_t* type, void* array, UInt_t size)
virtual TDataSet*TDataSet::Next() const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
voidTObject::operator delete(void* ptr)
voidTObject::operator delete(void* ptr, void* vp)
voidTObject::operator delete[](void* ptr)
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)
TTable&operator=(const TTable& rhs)
void*operator[](Int_t i)
const void*operator[](Int_t i) const
virtual voidTObject::Paint(Option_t* option = "")
virtual TDataSet::EDataSetPassTDataSet::Pass(EDataSetPass(*)(TDataSet*) callback, Int_t depth = 0)
virtual TDataSet::EDataSetPassTDataSet::Pass(EDataSetPass(*)(TDataSet*,void*) callback, void* user, Int_t depth = 0)
virtual TStringTDataSet::Path() const
TTable::piteratorpbegin()
TTable::piteratorpend()
virtual voidTObject::Pop()
virtual TDataSet*TDataSet::Prev() const
virtual voidPrint(Option_t* opt = "") const
virtual Char_t*Print(Char_t* buf, Int_t n) const
virtual const Char_t*Print(Int_t row, Int_t rownumber = 10, const Char_t* colfirst = "", const Char_t* collast = "") constMENU
virtual voidPrintContents(Option_t* opt = "") const
virtual const Char_t*PrintHeader() constMENU
virtual voidProject(const char* hname, const char* varexp, const char* selection = "", Option_t* option = "", Int_t nentries = 1000000000, Int_t firstentry = 0)
virtual Int_tPurge(Option_t* opt = "")
virtual Int_tTObject::Read(const char* name)
void*ReAllocate()
void*ReAllocate(Int_t newsize)
virtual voidTObject::RecursiveRemove(TObject* obj)
virtual voidTDataSet::Remove(TDataSet* set)
virtual TDataSet*TDataSet::RemoveAt(Int_t idx)
virtual voidReset(Int_t c = 0)
voidTObject::ResetBit(UInt_t f)
virtual voidResetMap(Bool_t wipe = kTRUE)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidSavePrimitive(ostream& out, Option_t* option = "")
virtual voidSet(Int_t n)
virtual voidSet(Int_t n, Char_t* array)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
virtual voidTDataSet::SetMother(TDataSet* parent = 0)
virtual voidTNamed::SetName(const char* name)MENU
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
virtual voidSetNRows(Int_t n)
virtual voidTDataSet::SetObject(TObject* obj)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidTDataSet::SetParent(TDataSet* parent = 0)
virtual voidTNamed::SetTitle(const char* title = "")MENU
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidTDataSet::SetWrite()
virtual voidShowMembers(TMemberInspector& insp) const
virtual voidTDataSet::Shunt(TDataSet* newParent = 0)
virtual Int_tTNamed::Sizeof() const
virtual voidTDataSet::Sort()
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
static const char*TableDictionary()
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
TTable(const TTable& table)
TTable(const char* name = 0, Int_t size = 0)
TTable(const char* name, Int_t n, Int_t size)
TTable(const char* name, Int_t n, Char_t* array, Int_t size)
TTable(const char* name, const char* type, Int_t n, Char_t* array, Int_t size)
voidTDataSet::UnMark()MENU
voidTDataSet::UnMarkAll()MENU
virtual voidUpdate()
virtual voidUpdate(TDataSet* set, UInt_t opt = 0)
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTDataSet::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTDataSet::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
voidTDataSet::AddMain(TDataSet* set)
Bool_tBoundsOk(const char* where, Int_t at) const
virtual voidClear(Option_t* opt = "")
voidCopyStruct(Char_t* dest, const Char_t* src)
Char_t*Create()
virtual voidDelete(Option_t* opt = "")
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
virtual Bool_tEntryLoop(const Char_t* exprFileName, Int_t& action, TObject* obj, Int_t nentries = 1000000000, Int_t firstentry = 0, Option_t* option = "")
virtual TTableDescriptor*GetDescriptorPointer() const
TDataSet*TDataSet::GetRealParent()
voidTDataSet::MakeCollection()
voidTObject::MakeZombie()
Bool_tOutOfBoundsError(const char* where, Int_t i) const
voidReAlloc(Int_t newsize)
virtual voidSetDescriptorPointer(TTableDescriptor* list)
Int_tSetfN(Long_t len)
virtual voidTDataSet::SetMother(TObject* mother)
voidSetTablePointer(void* table)
virtual voidSetType(const char*const type)
voidSetUsedRows(Int_t n)
static TDataSet::EDataSetPassTDataSet::SortIt(TDataSet* ds)
static TDataSet::EDataSetPassTDataSet::SortIt(TDataSet* ds, void* user)
voidStreamerHeader(TBuffer& b, Version_t version = 3)
voidStreamerTable(TBuffer& b, Version_t version = 3)
static const char*TableDictionary(const char* className, const char* structName, TTableDescriptor*& ColDescriptors)

Data Members

public:
static const char*fgTypeName[13]
static TDataSet::EDataSetPassTDataSet::kAll
static TDataSet::ESetBitsTDataSet::kArray
static TObject::(anonymous)TObject::kBitMask
static TTable::EColumnTypekBool
static TObject::EStatusBitsTObject::kCanDelete
static TObject::EStatusBitsTObject::kCannotPick
static TTable::EColumnTypekChar
static TDataSet::EDataSetPassTDataSet::kContinue
static TTable::EColumnTypekDouble
static TTable::EColumnTypekEndColumnType
static TTable::EColumnTypekFloat
static TObject::EStatusBitsTObject::kHasUUID
static TTable::EColumnTypekInt
static TObject::EStatusBitsTObject::kInvalidObject
static TTable::ETableBitskIsNotOwn
static TObject::(anonymous)TObject::kIsOnHeap
static TObject::EStatusBitsTObject::kIsReferenced
static TTable::EColumnTypekLong
static TDataSet::ESetBitsTDataSet::kMark
static TDataSet::EDataSetPassTDataSet::kMarked
static TObject::EStatusBitsTObject::kMustCleanup
static TTable::EColumnTypekNAN
static TObject::EStatusBitsTObject::kNoContextMenu
static TObject::(anonymous)TObject::kNotDeleted
static TObject::EStatusBitsTObject::kObjInCanvas
static TObject::(anonymous)TObject::kOverwrite
static TDataSet::EDataSetPassTDataSet::kPrune
static TTable::EColumnTypekPtr
static TDataSet::EDataSetPassTDataSet::kRefs
static TDataSet::EBitOptTDataSet::kReset
static TDataSet::EBitOptTDataSet::kSet
static TTable::EColumnTypekShort
static TObject::(anonymous)TObject::kSingleKey
static TDataSet::EDataSetPassTDataSet::kStop
static TDataSet::EDataSetPassTDataSet::kStruct
static TTable::EColumnTypekUChar
static TTable::EColumnTypekUInt
static TTable::EColumnTypekULong
static TTable::EColumnTypekUShort
static TDataSet::EDataSetPassTDataSet::kUp
static TObject::(anonymous)TObject::kWriteDelete
static TObject::(anonymous)TObject::kZombie
protected:
TSeqCollection*TDataSet::fListList of the the the objects included into this dataset
Long_tfMaxIndexThe used capacity of this array
Int_tfNNumber of array elements
TStringTNamed::fNameobject identifier
TDataSet*TDataSet::fParentpointer to mother of the directory
Long_tfSizeSize of the one element (row) of the table
Char_t*fTableArray of (fN*fSize) longs
TStringTNamed::fTitleobject title
static TDataSet*TDataSet::fgMainSetpointer the main dataset;

Class Charts

Inheritance Chart:
TObject
TNamed
TDataSet
TTable
TGenericTable
TResponseTable
TIndexTable
TTableDescriptor

Function documentation

TTableDescriptor * GetTableDescriptors() const
 protected: create a new TTableDescriptor descriptor for this table
void AsString(void* buf, TTable::EColumnType type, Int_t width, ostream& out) const
 AsString represents the value provided via "void *b" with type defined
          by "name"

   void *buf  - the pointer to the value to be printed out.
        type  - the basic data type for the value above
       width  - the number of psotion to be used to print the value out

const char * GetTypeName(TTable::EColumnType type)
return table type name
const void * At(Int_t i) const
 Returns a pointer to the i-th row of the table
Int_t CopyRows(const TTable* srcTable, Long_t srcRow = 0, Long_t dstRow = 0, Long_t nRows = 0, Bool_t expand = kFALSE)
 CopyRows copies nRows from starting from the srcRow of srcTable
 to the dstRow in this table upto nRows or by the end of this table.

 This table if automaticaly increased if expand = kTRUE.
 The old values of this table rows are to be destroyed and
 replaced with the new ones.

 PARAMETERS:
   srcTable - a pointer to the table "donor"
   srcRow   - the index of the first row of the table donor to copy from
   dstRow   - the index of the first row of this table to copy to
   nRows    - the total number of rows to be copied. This table will be expanded
              as needed if expand = kTRUE (it is kFALSE "by default")
          = 0 to copy ALL remain rows from the srcTable.
   expand   - flag whether this table should reallocated if needed.

 RETURN:
          the number of the rows been copied
void DeleteRows(Long_t indx, UInt_t nRows = 1)
 Delete one or several rows from the table

  Int_t indx  - index of the first row to be deleted
  Int_t nRows - the total number of rows to be deleted
              = 1 "by default
TH1 * Draw(TCut varexp, TCut selection, Option_t* option = "", Int_t nentries = 1000000000, Int_t firstentry = 0)
*-*-*-*-*-*Draw expression varexp for specified entries
*-*                  ===========================================

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

   TCutG object with "CUTG" name can be created via the graphics editor.

TH1 * Draw(const char* varexp, const char* selection, Option_t* option = "", Int_t nentries = 1000000000, Int_t firstentry = 0)
*-*-*-*-*-*Draw expression varexp for specified entries
*-*                  ===========================================

  varexp is an expression of the general form e1:e2:e3
    where e1,etc is a C++ expression referencing a combination of the TTable columns
          One can use two extra meta variable "i$" and "n$" along with the table
          column names.
          i$ is to involve the current row number
          n$ refers the total num,ber of rows of this table provided by TTable::GetNRows()

  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)
            = i$:sqrt(x) 2-Dim dsitribution of i versus sqrt(x[i])
            = phep[0]:sqrt(phep[3]) 2-Dim dsitribution of phep[0] versus sqrt(phep[3])

  Note that the variables e1, e2 or e3 may contain a boolean expression as well.
  example, if e1= x*(y<0), the value histogrammed will be x if y<0
  and will be 0 otherwise.

  selection is a C++ expression with a combination of the columns.
  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 && 6 < i$ && i$ < n$"
      selection2 = "(x+y)*(sqrt(z)>3.2"
      selection3 = "signal*(log(signal)>1.2)"
  selection1 returns a weigth = 0 or 1
  selection2 returns a weight = x+y if sqrt(z)>3.2
             returns a weight = 0 otherwise.
  selection3 returns a weight = signal if log(signal)>1.2

  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)

     Saving the result of Draw to an histogram

  By default the temporary histogram created is called 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.
  Example:
    tree.Draw("sqrt(x)>>hsqrt","y>0")
    will draw sqrt(x) and save the histogram as "hsqrt" in the current
    directory.

  By default, the specified histogram is reset.
  To continue to append data to an existing histogram, use "+" in front
  of the histogram name;
    table.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

  TTable::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 TTable::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;
    table.Draw(">>+yplus","y>0")
      will not reset yplus, but will enter the selected entries at the end
      of the existing list.

Bool_t EntryLoop(const Char_t* exprFileName, Int_t& action, TObject* obj, Int_t nentries = 1000000000, Int_t firstentry = 0, Option_t* option = "")
 EntryLoop creates a CINT bytecode to evaluate the given expressions for
 all table rows in loop and fill the appropriated histograms.

 Solution for Byte code
 From: Masaharu Goto <MXJ02154@nifty.ne.jp>
 To: <fine@bnl.gov>
 Cc: <rootdev@hpsalo.cern.ch>
 Sent: 13-th august 1999 year  23:01

  action =  1  Fill 1-D histogram obj
         =  2  Fill 2-D histogram obj
         =  3  Fill 3-D histogram obj
         =  4  Fill Profile histogram obj
         =  5  Fill a TEventlist
         = 11  Estimate Limits
         = 12  Fill 2-D PolyMarker obj
         = 13  Fill 3-D PolyMarker obj
  action < 0   Evaluate Limits for case abs(action)

  Load file
TTable(const char* name = 0, Int_t size = 0)
 Default TTable ctor.
TTable(const char* name, Int_t n, Int_t size)
 Create TTable object and set array size to n longs.
TTable(const char* name, Int_t n, Char_t* array, Int_t size)
 Create TTable object and initialize it with values of array.
TTable(const char* name, const char* type, Int_t n, Char_t* array, Int_t size)
 Create TTable object and initialize it with values of array.
TTable(const TTable& table)
 Copy constructor.
TTable & operator=(const TTable& rhs)
 TTable assignment operator.
 This operator REALLOCATEs this table to fit the number of
 the USED rows of the source table if any
~TTable()
 Delete TTable object.
void Adopt(Int_t n, void* array)
 Adopt array arr into TTable, i.e. don't copy arr but use it directly
 in TTable. User may not delete arr, TTable dtor will do it.
Int_t AddAt(const void* c)
 Add        the "row" at the GetNRows() position, and
 reallocate the table if neccesary,               and
 return     the row index the "row" has occupied.

 row == 0 see method TTable::AddAt(const void *row, Int_t i)
void AddAt(const void* c, Int_t i)
 Add    one element ("row") of structure at position "i".
 Check  for out of bounds.

        If the row == 0 the "i" cell is still occupied and
 filled with the pattern "ff"
void CopyStruct(Char_t* dest, const Char_t* src)
 Copy the C-structure src into the new location
 the length of the strucutre is defined by this class descriptor
void CopySet(TTable& array)
to be documented
const Char_t * GetColumnComment(Int_t columnIndex) const
 Get a comment from the table descriptor
Long_t AppendRows(const void* row, UInt_t nRows)
 Append nRows row of the array "row" to the table
 return
    - the new table size (# of table rows)
    - 0 if the object doesn't own the internal array and can not expand it
Long_t InsertRows(const void* rows, Long_t indx, UInt_t nRows = 1)
 void InsertRows(cons void *row, Long_t indx, UInt_t nRows)

 Insert one or several rows into the table at "indx" position
 The rest table stuff is shifted down

  cons void    - a pointer to the array of rows to be inserted
  Long_t indx =  The position these rows will be inserted to
  Int_t nRows  - the total number of rows to be inserted
                 = 1 "by default
  return:
  The number of the rows has been shifted to accomodate
  the new rows.

void * ReAllocate()
 Reallocate this table leaving only (used rows)+1 allocated
 GetTableSize() = GetNRows() + 1
 returns a pointer to the first row of the reallocated table
 Note:
 The table is reallocated if it is an owner of the internal array
void * ReAllocate(Int_t newsize)
 Reallocate this table leaving only <newsize> allocated
 GetTableSize() = newsize;
 returns a pointer to the first row of the reallocated table
 Note:
 The table is reallocated if it is an owner of the internal array
void ReAlloc(Int_t newsize)
 The table is reallocated if it is an owner of the internal array
Char_t * Create()
 Allocate a space for the new table, if any
 Sleep for a while if space is not available and try again
void Browse(TBrowser* b)
 Wrap each table coulumn with TColumnView object to browse.
void Clear(Option_t* opt = "")
 Deletes the internal array of this class
 if this object does own its internal table
void Delete(Option_t* opt = "")
 Delete the internal array and free the memory it occupied
 if this object did own this array

 Then perform TDataSet::Delete(opt)
TClass * GetRowClass() const
to be documented
Long_t GetNRows() const
 Returns the number of the used rows for the wrapped table
Long_t GetRowSize() const
 Returns the size (in bytes) of one table row
Long_t GetTableSize() const
 Returns the number of the allocated rows
void Fit(const char* formula, const char* varexp, const char* selection = "", Option_t* option = "", Option_t* goption = "", Int_t nentries = 1000000000, Int_t firstentry = 0)
Fit a projected item(s) from a TTable*-
*-*              =======================================

  formula is a TF1 expression.

  See TTable::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.
  Example:
    table.Fit(pol4,"sqrt(x)>>hsqrt","y>0")
    will fit sqrt(x) and save the histogram as "hsqrt" in the current
    directory.

const Char_t * GetType() const
Returns the type of the wrapped C-structure kept as the TNamed title
Bool_t IsFolder() const
 return Folder flag to be used by TBrowse object
 The table is a folder if
  - it has sub-dataset
    or
  - GetNRows > 0
Int_t NaN()
 return the total number of the NaN for float/double cells of this table
 Thanks Victor Perevoztchikov

TTable * New(const Char_t* name, const Char_t* type, void* array, UInt_t size)
 This static method creates a new TTable object if provided
Bool_t OutOfBoundsError(const char* where, Int_t i) const
 Generate an out-of-bounds error. Always returns false.
Char_t * Print(Char_t* buf, Int_t n) const
 Create IDL table defintion (to be used for XDF I/O)
const Char_t * PrintHeader() const
 Print general table inforamtion
const Char_t * Print(Int_t row, Int_t rownumber = 10, const Char_t* colfirst = "", const Char_t* collast = "") const
const Char_t *TTable::Print(Int_t row, Int_t rownumber, const Char_t *colfirst, const Char_t *collast) const

  Print the contents of internal table per COLUMN.

  row       - the index of the first row to print (counting from ZERO)
  rownumber - the total number of rows to print out (=10 by default)

  (No use !) Char_t *colfirst, *collast - the names of the first/last
                                          to print out (not implemented yet)


 Check bounds and adjust it
void PrintContents(Option_t* opt = "") const
to be documented
void Project(const char* hname, const char* varexp, const char* selection = "", Option_t* option = "", Int_t nentries = 1000000000, Int_t firstentry = 0)
-*-*Make a projection of a TTable using selections
*-*              =============================================

   Depending on the value of varexp (described in Draw) a 1-D,2-D,etc
   projection of the TTable will be filled in histogram hname.
   Note that the dimension of hname must match with the dimension of varexp.

Int_t Purge(Option_t* opt = "")
 Shrink the table to free the unused but still allocated rows
void SavePrimitive(ostream& out, Option_t* option = "")
   Save a primitive as a C++ statement(s) on output stream "out".
void Set(Int_t n)
 Set array size of TTable object to n longs. If n<0 leave array unchanged.
void SetTablePointer(void* table)
to be documented
void SetType(const char*const type)
to be documented
Char_t * MakeExpression(const Char_t*[] expressions, Int_t nExpressions)
 Create CINT macro to evaluate the user-provided expresssion
 Expression may contains:
   -  the table columen names
   - 2 meta names: i$ - the current column index,
                   n$ - the total table size provided by TTable::GetNRows() method

 return the name of temporary file with the current expressions

void Reset(Int_t c = 0)
 Fill the entire table with byte "c" ;
     c=0 "be default"
void ResetMap(Bool_t wipe = kTRUE)
 Clean all filled columns with the pointers to TTableMap
 if any
  wipe = kTRUE - delete all object the Map's point to
         kFALSE - zero pointer, do not call "delete" though
void Set(Int_t n, Char_t* array)
 Set array size of TTable object to n longs and copy array.
 If n<0 leave array unchanged.
void StreamerTable(TBuffer& b, Version_t version = 3)
 Stream an object of class TTable.
void StreamerHeader(TBuffer& b, Version_t version = 3)
 Read "table parameters first"
Int_t SetfN(Long_t len)
to be documented
TTableDescriptor * GetRowDescriptors() const
to be documented
TTableDescriptor * GetDescriptorPointer() const
to be documented
void SetDescriptorPointer(TTableDescriptor* list)
to be documented
void Streamer(TBuffer& )
 Stream an array of the "plain" C-structures
void Update()
to be documented
void Update(TDataSet* set, UInt_t opt = 0)
 Kill the table current data
 and adopt those from set
const char * TableDictionary(const char* className, const char* structName, TTableDescriptor*& ColDescriptors)
 Query the TClass instance for the C-stucture dicitonary
 This method is to be used  with TableImp CPP macro (see $ROOTSYS/table/inc/Ttypes.h
Int_t GetColumnIndex(const Char_t* columnName) const
{return GetRowDescriptors()->ColumnByName(columnName);}
const Char_t * GetColumnName(Int_t columnIndex) const
{return GetRowDescriptors()->ColumnName(columnIndex); }
const UInt_t * GetIndexArray(Int_t columnIndex) const
{return GetRowDescriptors()->IndexArray(columnIndex); }
UInt_t GetNumberOfColumns() const
UInt_t GetOffset(Int_t columnIndex) const
{return GetRowDescriptors()->Offset(columnIndex); }
Int_t GetOffset(const Char_t* columnName = 0) const
{return GetRowDescriptors()->Offset(columnName); }
UInt_t GetColumnSize(Int_t columnIndex) const
{return GetRowDescriptors()->ColumnSize(columnIndex); }
Int_t GetColumnSize(const Char_t* columnName = 0) const
{return GetRowDescriptors()->ColumnSize(columnName); }
UInt_t GetTypeSize(Int_t columnIndex) const
{return GetRowDescriptors()->TypeSize(columnIndex); }
Int_t GetTypeSize(const Char_t* columnName = 0) const
{return GetRowDescriptors()->TypeSize(columnName); }
UInt_t GetDimensions(Int_t columnIndex) const
{return GetRowDescriptors()->Dimensions(columnIndex); }
Int_t GetDimensions(const Char_t* columnName = 0) const
{return GetRowDescriptors()->Dimensions(columnName); }
void AddAt(TDataSet* dataset, Int_t idx = 0)
{ TDataSet::AddAt(dataset,idx); }
Bool_t BoundsOk(const char* where, Int_t at) const
void * GetArray() const
{ return (void *)fTable;}
void Print(Option_t* opt = "") const
{ Print((Char_t *)0,Int_t(0)); }
void SetUsedRows(Int_t n)
{ fMaxIndex = n;}
void SetNRows(Int_t n)
void * operator[](Int_t i)
const void * operator[](Int_t i) const
void Draw(Option_t* opt)
{ Draw(opt, "", "", 1000000000, 0); }
const char * TableDictionary(const char* className, const char* structName, TTableDescriptor*& ColDescriptors)
Int_t GetSize() const
{ return fN; }
Long_t HasData() const
{ return 1; }
EColumnType GetColumnType(Int_t columnIndex) const
EColumnType GetColumnType(const Char_t* columnName = 0) const
EColumnType GetTypeId(const char* typeName)
piterator pbegin()
{ return piterator(this); }
piterator pend()
{ piterator pLast(this); pLast.MakeEnd(GetNRows()); return pLast; }