ROOT logo
// @(#)root/tree:$Id: TTreeIndex.cxx 21731 2008-01-16 15:16:53Z brun $
// Author: Rene Brun   05/07/2004

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// A Tree Index with majorname and minorname.                           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TTreeIndex.h"
#include "TTree.h"
#include "TMath.h"

ClassImp(TTreeIndex)

//______________________________________________________________________________
TTreeIndex::TTreeIndex(): TVirtualIndex()
{
   // Default constructor for TTreeIndex

   fTree               = 0;
   fN                  = 0;
   fIndexValues        = 0;
   fIndex              = 0;
   fMajorFormula       = 0;
   fMinorFormula       = 0;
   fMajorFormulaParent = 0;
   fMinorFormulaParent = 0;
}

//______________________________________________________________________________
TTreeIndex::TTreeIndex(const TTree *T, const char *majorname, const char *minorname)
           : TVirtualIndex()
{
   // Normal constructor for TTreeIndex
   //
   // Build an index table using the leaves of Tree T with  major & minor names
   // The index is built with the expressions given in "majorname" and "minorname".
   //
   // a Long64_t array fIndexValues is built with:
   //    major = the value of majorname converted to an integer
   //    minor = the value of minorname converted to an integer
   //    fIndexValues[i] = major<<31 + minor
   // This array is sorted. The sorted fIndex[i] contains the serial number
   // in the Tree corresponding to the pair "major,minor" in fIndexvalues[i].
   //
   //  Once the index is computed, one can retrieve one entry via
   //    T->GetEntryWithIndex(majornumber, minornumber)
   // Example:
   //  tree.BuildIndex("Run","Event"); //creates an index using leaves Run and Event
   //  tree.GetEntryWithIndex(1234,56789); //reads entry corresponding to
   //                                        Run=1234 and Event=56789
   //
   // Note that majorname and minorname may be expressions using original
   // Tree variables eg: "run-90000", "event +3*xx". However the result
   // must be integer.
   // In case an expression is specified, the equivalent expression must be computed
   // when calling GetEntryWithIndex.
   //
   // To build an index with only majorname, specify minorname="0" (default)
   //
   //    TreeIndex and Friend Trees
   //    ---------------------------
   // Assuming a parent Tree T and a friend Tree TF, the following cases are supported:
   // CASE 1: T->GetEntry(entry) is called
   //         In this case, the serial number entry is used to retrieve
   //         the data in both Trees.
   // CASE 2: T->GetEntry(entry) is called, TF has a TreeIndex
   //         the expressions given in major/minorname of TF are used
   //         to compute the value pair major,minor with the data in T.
   //         TF->GetEntryWithIndex(major,minor) is then called (tricky case!)
   // CASE 3: T->GetEntryWithIndex(major,minor) is called.
   //         It is assumed that both T and TF have a TreeIndex built using
   //         the same major and minor name.
   //
   //    Saving the TreeIndex
   //    --------------------
   // Once the index is built, it can be saved with the TTree object
   // with tree.Write(); (if the file has been open in "update" mode).
   //
   // The most convenient place to create the index is at the end of
   // the filling process just before saving the Tree header.
   // If a previous index was computed, it is redefined by this new call.
   //
   // Note that this function can also be applied to a TChain.
   //
   // The return value is the number of entries in the Index (< 0 indicates failure)
   //
   // It is possible to play with different TreeIndex in the same Tree.
   // see comments in TTree::SetTreeIndex.

   fTree               = (TTree*)T;
   fN                  = 0;
   fIndexValues        = 0;
   fIndex              = 0;
   fMajorFormula       = 0;
   fMinorFormula       = 0;
   fMajorFormulaParent = 0;
   fMinorFormulaParent = 0;
   fMajorName          = majorname;
   fMinorName          = minorname;
   if (!T) return;
   fN = T->GetEntries();
   if (fN <= 0) {
      MakeZombie();
      Error("TreeIndex","Cannot build a TreeIndex with a Tree having no entries");
      return;
   }

   GetMajorFormula();
   GetMinorFormula();
   if (!fMajorFormula || !fMinorFormula) {
      MakeZombie();
      Error("TreeIndex","Cannot build the index with major=%s, minor=%s",fMajorName.Data(), fMinorName.Data());
      return;
   }
   if ((fMajorFormula->GetNdim() != 1) || (fMinorFormula->GetNdim() != 1)) {
      MakeZombie();
      Error("TreeIndex","Cannot build the index with major=%s, minor=%s",fMajorName.Data(), fMinorName.Data());
      return;
   }
   // accessing array elements should be OK
   //if ((fMajorFormula->GetMultiplicity() != 0) || (fMinorFormula->GetMultiplicity() != 0)) {
   //   MakeZombie();
   //   Error("TreeIndex","Cannot build the index with major=%s, minor=%s that cannot be arrays",fMajorName.Data(), fMinorName.Data());
   //   return;
   //}

   Long64_t *w = new Long64_t[fN];
   Long64_t i;
   Long64_t oldEntry = fTree->GetReadEntry();
   Int_t current = -1;
   for (i=0;i<fN;i++) {
      Long64_t centry = fTree->LoadTree(i);
      if (centry < 0) break;
      if (fTree->GetTreeNumber() != current) {
         current = fTree->GetTreeNumber();
         fMajorFormula->UpdateFormulaLeaves();
         fMinorFormula->UpdateFormulaLeaves();
      }
      Double_t majord = fMajorFormula->EvalInstance();
      Double_t minord = fMinorFormula->EvalInstance();
      Long64_t majorv = (Long64_t)majord;
      Long64_t minorv = (Long64_t)minord;
      w[i]  = majorv<<31;
      w[i] += minorv;
   }
   fIndex = new Long64_t[fN];
   TMath::Sort(fN,w,fIndex,0);
   fIndexValues = new Long64_t[fN];
   for (i=0;i<fN;i++) {
      fIndexValues[i] = w[fIndex[i]];
   }

   delete [] w;
   fTree->LoadTree(oldEntry);
}

//______________________________________________________________________________
TTreeIndex::~TTreeIndex()
{
   // Destructor.

   if (fTree && fTree->GetTreeIndex() == this) fTree->SetTreeIndex(0);
   delete [] fIndexValues;      fIndexValues = 0;
   delete [] fIndex;            fIndex = 0;
   delete fMajorFormula;        fMajorFormula  = 0;
   delete fMinorFormula;        fMinorFormula  = 0;
   delete fMajorFormulaParent;  fMajorFormulaParent = 0;
   delete fMinorFormulaParent;  fMinorFormulaParent = 0;
}

//______________________________________________________________________________
void TTreeIndex::Append(const TVirtualIndex *add, Bool_t delaySort ) 
{
   // Append 'add' to this index.  Entry 0 in add will become entry n+1 in this.
   // If delaySort is true, do not sort the value, then you must call
   // Append(0,kFALSE);

   
   if (add && add->GetN()) {
      // Create new buffer (if needed)

      Long64_t oldn = fN;
      fN += add->GetN();
      

      Long64_t *oldIndex = fIndex;
      Long64_t *oldValues = fIndexValues;

      fIndex = new Long64_t[fN];
      fIndexValues = new Long64_t[fN];

      // Copy data

      Long_t size = sizeof(Long64_t) * oldn;
      Long_t add_size = sizeof(Long64_t) * add->GetN();
      
      memcpy(fIndex,oldIndex, size);
      memcpy(fIndexValues,oldValues, size);

      Long64_t *addIndex = dynamic_cast<const TTreeIndex*>(add)->GetIndex();
      Long64_t *addValues = dynamic_cast<const TTreeIndex*>(add)->GetIndexValues();

      memcpy(fIndex + oldn, addIndex, add_size);
      memcpy(fIndexValues + oldn, addValues, add_size);
      for(Int_t i = 0; i < add->GetN(); i++) {
         fIndex[oldn + i] += oldn;
      }

      delete [] oldIndex;
      delete [] oldValues;
   }

   // Sort.
   if (!delaySort) {
      Long64_t *w = fIndexValues;
      Long64_t *ind = fIndex;
      Long64_t *conv = new Long64_t[fN];

      TMath::Sort(fN,w,conv,0);

      fIndex = new Long64_t[fN];
      fIndexValues = new Long64_t[fN];

      for (Int_t i=0;i<fN;i++) {
         fIndex[i] = ind[conv[i]];
         fIndexValues[i] = w[conv[i]];
      }
      delete [] w;
      delete [] ind;
      delete [] conv;
   }

}

//______________________________________________________________________________
Int_t TTreeIndex::GetEntryNumberFriend(const TTree *T)
{
// returns the entry number in this friend Tree corresponding to entry in
// the master Tree T.
// In case this friend Tree and T do not share an index with the same
// major and minor name, the entry serial number in the friend tree
// and in the master Tree are assumed to be the same

   if (!T) return -3;
   GetMajorFormulaParent(T);
   GetMinorFormulaParent(T);
   if (!fMajorFormulaParent || !fMinorFormulaParent) return -1;
   if (!fMajorFormulaParent->GetNdim() || !fMinorFormulaParent->GetNdim()) {
      // The Tree Index in the friend has a pair majorname,minorname
      // not available in the parent Tree T.
      // if the friend Tree has less entries than the parent, this is an error
      Int_t pentry = T->GetReadEntry();
      if (pentry >= (Int_t)fTree->GetEntries()) return -2;
      // otherwise we ignore the Tree Index and return the entry number
      // in the parent Tree.
      return pentry;
   }

   // majorname, minorname exist in the parent Tree
   // we find the current values pair majorv,minorv in the parent Tree
   Double_t majord = fMajorFormulaParent->EvalInstance();
   Double_t minord = fMinorFormulaParent->EvalInstance();
   Long64_t majorv = (Long64_t)majord;
   Long64_t minorv = (Long64_t)minord;
   // we check if this pair exist in the index.
   // if yes, we return the corresponding entry number
   // if not the function returns -1
   return fTree->GetEntryNumberWithIndex(majorv,minorv);
}

//______________________________________________________________________________
Long64_t TTreeIndex::GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const
{
// Return entry number corresponding to major and minor number
// Note that this function returns only the entry number, not the data
// To read the data corresponding to an entry number, use TTree::GetEntryWithIndex
// the BuildIndex function has created a table of Double_t* of sorted values
// corresponding to val = major<<31 + minor;
// The function performs binary search in this sorted table.
// If it finds a pair that maches val, it returns directly the
// index in the table.
// If an entry corresponding to major and minor is not found, the function
// returns the index of the major,minor pair immediatly lower than the
// requested value, ie it will return -1 if the pair is lower than
// the first entry in the index.
//
// See also GetEntryNumberWithIndex

   if (fN == 0) return -1;
   Long64_t value = Long64_t(major)<<31;
   value += minor;
   Int_t i = TMath::BinarySearch(fN, fIndexValues, value);
   if (i < 0) return -1;
   return fIndex[i];
}


//______________________________________________________________________________
Long64_t TTreeIndex::GetEntryNumberWithIndex(Int_t major, Int_t minor) const
{
// Return entry number corresponding to major and minor number
// Note that this function returns only the entry number, not the data
// To read the data corresponding to an entry number, use TTree::GetEntryWithIndex
// the BuildIndex function has created a table of Double_t* of sorted values
// corresponding to val = major<<31 + minor;
// The function performs binary search in this sorted table.
// If it finds a pair that maches val, it returns directly the
// index in the table, otherwise it returns -1.
//
// See also GetEntryNumberWithBestIndex

   if (fN == 0) return -1;
   Long64_t value = Long64_t(major)<<31;
   value += minor;
   Int_t i = TMath::BinarySearch(fN, fIndexValues, value);
   if (i < 0) return -1;
   if (fIndexValues[i] != value) return -1;
   return fIndex[i];
}

//______________________________________________________________________________
TTreeFormula *TTreeIndex::GetMajorFormula()
{
   // return a pointer to the TreeFormula corresponding to the majorname

   if (!fMajorFormula) {
      fMajorFormula = new TTreeFormula("Major",fMajorName.Data(),fTree);
      fMajorFormula->SetQuickLoad(kTRUE);
   }
   return fMajorFormula;
}

//______________________________________________________________________________
TTreeFormula *TTreeIndex::GetMinorFormula()
{
   // return a pointer to the TreeFormula corresponding to the minorname

   if (!fMinorFormula) {
      fMinorFormula = new TTreeFormula("Minor",fMinorName.Data(),fTree);
      fMinorFormula->SetQuickLoad(kTRUE);
   }
   return fMinorFormula;
}

//______________________________________________________________________________
TTreeFormula *TTreeIndex::GetMajorFormulaParent(const TTree *T)
{
   // return a pointer to the TreeFormula corresponding to the majorname in parent tree T

   if (!fMajorFormulaParent) {
      fMajorFormulaParent = new TTreeFormula("MajorP",fMajorName.Data(),(TTree*)T);
      fMajorFormulaParent->SetQuickLoad(kTRUE);
   }
   if (fMajorFormulaParent->GetTree() != T) {
      fMajorFormulaParent->SetTree((TTree*)T);
      fMajorFormulaParent->UpdateFormulaLeaves();
   }
   return fMajorFormulaParent;
}

//______________________________________________________________________________
TTreeFormula *TTreeIndex::GetMinorFormulaParent(const TTree *T)
{
   // return a pointer to the TreeFormula corresponding to the minorname in parent tree T

   if (!fMinorFormulaParent) {
      fMinorFormulaParent = new TTreeFormula("MinorP",fMinorName.Data(),(TTree*)T);
      fMinorFormulaParent->SetQuickLoad(kTRUE);
   }
   if (fMinorFormulaParent->GetTree() != T) {
      fMinorFormulaParent->SetTree((TTree*)T);
      fMinorFormulaParent->UpdateFormulaLeaves();
   }

   return fMinorFormulaParent;
}

//______________________________________________________________________________
void TTreeIndex::Print(Option_t * option) const
{
   // print the table with : serial number, majorname, minorname
   // if option = "10" print only the first 10 entries
   // if option = "100" print only the first 100 entries
   // if option = "1000" print only the first 1000 entries

   TString opt = option;
   Bool_t printEntry = kFALSE;
   Long64_t n = fN;
   if (opt.Contains("10"))   n = 10;
   if (opt.Contains("100"))  n = 100;
   if (opt.Contains("1000")) n = 1000;
   if (opt.Contains("all")) {
      printEntry = kTRUE;
   }

   if (printEntry) {

      Printf("\n*****************************************************************");
      Printf("*    Index of Tree: %s/%s",fTree->GetName(),fTree->GetTitle());
      Printf("*****************************************************************");
      Printf("%8s : %16s : %16s : %16s","serial",fMajorName.Data(),fMinorName.Data(),"entry number");
      Printf("*****************************************************************");
      for (Long64_t i=0;i<n;i++) {
         Long64_t minor = fIndexValues[i] & 0xffff;
         Long64_t major = fIndexValues[i]>>31;
         Printf("%8lld :         %8lld :         %8lld :         %8lld",i,major,minor,fIndex[i]);
      }

   } else {

      Printf("\n**********************************************");
      Printf("*    Index of Tree: %s/%s",fTree->GetName(),fTree->GetTitle());
      Printf("**********************************************");
      Printf("%8s : %16s : %16s","serial",fMajorName.Data(),fMinorName.Data());
      Printf("**********************************************");
      for (Long64_t i=0;i<n;i++) {
         Long64_t minor = fIndexValues[i] & 0xffff;
         Long64_t major = fIndexValues[i]>>31;
         Printf("%8lld :         %8lld :         %8lld",i,major,minor);
      }
   }
}

//______________________________________________________________________________
void TTreeIndex::Streamer(TBuffer &R__b)
{
   // Stream an object of class TTreeIndex.
   // Note that this Streamer should be changed to an automatic Streamer
   // once TStreamerInfo supports an index of type Long64_t

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TVirtualIndex::Streamer(R__b);
      fMajorName.Streamer(R__b);
      fMinorName.Streamer(R__b);
      R__b >> fN;
      fIndexValues = new Long64_t[fN];
      R__b.ReadFastArray(fIndexValues,fN);
      fIndex      = new Long64_t[fN];
      R__b.ReadFastArray(fIndex,fN);
      R__b.CheckByteCount(R__s, R__c, TTreeIndex::IsA());
   } else {
      R__c = R__b.WriteVersion(TTreeIndex::IsA(), kTRUE);
      TVirtualIndex::Streamer(R__b);
      fMajorName.Streamer(R__b);
      fMinorName.Streamer(R__b);
      R__b << fN;
      R__b.WriteFastArray(fIndexValues, fN);
      R__b.WriteFastArray(fIndex, fN);
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TTreeIndex::UpdateFormulaLeaves(const TTree *parent)
{
   // Called by TChain::LoadTree when the parent chain changes it's tree.

   if (fMajorFormula)       { fMajorFormula->UpdateFormulaLeaves();}
   if (fMinorFormula)       { fMinorFormula->UpdateFormulaLeaves();}
   if (fMajorFormulaParent) { 
      if (parent) fMajorFormulaParent->SetTree((TTree*)parent);
      fMajorFormulaParent->UpdateFormulaLeaves();
   }
   if (fMinorFormulaParent) { 
      if (parent) fMinorFormulaParent->SetTree((TTree*)parent);
      fMinorFormulaParent->UpdateFormulaLeaves();
   }
}
//______________________________________________________________________________
void TTreeIndex::SetTree(const TTree *T)
{
   // this function is called by TChain::LoadTree and TTreePlayer::UpdateFormulaLeaves
   // when a new Tree is loaded.
   // Because Trees in a TChain may have a different list of leaves, one
   // must update the leaves numbers in the TTreeFormula used by the TreeIndex.

   fTree = (TTree*)T;
}

 TTreeIndex.cxx:1
 TTreeIndex.cxx:2
 TTreeIndex.cxx:3
 TTreeIndex.cxx:4
 TTreeIndex.cxx:5
 TTreeIndex.cxx:6
 TTreeIndex.cxx:7
 TTreeIndex.cxx:8
 TTreeIndex.cxx:9
 TTreeIndex.cxx:10
 TTreeIndex.cxx:11
 TTreeIndex.cxx:12
 TTreeIndex.cxx:13
 TTreeIndex.cxx:14
 TTreeIndex.cxx:15
 TTreeIndex.cxx:16
 TTreeIndex.cxx:17
 TTreeIndex.cxx:18
 TTreeIndex.cxx:19
 TTreeIndex.cxx:20
 TTreeIndex.cxx:21
 TTreeIndex.cxx:22
 TTreeIndex.cxx:23
 TTreeIndex.cxx:24
 TTreeIndex.cxx:25
 TTreeIndex.cxx:26
 TTreeIndex.cxx:27
 TTreeIndex.cxx:28
 TTreeIndex.cxx:29
 TTreeIndex.cxx:30
 TTreeIndex.cxx:31
 TTreeIndex.cxx:32
 TTreeIndex.cxx:33
 TTreeIndex.cxx:34
 TTreeIndex.cxx:35
 TTreeIndex.cxx:36
 TTreeIndex.cxx:37
 TTreeIndex.cxx:38
 TTreeIndex.cxx:39
 TTreeIndex.cxx:40
 TTreeIndex.cxx:41
 TTreeIndex.cxx:42
 TTreeIndex.cxx:43
 TTreeIndex.cxx:44
 TTreeIndex.cxx:45
 TTreeIndex.cxx:46
 TTreeIndex.cxx:47
 TTreeIndex.cxx:48
 TTreeIndex.cxx:49
 TTreeIndex.cxx:50
 TTreeIndex.cxx:51
 TTreeIndex.cxx:52
 TTreeIndex.cxx:53
 TTreeIndex.cxx:54
 TTreeIndex.cxx:55
 TTreeIndex.cxx:56
 TTreeIndex.cxx:57
 TTreeIndex.cxx:58
 TTreeIndex.cxx:59
 TTreeIndex.cxx:60
 TTreeIndex.cxx:61
 TTreeIndex.cxx:62
 TTreeIndex.cxx:63
 TTreeIndex.cxx:64
 TTreeIndex.cxx:65
 TTreeIndex.cxx:66
 TTreeIndex.cxx:67
 TTreeIndex.cxx:68
 TTreeIndex.cxx:69
 TTreeIndex.cxx:70
 TTreeIndex.cxx:71
 TTreeIndex.cxx:72
 TTreeIndex.cxx:73
 TTreeIndex.cxx:74
 TTreeIndex.cxx:75
 TTreeIndex.cxx:76
 TTreeIndex.cxx:77
 TTreeIndex.cxx:78
 TTreeIndex.cxx:79
 TTreeIndex.cxx:80
 TTreeIndex.cxx:81
 TTreeIndex.cxx:82
 TTreeIndex.cxx:83
 TTreeIndex.cxx:84
 TTreeIndex.cxx:85
 TTreeIndex.cxx:86
 TTreeIndex.cxx:87
 TTreeIndex.cxx:88
 TTreeIndex.cxx:89
 TTreeIndex.cxx:90
 TTreeIndex.cxx:91
 TTreeIndex.cxx:92
 TTreeIndex.cxx:93
 TTreeIndex.cxx:94
 TTreeIndex.cxx:95
 TTreeIndex.cxx:96
 TTreeIndex.cxx:97
 TTreeIndex.cxx:98
 TTreeIndex.cxx:99
 TTreeIndex.cxx:100
 TTreeIndex.cxx:101
 TTreeIndex.cxx:102
 TTreeIndex.cxx:103
 TTreeIndex.cxx:104
 TTreeIndex.cxx:105
 TTreeIndex.cxx:106
 TTreeIndex.cxx:107
 TTreeIndex.cxx:108
 TTreeIndex.cxx:109
 TTreeIndex.cxx:110
 TTreeIndex.cxx:111
 TTreeIndex.cxx:112
 TTreeIndex.cxx:113
 TTreeIndex.cxx:114
 TTreeIndex.cxx:115
 TTreeIndex.cxx:116
 TTreeIndex.cxx:117
 TTreeIndex.cxx:118
 TTreeIndex.cxx:119
 TTreeIndex.cxx:120
 TTreeIndex.cxx:121
 TTreeIndex.cxx:122
 TTreeIndex.cxx:123
 TTreeIndex.cxx:124
 TTreeIndex.cxx:125
 TTreeIndex.cxx:126
 TTreeIndex.cxx:127
 TTreeIndex.cxx:128
 TTreeIndex.cxx:129
 TTreeIndex.cxx:130
 TTreeIndex.cxx:131
 TTreeIndex.cxx:132
 TTreeIndex.cxx:133
 TTreeIndex.cxx:134
 TTreeIndex.cxx:135
 TTreeIndex.cxx:136
 TTreeIndex.cxx:137
 TTreeIndex.cxx:138
 TTreeIndex.cxx:139
 TTreeIndex.cxx:140
 TTreeIndex.cxx:141
 TTreeIndex.cxx:142
 TTreeIndex.cxx:143
 TTreeIndex.cxx:144
 TTreeIndex.cxx:145
 TTreeIndex.cxx:146
 TTreeIndex.cxx:147
 TTreeIndex.cxx:148
 TTreeIndex.cxx:149
 TTreeIndex.cxx:150
 TTreeIndex.cxx:151
 TTreeIndex.cxx:152
 TTreeIndex.cxx:153
 TTreeIndex.cxx:154
 TTreeIndex.cxx:155
 TTreeIndex.cxx:156
 TTreeIndex.cxx:157
 TTreeIndex.cxx:158
 TTreeIndex.cxx:159
 TTreeIndex.cxx:160
 TTreeIndex.cxx:161
 TTreeIndex.cxx:162
 TTreeIndex.cxx:163
 TTreeIndex.cxx:164
 TTreeIndex.cxx:165
 TTreeIndex.cxx:166
 TTreeIndex.cxx:167
 TTreeIndex.cxx:168
 TTreeIndex.cxx:169
 TTreeIndex.cxx:170
 TTreeIndex.cxx:171
 TTreeIndex.cxx:172
 TTreeIndex.cxx:173
 TTreeIndex.cxx:174
 TTreeIndex.cxx:175
 TTreeIndex.cxx:176
 TTreeIndex.cxx:177
 TTreeIndex.cxx:178
 TTreeIndex.cxx:179
 TTreeIndex.cxx:180
 TTreeIndex.cxx:181
 TTreeIndex.cxx:182
 TTreeIndex.cxx:183
 TTreeIndex.cxx:184
 TTreeIndex.cxx:185
 TTreeIndex.cxx:186
 TTreeIndex.cxx:187
 TTreeIndex.cxx:188
 TTreeIndex.cxx:189
 TTreeIndex.cxx:190
 TTreeIndex.cxx:191
 TTreeIndex.cxx:192
 TTreeIndex.cxx:193
 TTreeIndex.cxx:194
 TTreeIndex.cxx:195
 TTreeIndex.cxx:196
 TTreeIndex.cxx:197
 TTreeIndex.cxx:198
 TTreeIndex.cxx:199
 TTreeIndex.cxx:200
 TTreeIndex.cxx:201
 TTreeIndex.cxx:202
 TTreeIndex.cxx:203
 TTreeIndex.cxx:204
 TTreeIndex.cxx:205
 TTreeIndex.cxx:206
 TTreeIndex.cxx:207
 TTreeIndex.cxx:208
 TTreeIndex.cxx:209
 TTreeIndex.cxx:210
 TTreeIndex.cxx:211
 TTreeIndex.cxx:212
 TTreeIndex.cxx:213
 TTreeIndex.cxx:214
 TTreeIndex.cxx:215
 TTreeIndex.cxx:216
 TTreeIndex.cxx:217
 TTreeIndex.cxx:218
 TTreeIndex.cxx:219
 TTreeIndex.cxx:220
 TTreeIndex.cxx:221
 TTreeIndex.cxx:222
 TTreeIndex.cxx:223
 TTreeIndex.cxx:224
 TTreeIndex.cxx:225
 TTreeIndex.cxx:226
 TTreeIndex.cxx:227
 TTreeIndex.cxx:228
 TTreeIndex.cxx:229
 TTreeIndex.cxx:230
 TTreeIndex.cxx:231
 TTreeIndex.cxx:232
 TTreeIndex.cxx:233
 TTreeIndex.cxx:234
 TTreeIndex.cxx:235
 TTreeIndex.cxx:236
 TTreeIndex.cxx:237
 TTreeIndex.cxx:238
 TTreeIndex.cxx:239
 TTreeIndex.cxx:240
 TTreeIndex.cxx:241
 TTreeIndex.cxx:242
 TTreeIndex.cxx:243
 TTreeIndex.cxx:244
 TTreeIndex.cxx:245
 TTreeIndex.cxx:246
 TTreeIndex.cxx:247
 TTreeIndex.cxx:248
 TTreeIndex.cxx:249
 TTreeIndex.cxx:250
 TTreeIndex.cxx:251
 TTreeIndex.cxx:252
 TTreeIndex.cxx:253
 TTreeIndex.cxx:254
 TTreeIndex.cxx:255
 TTreeIndex.cxx:256
 TTreeIndex.cxx:257
 TTreeIndex.cxx:258
 TTreeIndex.cxx:259
 TTreeIndex.cxx:260
 TTreeIndex.cxx:261
 TTreeIndex.cxx:262
 TTreeIndex.cxx:263
 TTreeIndex.cxx:264
 TTreeIndex.cxx:265
 TTreeIndex.cxx:266
 TTreeIndex.cxx:267
 TTreeIndex.cxx:268
 TTreeIndex.cxx:269
 TTreeIndex.cxx:270
 TTreeIndex.cxx:271
 TTreeIndex.cxx:272
 TTreeIndex.cxx:273
 TTreeIndex.cxx:274
 TTreeIndex.cxx:275
 TTreeIndex.cxx:276
 TTreeIndex.cxx:277
 TTreeIndex.cxx:278
 TTreeIndex.cxx:279
 TTreeIndex.cxx:280
 TTreeIndex.cxx:281
 TTreeIndex.cxx:282
 TTreeIndex.cxx:283
 TTreeIndex.cxx:284
 TTreeIndex.cxx:285
 TTreeIndex.cxx:286
 TTreeIndex.cxx:287
 TTreeIndex.cxx:288
 TTreeIndex.cxx:289
 TTreeIndex.cxx:290
 TTreeIndex.cxx:291
 TTreeIndex.cxx:292
 TTreeIndex.cxx:293
 TTreeIndex.cxx:294
 TTreeIndex.cxx:295
 TTreeIndex.cxx:296
 TTreeIndex.cxx:297
 TTreeIndex.cxx:298
 TTreeIndex.cxx:299
 TTreeIndex.cxx:300
 TTreeIndex.cxx:301
 TTreeIndex.cxx:302
 TTreeIndex.cxx:303
 TTreeIndex.cxx:304
 TTreeIndex.cxx:305
 TTreeIndex.cxx:306
 TTreeIndex.cxx:307
 TTreeIndex.cxx:308
 TTreeIndex.cxx:309
 TTreeIndex.cxx:310
 TTreeIndex.cxx:311
 TTreeIndex.cxx:312
 TTreeIndex.cxx:313
 TTreeIndex.cxx:314
 TTreeIndex.cxx:315
 TTreeIndex.cxx:316
 TTreeIndex.cxx:317
 TTreeIndex.cxx:318
 TTreeIndex.cxx:319
 TTreeIndex.cxx:320
 TTreeIndex.cxx:321
 TTreeIndex.cxx:322
 TTreeIndex.cxx:323
 TTreeIndex.cxx:324
 TTreeIndex.cxx:325
 TTreeIndex.cxx:326
 TTreeIndex.cxx:327
 TTreeIndex.cxx:328
 TTreeIndex.cxx:329
 TTreeIndex.cxx:330
 TTreeIndex.cxx:331
 TTreeIndex.cxx:332
 TTreeIndex.cxx:333
 TTreeIndex.cxx:334
 TTreeIndex.cxx:335
 TTreeIndex.cxx:336
 TTreeIndex.cxx:337
 TTreeIndex.cxx:338
 TTreeIndex.cxx:339
 TTreeIndex.cxx:340
 TTreeIndex.cxx:341
 TTreeIndex.cxx:342
 TTreeIndex.cxx:343
 TTreeIndex.cxx:344
 TTreeIndex.cxx:345
 TTreeIndex.cxx:346
 TTreeIndex.cxx:347
 TTreeIndex.cxx:348
 TTreeIndex.cxx:349
 TTreeIndex.cxx:350
 TTreeIndex.cxx:351
 TTreeIndex.cxx:352
 TTreeIndex.cxx:353
 TTreeIndex.cxx:354
 TTreeIndex.cxx:355
 TTreeIndex.cxx:356
 TTreeIndex.cxx:357
 TTreeIndex.cxx:358
 TTreeIndex.cxx:359
 TTreeIndex.cxx:360
 TTreeIndex.cxx:361
 TTreeIndex.cxx:362
 TTreeIndex.cxx:363
 TTreeIndex.cxx:364
 TTreeIndex.cxx:365
 TTreeIndex.cxx:366
 TTreeIndex.cxx:367
 TTreeIndex.cxx:368
 TTreeIndex.cxx:369
 TTreeIndex.cxx:370
 TTreeIndex.cxx:371
 TTreeIndex.cxx:372
 TTreeIndex.cxx:373
 TTreeIndex.cxx:374
 TTreeIndex.cxx:375
 TTreeIndex.cxx:376
 TTreeIndex.cxx:377
 TTreeIndex.cxx:378
 TTreeIndex.cxx:379
 TTreeIndex.cxx:380
 TTreeIndex.cxx:381
 TTreeIndex.cxx:382
 TTreeIndex.cxx:383
 TTreeIndex.cxx:384
 TTreeIndex.cxx:385
 TTreeIndex.cxx:386
 TTreeIndex.cxx:387
 TTreeIndex.cxx:388
 TTreeIndex.cxx:389
 TTreeIndex.cxx:390
 TTreeIndex.cxx:391
 TTreeIndex.cxx:392
 TTreeIndex.cxx:393
 TTreeIndex.cxx:394
 TTreeIndex.cxx:395
 TTreeIndex.cxx:396
 TTreeIndex.cxx:397
 TTreeIndex.cxx:398
 TTreeIndex.cxx:399
 TTreeIndex.cxx:400
 TTreeIndex.cxx:401
 TTreeIndex.cxx:402
 TTreeIndex.cxx:403
 TTreeIndex.cxx:404
 TTreeIndex.cxx:405
 TTreeIndex.cxx:406
 TTreeIndex.cxx:407
 TTreeIndex.cxx:408
 TTreeIndex.cxx:409
 TTreeIndex.cxx:410
 TTreeIndex.cxx:411
 TTreeIndex.cxx:412
 TTreeIndex.cxx:413
 TTreeIndex.cxx:414
 TTreeIndex.cxx:415
 TTreeIndex.cxx:416
 TTreeIndex.cxx:417
 TTreeIndex.cxx:418
 TTreeIndex.cxx:419
 TTreeIndex.cxx:420
 TTreeIndex.cxx:421
 TTreeIndex.cxx:422
 TTreeIndex.cxx:423
 TTreeIndex.cxx:424
 TTreeIndex.cxx:425
 TTreeIndex.cxx:426
 TTreeIndex.cxx:427
 TTreeIndex.cxx:428
 TTreeIndex.cxx:429
 TTreeIndex.cxx:430
 TTreeIndex.cxx:431
 TTreeIndex.cxx:432
 TTreeIndex.cxx:433
 TTreeIndex.cxx:434
 TTreeIndex.cxx:435
 TTreeIndex.cxx:436
 TTreeIndex.cxx:437
 TTreeIndex.cxx:438
 TTreeIndex.cxx:439
 TTreeIndex.cxx:440
 TTreeIndex.cxx:441
 TTreeIndex.cxx:442
 TTreeIndex.cxx:443
 TTreeIndex.cxx:444
 TTreeIndex.cxx:445
 TTreeIndex.cxx:446
 TTreeIndex.cxx:447
 TTreeIndex.cxx:448
 TTreeIndex.cxx:449
 TTreeIndex.cxx:450
 TTreeIndex.cxx:451
 TTreeIndex.cxx:452
 TTreeIndex.cxx:453
 TTreeIndex.cxx:454
 TTreeIndex.cxx:455
 TTreeIndex.cxx:456
 TTreeIndex.cxx:457
 TTreeIndex.cxx:458
 TTreeIndex.cxx:459
 TTreeIndex.cxx:460
 TTreeIndex.cxx:461
 TTreeIndex.cxx:462
 TTreeIndex.cxx:463
 TTreeIndex.cxx:464
 TTreeIndex.cxx:465
 TTreeIndex.cxx:466
 TTreeIndex.cxx:467
 TTreeIndex.cxx:468
 TTreeIndex.cxx:469
 TTreeIndex.cxx:470
 TTreeIndex.cxx:471
 TTreeIndex.cxx:472
 TTreeIndex.cxx:473
 TTreeIndex.cxx:474
 TTreeIndex.cxx:475
 TTreeIndex.cxx:476
 TTreeIndex.cxx:477
 TTreeIndex.cxx:478
 TTreeIndex.cxx:479
 TTreeIndex.cxx:480
 TTreeIndex.cxx:481
 TTreeIndex.cxx:482
 TTreeIndex.cxx:483
 TTreeIndex.cxx:484
 TTreeIndex.cxx:485
 TTreeIndex.cxx:486
 TTreeIndex.cxx:487
 TTreeIndex.cxx:488
 TTreeIndex.cxx:489
 TTreeIndex.cxx:490
 TTreeIndex.cxx:491