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 = fTree->GetZipBytes();
  64   Float_t totBytes = fTree->GetTotBytes();
  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 * name, Float_t size[2], Float_t ratio){
  85   //
  86   // add branch info to array
  87   //
  88   aReport.AddLast(new TObjString(name));
  89   Int_t entry = aReport.GetEntries();
  90   if (totSize.GetSize()<entry){
  91     totSize.Set(entry*2);
  92     zipSize.Set(entry*2);
  93     zipRatio.Set(entry*2);
  94   }
  95   totSize[entry-1]=Float_t(size[0]);
  96   zipSize[entry-1]=Float_t(size[1]);
  97   zipRatio[entry-1]=Float_t(ratio);
  98 }
  99
 100
 101
 102
 103
 104 void MakeStat(const char *prefix, TBranch * branch, Float_t* size, Float_t mratio);
 105
 106
 107
 108 void MakeStat(TTree *tree, Bool_t zipSort){
 109   //
 110   // make recursve loop over tree branches
 111   //
 112   fTree= tree;
 113   aReport.Clear();
 114   TObjArray * array = tree->GetListOfBranches();
 115   Float_t size[2]={0,0};
 116   char * prefix ="";
 117   Float_t mratio=tree->GetZipBytes()/float(tree->GetTotBytes());
 118   for (Int_t i=0; i<array->GetEntries(); i++){
 119     MakeStat(prefix,(TBranch*)array->At(i),size, mratio);
 120   }
 121   Float_t ratio= (size[0]>0) ? size[1]/Float_t(size[0]): 0;
 122   //  printf("Sum :\t%f\t%f\t%f\t%s.%s\t\n", float(size[0]), float(size[1]),ratio, prefix,tree->GetName());
 123
 124   AddToReport(tree->GetName(),size,ratio);
 125   PrintSorted(zipSort);
 126 }
 127
 128
 129 void MakeStat(const char *prefix, TBranch * branch, Float_t *size, Float_t mratio){
 130   //
 131   // Recursive function to get size of the branches
 132   // and ratios
 133   //
 134   TObjArray * array = branch->GetListOfBranches();
 135   Float_t bsizeSum[2]={0,0};
 136
 137   if (!array || array->GetEntries()==0){
 138     Float_t bsize[2] = {0,0};
 139     bsize[0]=branch->GetTotalSize();
 140     bsize[1]=branch->GetZipBytes();
 141     if (bsize[1]>0){
 142       Float_t ratio= (bsize[0]>0) ? bsize[1]/Float_t(bsize[0]): 0;
 143       //      printf("Term:\t%f\t%f\t%f\t%s.%s\t\n",float(bsize[0]), float(bsize[1]),ratio, prefix,branch->GetName());
 144       AddToReport(branch->GetName(),bsize,ratio);
 145       //branch->Print();
 146       size[0]+=bsize[0];
 147       size[1]+=bsize[1];
 148     }else{
 149       Float_t ratio= mratio;
 150       //printf("Ter?:\t%f\t%f\t%f\t%s.%s\t\n",float(bsize[0]), float(-1),ratio, prefix,branch->GetName());
 151       AddToReport(branch->GetName(),bsize,ratio);
 152       //branch->Print();
 153       size[0]+=bsize[0];
 154       size[1]+=TMath::Nint(bsize[0]*mratio);
 155     }
 156
 157     return;
 158   }
 159   for (Int_t i=0; i<array->GetEntries(); i++){
 160     Float_t bsize[2] = {0,0};
 161     TString str=prefix;
 162     str+= branch->GetName();
 163     MakeStat(str.Data(),(TBranch*)array->At(i), bsize, mratio);
 164     bsizeSum[0]+=bsize[0];
 165     bsizeSum[1]+=bsize[1];
 166     size[0]+=bsize[0];
 167     size[1]+=bsize[1];
 168   }
 169   Float_t ratio= (size[0]>0) ? size[1]/Float_t(size[0]): 0;
 170   //printf("Sum :\t%f\t%f\t%f\t%s.%s\t\n", float(bsizeSum[0]), float(bsizeSum[1]),ratio, prefix,branch->GetName());
 171   AddToReport(branch->GetName(),bsizeSum,ratio);
 172 }