TPC/macros/MakeTreeStat.C

   1 /****************************************************************************
   2   Macro to get the size of the Tree
   3   As a improvment to  tree->Print() function, this algorithm
   4   gives the size of all of the branchces and in addition print them
   5   sorted according total tree size (MEMORY USAGE if one event in tree)
   6   or zip size (THE storage size on disk
   7
   8   Printed statistic:
   9   1. Order
  10   2. TotSize (in memory) + fraction of total size
  11   3. ZipSize (in memory) + fraction of zip size
  12   4. Compression ratio
  13
  14   Usage:
  15   //  1. Enable macro
  16   .L $ALICE_ROOT/TPC/macros/MakeTreeStat.C+
  17   // 2. Open the tree (eg.)
  18   TFile f("AliESDs.root");
  19   TTree * tree = (TTree*)f.Get("esdTree");
  20   // 3. Print statistic (sorting according secon argument - either zip Bytes (kTRUE or TotSize (kFALSE)
  21   MakeStat(tree, kTRUE);
  22
  23   Origin: M.Ivanov, GSI, m.ivanov@gsi.de
  24
  25 ****************************************************************************/
  26
  27
  28
  29
  30
  31
  32 #include "TFile.h"
  33 #include "TTree.h"
  34 #include "TBranch.h"
  35 #include "TMath.h"
  36 #include "TArrayF.h"
  37 #include "TObjArray.h"
  38 #include "TObjString.h"
  39
  40
  41
  42
  43 TTree     *fTree;   // tree of interest
  44 TObjArray aReport;  // array with branch statistic
  45 TArrayF   totSize;  // total size for branch
  46 TArrayF   zipSize;  // zip Size for branch
  47 TArrayF   zipRatio; // zip Ratio for branch
  48
  49 void MakeStat(TTree *tree, Bool_t zipSort);
  50
  51
  52
  53 void PrintSorted(Bool_t zipSort){
  54   //
  55   //print statistic
  56   //
  57   Int_t entries   = aReport.GetEntries();
  58   Int_t* indexes  = new Int_t[entries];
  59   if (zipSort) TMath::Sort(entries,zipSize.GetArray(),indexes,kTRUE);
  60   else{
  61     TMath::Sort(entries,totSize.GetArray(),indexes,kTRUE);
  62   }
  63   Float_t zipBytes = zipSize[indexes[0]];
  64   Float_t totBytes =  totSize[indexes[0]];
  65   Float_t ratioT = 100.*zipBytes/totBytes;
  66   for (Int_t i=entries-1; i>=0; i--){
  67     Int_t ib = indexes[i];
  68     Float_t ratio0= 100.*totSize[ib]/totBytes;
  69     Float_t ratio1= 100.*zipSize[ib]/zipBytes;
  70     if (i==0) {
  71       printf("\n------------------------------------------------------------\n");
  72       printf("%d  \t\t%5.f(%.2f\%)  \t\t%5.f(%.2f\%)  \t%.2f  \t%s\n",i,
  73              totSize[ib],100., zipSize[ib],100., 100.*zipRatio[ib], aReport.At(ib)->GetName());
  74     }else{
  75     printf("%d  \t\t%5.f(%.2f\%)  \t\t%5.f(%.2f\%)  \t%.2f  \t%s\n",i,
  76            totSize[ib],ratio0, zipSize[ib],ratio1, 100.*zipRatio[ib], aReport.At(ib)->GetName());
  77     }
  78   }
  79
  80
  81 }
  82
  83
  84 void AddToReport(const char *prefix,const char * name, Float_t size[2], Float_t ratio){
  85   //
  86   // add branch info to array
  87   //
  88   char fullname[10000];
  89   sprintf(fullname,"%s.%s",prefix,name);
  90   aReport.AddLast(new TObjString(fullname));
  91   Int_t entry = aReport.GetEntries();
  92   if (totSize.GetSize()<entry){
  93     totSize.Set(entry*2);
  94     zipSize.Set(entry*2);
  95     zipRatio.Set(entry*2);
  96   }
  97   totSize[entry-1]=Float_t(size[0]);
  98   zipSize[entry-1]=Float_t(size[1]);
  99   zipRatio[entry-1]=Float_t(ratio);
 100 }
 101
 102
 103
 104
 105
 106 void MakeStat(const char *prefix, TBranch * branch, Float_t* size, Float_t mratio);
 107
 108
 109
 110 void MakeStat(TTree *tree, Bool_t zipSort){
 111   //
 112   // make recursve loop over tree branches
 113   //
 114   fTree= tree;
 115   aReport.Clear();
 116   TObjArray * array = tree->GetListOfBranches();
 117   Float_t size[2]={0,0};
 118   char * prefix ="";
 119   Float_t mratio=tree->GetZipBytes()/float(tree->GetTotBytes());
 120   for (Int_t i=0; i<array->GetEntries(); i++){
 121     MakeStat(prefix,(TBranch*)array->At(i),size, mratio);
 122   }
 123   Float_t ratio= (size[0]>0) ? size[1]/Float_t(size[0]): 0;
 124   //  printf("Sum :\t%f\t%f\t%f\t%s.%s\t\n", float(size[0]), float(size[1]),ratio, prefix,tree->GetName());
 125
 126   AddToReport(prefix, tree->GetName(),size,ratio);
 127   PrintSorted(zipSort);
 128 }
 129
 130
 131 void MakeStat(const char *prefix, TBranch * branch, Float_t *size, Float_t mratio){
 132   //
 133   // Recursive function to get size of the branches
 134   // and ratios
 135   //
 136   TObjArray * array = branch->GetListOfBranches();
 137   Float_t bsizeSum[2]={0,0};
 138
 139   if (!array || array->GetEntries()==0){
 140     Float_t bsize[2] = {0,0};
 141     bsize[0]=branch->GetTotalSize();
 142     bsize[1]=branch->GetZipBytes();
 143     if (bsize[1]>0){
 144       Float_t ratio= (bsize[0]>0) ? bsize[1]/Float_t(bsize[0]): 0;
 145       //      printf("Term:\t%f\t%f\t%f\t%s.%s\t\n",float(bsize[0]), float(bsize[1]),ratio, prefix,branch->GetName());
 146       AddToReport(prefix, branch->GetName(),bsize,ratio);
 147       //branch->Print();
 148       size[0]+=bsize[0];
 149       size[1]+=bsize[1];
 150     }else{
 151       Float_t ratio= mratio;
 152       //printf("Ter?:\t%f\t%f\t%f\t%s.%s\t\n",float(bsize[0]), float(-1),ratio, prefix,branch->GetName());
 153       AddToReport(prefix, branch->GetName(),bsize,ratio);
 154       //branch->Print();
 155       size[0]+=bsize[0];
 156       size[1]+=TMath::Nint(bsize[0]*mratio);
 157     }
 158
 159     return;
 160   }
 161   for (Int_t i=0; i<array->GetEntries(); i++){
 162     Float_t bsize[2] = {0,0};
 163     TString str=prefix;
 164     str+= branch->GetName();
 165     MakeStat(str.Data(),(TBranch*)array->At(i), bsize, mratio);
 166     bsizeSum[0]+=bsize[0];
 167     bsizeSum[1]+=bsize[1];
 168     size[0]+=bsize[0];
 169     size[1]+=bsize[1];
 170   }
 171   Float_t ratio= (size[0]>0) ? size[1]/Float_t(size[0]): 0;
 172   //printf("Sum :\t%f\t%f\t%f\t%s.%s\t\n", float(bsizeSum[0]), float(bsizeSum[1]),ratio, prefix,branch->GetName());
 173   AddToReport(prefix,branch->GetName(),bsizeSum,ratio);
 174 }