PWGDQ/dielectron/TakuAlberica/single/AliDielectronHistosTaku.cxx

   1 /*************************************************************************
   2 * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
   3 *                                                                        *
   4 * Author: The ALICE Off-line Project.                                    *
   5 * Contributors are mentioned in the code where appropriate.              *
   6 *                                                                        *
   7 * Permission to use, copy, modify and distribute this software and its   *
   8 * documentation strictly for non-commercial purposes is hereby granted   *
   9 * without fee, provided that the above copyright notice appears in all   *
  10 * copies and that both the copyright notice and this permission notice   *
  11 * appear in the supporting documentation. The authors make no claims     *
  12 * about the suitability of this software for any purpose. It is          *
  13 * provided "as is" without express or implied warranty.                  *
  14 **************************************************************************/
  15
  16 //
  17 // Generic Histogram container with support for groups and filling of groups by passing
  18 // a vector of data
  19 //
  20 // Authors:
  21 //   Jens Wiechula <Jens.Wiechula@cern.ch>
  22 //
  23
  24 #include <iostream>
  25 #include <TH1.h>
  26 #include <TH1F.h>
  27 #include <TH2.h>
  28 #include <TH3.h>
  29 #include <TTree.h>
  30 #include <TCollection.h>
  31 #include <THashList.h>
  32 #include <TString.h>
  33 #include <TObjString.h>
  34 #include <TObjArray.h>
  35 #include <TFile.h>
  36 #include <TError.h>
  37 #include <TCanvas.h>
  38 #include <TMath.h>
  39 #include <TROOT.h>
  40 #include <TLegend.h>
  41 #include <TKey.h>
  42 #include <TAxis.h>
  43 #include <TVirtualPS.h>
  44 #include <TVectorD.h>
  45
  46 #include "AliDielectronHelper.h"
  47 #include "AliDielectronHistosTaku.h"
  48 #include "AliDielectronVarManager.h"
  49
  50 ClassImp(AliDielectronHistosTaku)
  51
  52
  53 AliDielectronHistosTaku::AliDielectronHistosTaku() :
  54 //   TCollection(),
  55   TNamed("AliDielectronHistosTaku","Dielectron Histogram Container"),
  56   fHistoList(),
  57   fTreeList(),
  58   fList(0x0),
  59   fTree(0x0),
  60   fReservedWords(new TString)
  61 {
  62   //
  63   // Default constructor
  64   //
  65   fHistoList.SetOwner(kTRUE);
  66   fHistoList.SetName("Dielectron_Histos");
  67   fTreeList.SetOwner(kTRUE);
  68   fTreeList.SetName("Dielectron_Tree");
  69 }
  70
  71 //_____________________________________________________________________________
  72 AliDielectronHistosTaku::AliDielectronHistosTaku(const char* name, const char* title) :
  73 //   TCollection(),
  74   TNamed(name, title),
  75   fHistoList(),
  76   fTreeList(),
  77   fList(0x0),
  78   fTree(0x0),
  79   fReservedWords(new TString)
  80 {
  81   //
  82   // TNamed constructor
  83   //
  84   fHistoList.SetOwner(kTRUE);
  85   fHistoList.SetName(name);
  86   fTreeList.SetOwner(kTRUE);
  87   char tname[100];
  88   sprintf(tname,"%s_tree", name);
  89   fTreeList.SetName(tname);
  90 }
  91
  92 //_____________________________________________________________________________
  93 AliDielectronHistosTaku::~AliDielectronHistosTaku()
  94 {
  95   //
  96   // Destructor
  97   //
  98   fHistoList.Clear();
  99   if (fList) fList->Clear();
 100   delete fReservedWords;
 101   fTreeList.Clear();
 102   if (fTree) fTree->Clear();
 103 }
 104
 105 //_____________________________________________________________________________
 106 void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title,
 107                                         Int_t nbinsX, Double_t xmin, Double_t xmax,
 108                                         UInt_t valTypeX, Bool_t logBinX)
 109 {
 110   //
 111   // Default histogram creation 1D case
 112   //
 113
 114   TVectorD *binLimX=0x0;
 115
 116   if (logBinX) {
 117     binLimX=AliDielectronHelper::MakeLogBinning(nbinsX, xmin, xmax);
 118   } else {
 119     binLimX=AliDielectronHelper::MakeLinBinning(nbinsX, xmin, xmax);
 120   }
 121
 122   UserHistogram(histClass,name,title,binLimX,valTypeX);
 123 }
 124
 125 //_____________________________________________________________________________
 126 void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title,
 127                                         Int_t nbinsX, Double_t xmin, Double_t xmax,
 128                                         Int_t nbinsY, Double_t ymin, Double_t ymax,
 129                                         UInt_t valTypeX, UInt_t valTypeY,
 130                                         Bool_t logBinX, Bool_t logBinY)
 131 {
 132   //
 133   // Default histogram creation 2D case
 134   //
 135   if (!IsHistogramOk(histClass,name)) return;
 136
 137   TVectorD *binLimX=0x0;
 138   TVectorD *binLimY=0x0;
 139
 140   if (logBinX) {
 141     binLimX=AliDielectronHelper::MakeLogBinning(nbinsX, xmin, xmax);
 142   } else {
 143     binLimX=AliDielectronHelper::MakeLinBinning(nbinsX, xmin, xmax);
 144   }
 145   if (logBinY) {
 146     binLimY=AliDielectronHelper::MakeLogBinning(nbinsY, ymin, ymax);
 147   } else {
 148     binLimY=AliDielectronHelper::MakeLinBinning(nbinsY, ymin, ymax);
 149   }
 150
 151   UserHistogram(histClass,name,title,binLimX,binLimY,valTypeX,valTypeY);
 152 }
 153
 154
 155 //_____________________________________________________________________________
 156 void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title,
 157                                         Int_t nbinsX, Double_t xmin, Double_t xmax,
 158                                         Int_t nbinsY, Double_t ymin, Double_t ymax,
 159                                         Int_t nbinsZ, Double_t zmin, Double_t zmax,
 160                                         UInt_t valTypeX, UInt_t valTypeY, UInt_t valTypeZ,
 161                                         Bool_t logBinX, Bool_t logBinY, Bool_t logBinZ)
 162 {
 163   //
 164   // Default histogram creation 3D case
 165   //
 166   if (!IsHistogramOk(histClass,name)) return;
 167
 168   TVectorD *binLimX=0x0;
 169   TVectorD *binLimY=0x0;
 170   TVectorD *binLimZ=0x0;
 171
 172   if (logBinX) {
 173     binLimX=AliDielectronHelper::MakeLogBinning(nbinsX, xmin, xmax);
 174   } else {
 175     binLimX=AliDielectronHelper::MakeLinBinning(nbinsX, xmin, xmax);
 176   }
 177
 178   if (logBinY) {
 179     binLimY=AliDielectronHelper::MakeLogBinning(nbinsY, ymin, ymax);
 180   } else {
 181     binLimY=AliDielectronHelper::MakeLinBinning(nbinsY, ymin, ymax);
 182   }
 183
 184   if (logBinZ) {
 185     binLimZ=AliDielectronHelper::MakeLogBinning(nbinsZ, zmin, zmax);
 186   } else {
 187     binLimZ=AliDielectronHelper::MakeLinBinning(nbinsZ, zmin, zmax);
 188   }
 189
 190   UserHistogram(histClass,name,title,binLimX,binLimY,binLimZ,valTypeX,valTypeY,valTypeZ);
 191 }
 192
 193 //_____________________________________________________________________________
 194 void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title,
 195                                         const char* binning,
 196                                         UInt_t valTypeX)
 197 {
 198   //
 199   // Histogram creation 1D case with arbitraty binning
 200   //
 201
 202   TVectorD *binLimX=AliDielectronHelper::MakeArbitraryBinning(binning);
 203   UserHistogram(histClass,name,title,binLimX,valTypeX);
 204 }
 205
 206 //_____________________________________________________________________________
 207 void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title,
 208                                         const TVectorD * const binsX,
 209                                         UInt_t valTypeX/*=kNoAutoFill*/)
 210 {
 211   //
 212   // Histogram creation 1D case with arbitraty binning X
 213   // the TVectorD is assumed to be surplus after the creation and will be deleted!!!
 214   //
 215
 216   Bool_t isOk=kTRUE;
 217   isOk&=IsHistogramOk(histClass,name);
 218   isOk&=(binsX!=0x0);
 219
 220   if (isOk){
 221     TH1* hist=new TH1F(name,title,binsX->GetNrows()-1,binsX->GetMatrixArray());
 222
 223     Bool_t isReserved=fReservedWords->Contains(histClass);
 224     if (isReserved)
 225       UserHistogramReservedWords(histClass, hist, valTypeX);
 226     else
 227       UserHistogram(histClass, hist, valTypeX);
 228   }
 229
 230   delete binsX;
 231 }
 232
 233 //_____________________________________________________________________________
 234 void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title,
 235                                         const TVectorD * const binsX, const TVectorD * const binsY,
 236                                         UInt_t valTypeX/*=kNoAutoFill*/, UInt_t valTypeY/*=0*/)
 237 {
 238   //
 239   // Histogram creation 1D case with arbitraty binning X
 240   // the TVectorD is assumed to be surplus after the creation and will be deleted!!!
 241   //
 242
 243   Bool_t isOk=kTRUE;
 244   isOk&=IsHistogramOk(histClass,name);
 245   isOk&=(binsX!=0x0);
 246   isOk&=(binsY!=0x0);
 247
 248   if (isOk){
 249     TH1* hist=new TH2F(name,title,
 250                        binsX->GetNrows()-1,binsX->GetMatrixArray(),
 251                        binsY->GetNrows()-1,binsY->GetMatrixArray());
 252
 253     Bool_t isReserved=fReservedWords->Contains(histClass);
 254     if (isReserved)
 255       UserHistogramReservedWords(histClass, hist, valTypeX+100*valTypeY);
 256     else
 257       UserHistogram(histClass, hist, valTypeX+100*valTypeY);
 258   }
 259
 260   delete binsX;
 261   delete binsY;
 262
 263 }
 264
 265 //_____________________________________________________________________________
 266 void AliDielectronHistosTaku::UserHistogram(const char* histClass,const char *name, const char* title,
 267                                         const TVectorD * const binsX, const TVectorD * const binsY, const TVectorD * const binsZ,
 268                                         UInt_t valTypeX/*=kNoAutoFill*/, UInt_t valTypeY/*=0*/, UInt_t valTypeZ/*=0*/)
 269 {
 270   //
 271   // Histogram creation 1D case with arbitraty binning X
 272   // the TVectorD is assumed to be surplus after the creation and will be deleted!!!
 273   //
 274
 275   Bool_t isOk=kTRUE;
 276   isOk&=IsHistogramOk(histClass,name);
 277   isOk&=(binsX!=0x0);
 278   isOk&=(binsY!=0x0);
 279   isOk&=(binsZ!=0x0);
 280
 281   if (isOk){
 282     TH1* hist=new TH3F(name,title,
 283                        binsX->GetNrows()-1,binsX->GetMatrixArray(),
 284                        binsY->GetNrows()-1,binsY->GetMatrixArray(),
 285                        binsZ->GetNrows()-1,binsZ->GetMatrixArray());
 286
 287     Bool_t isReserved=fReservedWords->Contains(histClass);
 288     if (isReserved)
 289       UserHistogramReservedWords(histClass, hist, valTypeX+100*valTypeY+10000*valTypeZ);
 290     else
 291       UserHistogram(histClass, hist, valTypeX+100*valTypeY+10000*valTypeZ);
 292   }
 293
 294   delete binsX;
 295   delete binsY;
 296   delete binsZ;
 297 }
 298
 299 //_____________________________________________________________________________
 300 void AliDielectronHistosTaku::UserHistogram(const char* histClass, TH1* hist, UInt_t valTypes)
 301 {
 302   //
 303   // Add any type of user histogram
 304   //
 305
 306   //special case for the calss Pair. where histograms will be created for all pair classes
 307   Bool_t isReserved=fReservedWords->Contains(histClass);
 308   if (isReserved) {
 309     UserHistogramReservedWords(histClass, hist, valTypes);
 310     return;
 311   }
 312
 313   if (!IsHistogramOk(histClass,hist->GetName())) return;
 314
 315   THashList *classTable=(THashList*)fHistoList.FindObject(histClass);
 316   hist->SetDirectory(0);
 317   hist->SetUniqueID(valTypes);
 318   classTable->Add(hist);
 319 }
 320
 321 //_____________________________________________________________________________
 322 void AliDielectronHistosTaku::AddClass(const char* histClass)
 323 {
 324   //
 325   // Add a class of histograms
 326   // Several classes can be added by separating them by a ';' e.g. 'class1;class2;class3'
 327   //
 328   TString hists(histClass);
 329   TObjArray *arr=hists.Tokenize(";");
 330   TIter next(arr);
 331   TObject *o=0;
 332   while ( (o=next()) ){
 333     if (fHistoList.FindObject(o->GetName())){
 334       Warning("AddClass","Cannot create class '%s' it already exists.",histClass);
 335       continue;
 336     }
 337     if (fReservedWords->Contains(o->GetName())){
 338       Error("AddClass","Pair is a reserved word, please use another name");
 339       continue;
 340     }
 341     THashList *table=new THashList;
 342     table->SetOwner(kTRUE);
 343     table->SetName(o->GetName());
 344     fHistoList.Add(table);
 345   }
 346   delete arr;
 347 }
 348
 349 //_____________________________________________________________________________
 350 void AliDielectronHistosTaku::Fill(const char* histClass, const char* name, Double_t xval)
 351 {
 352   //
 353   // Fill function 1D case
 354   //
 355   THashList *classTable=(THashList*)fHistoList.FindObject(histClass);
 356   TH1* hist=0;
 357   if (!classTable || !(hist=(TH1*)classTable->FindObject(name)) ){
 358     Warning("Fill","Cannot fill histogram. Either class '%s' or histogram '%s' not existing.",histClass,name);
 359     return;
 360   }
 361   hist->Fill(xval);
 362 }
 363
 364 //_____________________________________________________________________________
 365 void AliDielectronHistosTaku::Fill(const char* histClass, const char* name, Double_t xval, Double_t yval)
 366 {
 367   //
 368   // Fill function 2D case
 369   //
 370   THashList *classTable=(THashList*)fHistoList.FindObject(histClass);
 371   TH2* hist=0;
 372   if (!classTable || !(hist=(TH2*)classTable->FindObject(name)) ){
 373     Warning("UserHistogram","Cannot fill histogram. Either class '%s' or histogram '%s' not existing.",histClass,name);
 374     return;
 375   }
 376   hist->Fill(xval,yval);
 377 }
 378
 379 //_____________________________________________________________________________
 380 void AliDielectronHistosTaku::Fill(const char* histClass, const char* name, Double_t xval, Double_t yval, Double_t zval)
 381 {
 382   //
 383   // Fill function 3D case
 384   //
 385   THashList *classTable=(THashList*)fHistoList.FindObject(histClass);
 386   TH3* hist=0;
 387   if (!classTable || !(hist=(TH3*)classTable->FindObject(name)) ){
 388     Warning("UserHistogram","Cannot fill histogram. Either class '%s' or histogram '%s' not existing.",histClass,name);
 389     return;
 390   }
 391   hist->Fill(xval,yval,zval);
 392 }
 393
 394 //_____________________________________________________________________________
 395 void AliDielectronHistosTaku::FillClass(const char* histClass, Int_t nValues, const Double_t *values)
 396 {
 397   //
 398   // Fill class 'histClass' (by name)
 399   //
 400
 401   THashList *classTable=(THashList*)fHistoList.FindObject(histClass);
 402   if (!classTable){
 403     Warning("FillClass","Cannot fill class '%s' its not defined.",histClass);
 404     return;
 405   }
 406
 407   TIter nextHist(classTable);
 408   TH1 *hist=0;
 409   while ( (hist=(TH1*)nextHist()) ){
 410     UInt_t valueTypes=hist->GetUniqueID();
 411     if (valueTypes==(UInt_t)kNoAutoFill) continue;
 412     UInt_t value1=valueTypes%100;        //last two digits
 413     UInt_t value2=valueTypes/100%100;    //second last two digits
 414     UInt_t value3=valueTypes/10000%100;  //third last two digits
 415     if (value1>=(UInt_t)nValues||value2>=(UInt_t)nValues||value3>=(UInt_t)nValues) {
 416       Warning("FillClass","One of the values is out of range. Not filling histogram '%s/%s'.", histClass, hist->GetName());
 417       continue;
 418     }
 419     switch (hist->GetDimension()){
 420     case 1:
 421       hist->Fill(values[value1]);
 422       break;
 423     case 2:
 424       ((TH2*)hist)->Fill(values[value1],values[value2]);
 425       break;
 426     case 3:
 427       ((TH3*)hist)->Fill(values[value1],values[value2],values[value3]);
 428       break;
 429     }
 430   }
 431 }
 432
 433 //_____________________________________________________________________________
 434 // void AliDielectronHistosTaku::FillClass(const char* histClass, const TVectorD &vals)
 435 // {
 436 //   //
 437 //   //
 438 //   //
 439 //   FillClass(histClass, vals.GetNrows(), vals.GetMatrixArray());
 440 // }
 441
 442 //_____________________________________________________________________________
 443 void AliDielectronHistosTaku::UserHistogramReservedWords(const char* histClass, const TH1 *hist, UInt_t valTypes)
 444 {
 445   //
 446   // Creation of histogram for all pair types
 447   //
 448   TString title(hist->GetTitle());
 449   // Same Event Like Sign
 450   TIter nextClass(&fHistoList);
 451   THashList *l=0;
 452   while ( (l=static_cast<THashList*>(nextClass())) ){
 453     TString name(l->GetName());
 454     if (name.Contains(histClass)){
 455       TH1 *h=static_cast<TH1*>(hist->Clone());
 456       h->SetDirectory(0);
 457       h->SetTitle(Form("%s %s",title.Data(),l->GetName()));
 458       UserHistogram(l->GetName(),h,valTypes);
 459     }
 460   }
 461   delete hist;
 462 }
 463
 464 //_____________________________________________________________________________
 465 void AliDielectronHistosTaku::DumpToFile(const char* file)
 466 {
 467   //
 468   // Dump the histogram list to a newly created root file
 469   //
 470   TFile f(file,"recreate");
 471   fHistoList.Write(fHistoList.GetName(),TObject::kSingleKey);
 472   f.Close();
 473 }
 474
 475 //_____________________________________________________________________________
 476 TH1* AliDielectronHistosTaku::GetHistogram(const char* histClass, const char* name) const
 477 {
 478   //
 479   // return histogram 'name' in 'histClass'
 480   //
 481   THashList *classTable=(THashList*)fHistoList.FindObject(histClass);
 482   if (!classTable) return 0x0;
 483   return (TH1*)classTable->FindObject(name);
 484 }
 485
 486 //_____________________________________________________________________________
 487 TH1* AliDielectronHistosTaku::GetHistogram(const char* cutClass, const char* histClass, const char* name) const
 488 {
 489   //
 490   // return histogram from list of list of histograms
 491   // this function is thought for retrieving histograms if a list of AliDielectronHistosTaku is set
 492   //
 493
 494   if (!fList) return 0x0;
 495   THashList *h=dynamic_cast<THashList*>(fList->FindObject(cutClass));
 496   if (!h)return 0x0;
 497   THashList *classTable=dynamic_cast<THashList*>(h->FindObject(histClass));
 498   if (!classTable) return 0x0;
 499   return (TH1*)classTable->FindObject(name);
 500 }
 501
 502 //_____________________________________________________________________________
 503 void AliDielectronHistosTaku::Draw(const Option_t* option)
 504 {
 505   //
 506   // Draw histograms
 507   //
 508
 509   TString drawStr(option);
 510   TObjArray *arr=drawStr.Tokenize(";");
 511   arr->SetOwner();
 512   TIter nextOpt(arr);
 513
 514   TString drawClasses;
 515   TObjString *ostr=0x0;
 516
 517   TString currentOpt;
 518   TString testOpt;
 519   while ( (ostr=(TObjString*)nextOpt()) ){
 520     currentOpt=ostr->GetString();
 521     currentOpt.Remove(TString::kBoth,'\t');
 522     currentOpt.Remove(TString::kBoth,' ');
 523
 524     testOpt="classes=";
 525     if ( currentOpt.Contains(testOpt.Data()) ){
 526       drawClasses=currentOpt(testOpt.Length(),currentOpt.Length());
 527     }
 528   }
 529
 530   delete arr;
 531   drawStr.ToLower();
 532   //optionsfList
 533 //   Bool_t same=drawOpt.Contains("same"); //FIXME not yet implemented
 534
 535   TCanvas *c=0x0;
 536   if (gVirtualPS) {
 537     if (!gPad){
 538       Error("Draw","When writing to a file you have to create a canvas before opening the file!!!");
 539       return;
 540     }
 541     c=gPad->GetCanvas();
 542     c->cd();
 543 //     c=new TCanvas;
 544   }
 545
 546   TIter nextClass(&fHistoList);
 547   THashList *classTable=0;
 548 //   Bool_t first=kTRUE;
 549   while ( (classTable=(THashList*)nextClass()) ){
 550     //test classes option
 551     if (!drawClasses.IsNull() && !drawClasses.Contains(classTable->GetName())) continue;
 552     //optimised division
 553     Int_t nPads = classTable->GetEntries();
 554     Int_t nCols = (Int_t)TMath::Ceil( TMath::Sqrt(nPads) );
 555     Int_t nRows = (Int_t)TMath::Ceil( (Double_t)nPads/(Double_t)nCols );
 556
 557     //create canvas
 558     if (!gVirtualPS){
 559       TString canvasName;
 560       canvasName.Form("c%s_%s",GetName(),classTable->GetName());
 561       c=(TCanvas*)gROOT->FindObject(canvasName.Data());
 562       if (!c) c=new TCanvas(canvasName.Data(),Form("%s: %s",GetName(),classTable->GetName()));
 563       c->Clear();
 564     } else {
 565 //       if (first){
 566 //         first=kFALSE;
 567 //         if (nPads>1) gVirtualPS->NewPage();
 568 //       } else {
 569         if (nPads>1) c->Clear();
 570 //       }
 571     }
 572     if (nCols>1||nRows>1) c->Divide(nCols,nRows);
 573
 574     //loop over histograms and draw them
 575     TIter nextHist(classTable);
 576     Int_t iPad=0;
 577     TH1 *h=0;
 578     while ( (h=(TH1*)nextHist()) ){
 579       TString drawOpt;
 580       if ( (h->InheritsFrom(TH2::Class())) ) drawOpt="colz";
 581       if (nCols>1||nRows>1) c->cd(++iPad);
 582       if ( TMath::Abs(h->GetXaxis()->GetBinWidth(1)-h->GetXaxis()->GetBinWidth(2))>1e-10 ) gPad->SetLogx();
 583       if ( TMath::Abs(h->GetYaxis()->GetBinWidth(1)-h->GetYaxis()->GetBinWidth(2))>1e-10 ) gPad->SetLogy();
 584       if ( TMath::Abs(h->GetZaxis()->GetBinWidth(1)-h->GetZaxis()->GetBinWidth(2))>1e-10 ) gPad->SetLogz();
 585       TString histOpt=h->GetOption();
 586       histOpt.ToLower();
 587       if (histOpt.Contains("logx")) gPad->SetLogx();
 588       if (histOpt.Contains("logy")) gPad->SetLogy();
 589       if (histOpt.Contains("logz")) gPad->SetLogz();
 590       histOpt.ReplaceAll("logx","");
 591       histOpt.ReplaceAll("logy","");
 592       histOpt.ReplaceAll("logz","");
 593       h->Draw(drawOpt.Data());
 594     }
 595     if (gVirtualPS) {
 596       c->Update();
 597     }
 598
 599   }
 600 //   if (gVirtualPS) delete c;
 601 }
 602
 603 //_____________________________________________________________________________
 604 void AliDielectronHistosTaku::Print(const Option_t* option) const
 605 {
 606   //
 607   // Print classes and histograms
 608   //
 609   TString optString(option);
 610
 611   if (optString.IsNull()) PrintStructure();
 612
 613
 614
 615 }
 616
 617 //_____________________________________________________________________________
 618 void AliDielectronHistosTaku::PrintStructure() const
 619 {
 620   //
 621   // Print classes and histograms in the class to stdout
 622   //
 623   if (!fList){
 624     TIter nextClass(&fHistoList);
 625     THashList *classTable=0;
 626     while ( (classTable=(THashList*)nextClass()) ){
 627       TIter nextHist(classTable);
 628       TObject *o=0;
 629       printf("+ %s\n",classTable->GetName());
 630       while ( (o=nextHist()) )
 631         printf("| ->%s\n",o->GetName());
 632     }
 633   } else {
 634     TIter nextCutClass(fList);
 635     THashList *cutClass=0x0;
 636     while ( (cutClass=(THashList*)nextCutClass()) ) {
 637       printf("+ %s\n",cutClass->GetName());
 638       TIter nextClass(cutClass);
 639       THashList *classTable=0;
 640       while ( (classTable=(THashList*)nextClass()) ){
 641         TIter nextHist(classTable);
 642         TObject *o=0;
 643         printf("|  + %s\n",classTable->GetName());
 644         while ( (o=nextHist()) )
 645           printf("|  | ->%s\n",o->GetName());
 646       }
 647
 648     }
 649   }
 650 }
 651
 652 //_____________________________________________________________________________
 653 void AliDielectronHistosTaku::SetHistogramList(THashList &list, Bool_t setOwner/*=kTRUE*/)
 654 {
 655   //
 656   // set histogram classes and histograms to this instance. It will take onwnership!
 657   //
 658   ResetHistogramList();
 659   TString name(GetName());
 660   if (name == "AliDielectronHistosTaku") SetName(list.GetName());
 661   TIter next(&list);
 662   TObject *o;
 663   while ( (o=next()) ){
 664     fHistoList.Add(o);
 665   }
 666   if (setOwner){
 667     list.SetOwner(kFALSE);
 668     fHistoList.SetOwner(kTRUE);
 669   } else {
 670     fHistoList.SetOwner(kFALSE);
 671   }
 672 }
 673
 674 //_____________________________________________________________________________
 675 Bool_t AliDielectronHistosTaku::SetCutClass(const char* cutClass)
 676 {
 677   //
 678   // Assign histogram list according to cutClass
 679   //
 680
 681   if (!fList) return kFALSE;
 682   ResetHistogramList();
 683   THashList *h=dynamic_cast<THashList*>(fList->FindObject(cutClass));
 684   if (!h) {
 685     Warning("SetCutClass","cutClass '%s' not found", cutClass);
 686     return kFALSE;
 687   }
 688   SetHistogramList(*h,kFALSE);
 689   return kTRUE;
 690 }
 691
 692 //_____________________________________________________________________________
 693 Bool_t AliDielectronHistosTaku::IsHistogramOk(const char* histClass, const char* name)
 694 {
 695   //
 696   // check whether the histogram class exists and the histogram itself does not exist yet
 697   //
 698   Bool_t isReserved=fReservedWords->Contains(histClass);
 699   if (!fHistoList.FindObject(histClass)&&!isReserved){
 700     Warning("IsHistogramOk","Cannot create histogram. Class '%s' not defined. Please create it using AddClass before.",histClass);
 701     return kFALSE;
 702   }
 703   if (GetHistogram(histClass,name)){
 704     Warning("IsHistogramOk","Cannot create histogram '%s' in class '%s': It already exists!",name,histClass);
 705     return kFALSE;
 706   }
 707   return kTRUE;
 708 }
 709
 710 // //_____________________________________________________________________________
 711 // TIterator* AliDielectronHistosTaku::MakeIterator(Bool_t dir) const
 712 // {
 713 //   //
 714 //   //
 715 //   //
 716 //   return new TListIter(&fHistoList, dir);
 717 // }
 718
 719 //_____________________________________________________________________________
 720 void AliDielectronHistosTaku::ReadFromFile(const char* file)
 721 {
 722   //
 723   // Read histos from file
 724   //
 725   TFile f(file);
 726   TIter nextKey(f.GetListOfKeys());
 727   TKey *key=0;
 728   while ( (key=(TKey*)nextKey()) ){
 729     TObject *o=f.Get(key->GetName());
 730     THashList *list=dynamic_cast<THashList*>(o);
 731     if (!list) continue;
 732     SetHistogramList(*list);
 733     break;
 734   }
 735   f.Close();
 736 }
 737
 738 //_____________________________________________________________________________
 739 void AliDielectronHistosTaku::DrawSame(const char* histName, const Option_t *opt)
 740 {
 741   //
 742   // Draw all histograms with the same name into one canvas
 743   // if option contains 'leg' a legend will be created with the class name as caption
 744   // if option contains 'can' a new canvas is created
 745   //
 746
 747   TString optString(opt);
 748   optString.ToLower();
 749   Bool_t optLeg=optString.Contains("leg");
 750   Bool_t optCan=optString.Contains("can");
 751
 752   TLegend *leg=0;
 753   TCanvas *c=0;
 754   if (optCan){
 755     c=(TCanvas*)gROOT->FindObject(Form("c%s",histName));
 756     if (!c) c=new TCanvas(Form("c%s",histName),Form("All '%s' histograms",histName));
 757     c->Clear();
 758     c->cd();
 759   }
 760
 761   if (optLeg) leg=new TLegend(.8,.3,.99,.9);
 762
 763   Int_t i=0;
 764   TIter next(&fHistoList);
 765   THashList *classTable=0;
 766   Double_t max=-1e10;
 767   TH1 *hFirst=0x0;
 768   while ( (classTable=(THashList*)next()) ){
 769     if ( TH1 *h=(TH1*)classTable->FindObject(histName) ){
 770       if (i==0) hFirst=h;
 771       h->SetLineColor(i+1);
 772       h->SetMarkerColor(i+1);
 773       h->Draw(i>0?"same":"");
 774       if (leg) leg->AddEntry(h,classTable->GetName(),"lp");
 775       ++i;
 776       max=TMath::Max(max,h->GetMaximum());
 777     }
 778   }
 779   if (leg){
 780     leg->SetFillColor(10);
 781     leg->SetY1(.9-i*.05);
 782     leg->Draw();
 783   }
 784   if (hFirst&&(hFirst->GetYaxis()->GetXmax()<max)){
 785     hFirst->SetMaximum(max);
 786   }
 787 }
 788
 789 //_____________________________________________________________________________
 790 void AliDielectronHistosTaku::SetReservedWords(const char* words)
 791 {
 792   //
 793   // set reserved words
 794   //
 795
 796   (*fReservedWords)=words;
 797 }
 798
 799 //_____________________________________________________________________________
 800 void AliDielectronHistosTaku::UserTree(const char* name, const char *title)
 801 {
 802   fTree = new TTree(name, title);
 803 }
 804
 805 //_____________________________________________________________________________
 806 void AliDielectronHistosTaku::SetReserveVariableInTree(UInt_t valTypes)
 807 {
 808   switch(valTypes){
 809   case AliDielectronVarManager::kPx:
 810     fTree->Branch("kPx",&fgData[AliDielectronVarManager::kPx],"kPx/D"); break;
 811   case AliDielectronVarManager::kPy:
 812     fTree->Branch("kPy",&fgData[AliDielectronVarManager::kPy],"kPy/D"); break;
 813   case AliDielectronVarManager::kPz:
 814     fTree->Branch("kPz",&fgData[AliDielectronVarManager::kPz],"kPz/D"); break;
 815   case AliDielectronVarManager::kPt:
 816     fTree->Branch("kPt",&fgData[AliDielectronVarManager::kPt],"kPt/D"); break;
 817   case AliDielectronVarManager::kP:
 818     fTree->Branch("kP",&fgData[AliDielectronVarManager::kP],"kP/D"); break;
 819   case AliDielectronVarManager::kXv:
 820     fTree->Branch("kXv",&fgData[AliDielectronVarManager::kXv],"kXv/D"); break;
 821   case AliDielectronVarManager::kYv:
 822     fTree->Branch("kYv",&fgData[AliDielectronVarManager::kYv],"kYv/D"); break;
 823   case AliDielectronVarManager::kZv:
 824     fTree->Branch("kZv",&fgData[AliDielectronVarManager::kZv],"kZv/D"); break;
 825   case AliDielectronVarManager::kOneOverPt:
 826     fTree->Branch("kOneOverPt",&fgData[AliDielectronVarManager::kOneOverPt],"kOneOverPt/D"); break;
 827   case AliDielectronVarManager::kPhi:
 828     fTree->Branch("kPhi",&fgData[AliDielectronVarManager::kPhi],"kPhi/D"); break;
 829   case AliDielectronVarManager::kTheta:
 830     fTree->Branch("kTheta",&fgData[AliDielectronVarManager::kTheta],"kTheta/D"); break;
 831   case AliDielectronVarManager::kEta:
 832     fTree->Branch("kEta",&fgData[AliDielectronVarManager::kEta],"kEta/D"); break;
 833   case AliDielectronVarManager::kY:
 834     fTree->Branch("kY",&fgData[AliDielectronVarManager::kY],"kY/D"); break;
 835   case AliDielectronVarManager::kE:
 836     fTree->Branch("kE",&fgData[AliDielectronVarManager::kE],"kE/D"); break;
 837   case AliDielectronVarManager::kM:
 838     fTree->Branch("kM",&fgData[AliDielectronVarManager::kM],"kM/D"); break;
 839   case AliDielectronVarManager::kCharge:
 840     fTree->Branch("kCharge",&fgData[AliDielectronVarManager::kCharge],"kCharge/D"); break;
 841   case AliDielectronVarManager::kNclsITS:
 842     fTree->Branch("kNclsITS",&fgData[AliDielectronVarManager::kNclsITS],"kNclsITS/D"); break;
 843   case AliDielectronVarManager::kNclsTPC:
 844     fTree->Branch("kNclsTPC",&fgData[AliDielectronVarManager::kNclsTPC],"kNclsTPC/D"); break;
 845   case AliDielectronVarManager::kNclsTPCiter1:
 846     fTree->Branch("kNclsTPCiter1",&fgData[AliDielectronVarManager::kNclsTPCiter1],"kNclsTPCiter1/D"); break;
 847   case AliDielectronVarManager::kNFclsTPC:
 848     fTree->Branch("kNFclsTPC",&fgData[AliDielectronVarManager::kNFclsTPC],"kNFclsTPC/D"); break;
 849   case AliDielectronVarManager::kNFclsTPCr:
 850     fTree->Branch("kNFclsTPCr",&fgData[AliDielectronVarManager::kNFclsTPCr],"kNFclsTPCr/D"); break;
 851   case AliDielectronVarManager::kNFclsTPCrFrac:
 852     fTree->Branch("kNFclsTPCrFrac",&fgData[AliDielectronVarManager::kNFclsTPCrFrac],"kNFclsTPCrFrac/D"); break;
 853   case AliDielectronVarManager::kTPCsignalN:
 854     fTree->Branch("kTPCsignalN",&fgData[AliDielectronVarManager::kTPCsignalN],"kTPCsignalN/D"); break;
 855   case AliDielectronVarManager::kTPCsignalNfrac:
 856     fTree->Branch("kTPCsignalNfrac",&fgData[AliDielectronVarManager::kTPCsignalNfrac],"kTPCsignalNfrac/D"); break;
 857   case AliDielectronVarManager::kTPCchi2Cl:
 858     fTree->Branch("kTPCchi2Cl",&fgData[AliDielectronVarManager::kTPCchi2Cl],"kTPCchi2Cl/D"); break;
 859   case AliDielectronVarManager::kTrackStatus:
 860     fTree->Branch("kTrackStatus",&fgData[AliDielectronVarManager::kTrackStatus],"kTrackStatus/D"); break;
 861   case AliDielectronVarManager::kNclsTRD:
 862     fTree->Branch("kNclsTRD",&fgData[AliDielectronVarManager::kNclsTRD],"kNclsTRD/D"); break;
 863   case AliDielectronVarManager::kTRDntracklets:
 864     fTree->Branch("kTRDntracklets",&fgData[AliDielectronVarManager::kTRDntracklets],"kTRDntracklets/D"); break;
 865   case AliDielectronVarManager::kTRDpidQuality:
 866     fTree->Branch("kTRDpidQuality",&fgData[AliDielectronVarManager::kTRDpidQuality],"kTRDpidQuality/D"); break;
 867   case AliDielectronVarManager::kTRDprobEle:
 868     fTree->Branch("kTRDprobEle",&fgData[AliDielectronVarManager::kTRDprobEle],"kTRDprobEle/D"); break;
 869   case AliDielectronVarManager::kTRDprobPio:
 870     fTree->Branch("kTRDprobPio",&fgData[AliDielectronVarManager::kTRDprobPio],"kTRDprobPio/D"); break;
 871   case AliDielectronVarManager::kImpactParXY:
 872     fTree->Branch("kImpactParXY",&fgData[AliDielectronVarManager::kImpactParXY],"kImpactParXY/D"); break;
 873   case AliDielectronVarManager::kImpactParZ:
 874     fTree->Branch("kImpactParZ",&fgData[AliDielectronVarManager::kImpactParZ],"kImpactParZ/D"); break;
 875   case AliDielectronVarManager::kTrackLength:
 876     fTree->Branch("kTrackLength",&fgData[AliDielectronVarManager::kTrackLength],"kTrackLength/D"); break;
 877   case AliDielectronVarManager::kPdgCode:
 878     fTree->Branch("kPdgCode",&fgData[AliDielectronVarManager::kPdgCode],"kPdgCode/D"); break;
 879   case AliDielectronVarManager::kPdgCodeMother:
 880     fTree->Branch("kPdgCodeMother",&fgData[AliDielectronVarManager::kPdgCodeMother],"kPdgCodeMother/D"); break;
 881   case AliDielectronVarManager::kPdgCodeGrandMother:
 882     fTree->Branch("kPdgCodeGrandMother",&fgData[AliDielectronVarManager::kPdgCodeGrandMother],"kPdgCodeGrandMother/D"); break;
 883   case AliDielectronVarManager::kNumberOfDaughters:
 884     fTree->Branch("kNumberOfDaughters",&fgData[AliDielectronVarManager::kNumberOfDaughters],"kNumberOfDaughters/D"); break;
 885   case AliDielectronVarManager::kHaveSameMother:
 886     fTree->Branch("kHaveSameMother",&fgData[AliDielectronVarManager::kHaveSameMother],"kHaveSameMother/D"); break;
 887   case AliDielectronVarManager::kIsJpsiPrimary:
 888     fTree->Branch("kIsJpsiPrimary",&fgData[AliDielectronVarManager::kIsJpsiPrimary],"kIsJpsiPrimary/D"); break;
 889   case AliDielectronVarManager::kITSsignal:
 890     fTree->Branch("kITSsignal",&fgData[AliDielectronVarManager::kITSsignal],"kITSsignal/D"); break;
 891   case AliDielectronVarManager::kITSsignalSSD1:
 892     fTree->Branch("kITSsignalSSD1",&fgData[AliDielectronVarManager::kITSsignalSSD1],"kITSsignalSSD1/D"); break;
 893   case AliDielectronVarManager::kITSsignalSSD2:
 894     fTree->Branch("kITSsignalSSD2",&fgData[AliDielectronVarManager::kITSsignalSSD2],"kITSsignalSSD2/D"); break;
 895   case AliDielectronVarManager::kITSsignalSDD1:
 896     fTree->Branch("kITSsignalSDD1",&fgData[AliDielectronVarManager::kITSsignalSDD1],"kITSsignalSDD1/D"); break;
 897   case AliDielectronVarManager::kITSsignalSDD2:
 898     fTree->Branch("kITSsignalSDD2",&fgData[AliDielectronVarManager::kITSsignalSDD2],"kITSsignalSDD2/D"); break;
 899   case AliDielectronVarManager::kITSclusterMap:
 900     fTree->Branch("kITSclusterMap",&fgData[AliDielectronVarManager::kITSclusterMap],"kITSclusterMap/D"); break;
 901   case AliDielectronVarManager::kITSnSigmaEle:
 902     fTree->Branch("kITSnSigmaEle",&fgData[AliDielectronVarManager::kITSnSigmaEle],"kITSnSigmaEle/D"); break;
 903   case AliDielectronVarManager::kITSnSigmaPio:
 904     fTree->Branch("kITSnSigmaPio",&fgData[AliDielectronVarManager::kITSnSigmaPio],"kITSnSigmaPio/D"); break;
 905   case AliDielectronVarManager::kITSnSigmaMuo:
 906     fTree->Branch("kITSnSigmaMuo",&fgData[AliDielectronVarManager::kITSnSigmaMuo],"kITSnSigmaMuo/D"); break;
 907   case AliDielectronVarManager::kITSnSigmaKao:
 908     fTree->Branch("kITSnSigmaKao",&fgData[AliDielectronVarManager::kITSnSigmaKao],"kITSnSigmaKao/D"); break;
 909   case AliDielectronVarManager::kITSnSigmaPro:
 910     fTree->Branch("kITSnSigmaPro",&fgData[AliDielectronVarManager::kITSnSigmaPro],"kITSnSigmaPro/D"); break;
 911   case AliDielectronVarManager::kPIn:
 912     fTree->Branch("kPIn",&fgData[AliDielectronVarManager::kPIn],"kPIn/D"); break;
 913   case AliDielectronVarManager::kTPCsignal:
 914     fTree->Branch("kTPCsignal",&fgData[AliDielectronVarManager::kTPCsignal],"kTPCsignal/D"); break;
 915   case AliDielectronVarManager::kTOFsignal:
 916     fTree->Branch("kTOFsignal",&fgData[AliDielectronVarManager::kTOFsignal],"kTOFsignal/D"); break;
 917   case AliDielectronVarManager::kTOFbeta:
 918     fTree->Branch("kTOFbeta",&fgData[AliDielectronVarManager::kTOFbeta],"kTOFbeta/D"); break;
 919   case AliDielectronVarManager::kTPCnSigmaEle:
 920     fTree->Branch("kTPCnSigmaEle",&fgData[AliDielectronVarManager::kTPCnSigmaEle],"kTPCnSigmaEle/D"); break;
 921   case AliDielectronVarManager::kTPCnSigmaPio:
 922     fTree->Branch("kTPCnSigmaPio",&fgData[AliDielectronVarManager::kTPCnSigmaPio],"kTPCnSigmaPio/D"); break;
 923   case AliDielectronVarManager::kTPCnSigmaMuo:
 924     fTree->Branch("kTPCnSigmaMuo",&fgData[AliDielectronVarManager::kTPCnSigmaMuo],"kTPCnSigmaMuo/D"); break;
 925   case AliDielectronVarManager::kTPCnSigmaKao:
 926     fTree->Branch("kTPCnSigmaKao",&fgData[AliDielectronVarManager::kTPCnSigmaKao],"kTPCnSigmaKao/D"); break;
 927   case AliDielectronVarManager::kTPCnSigmaPro:
 928     fTree->Branch("kTPCnSigmaPro",&fgData[AliDielectronVarManager::kTPCnSigmaPro],"kTPCnSigmaPro/D"); break;
 929   case AliDielectronVarManager::kTOFnSigmaEle:
 930     fTree->Branch("kTOFnSigmaEle",&fgData[AliDielectronVarManager::kTOFnSigmaEle],"kTOFnSigmaEle/D"); break;
 931   case AliDielectronVarManager::kTOFnSigmaPio:
 932     fTree->Branch("kTOFnSigmaPio",&fgData[AliDielectronVarManager::kTOFnSigmaPio],"kTOFnSigmaPio/D"); break;
 933   case AliDielectronVarManager::kTOFnSigmaMuo:
 934     fTree->Branch("kTOFnSigmaMuo",&fgData[AliDielectronVarManager::kTOFnSigmaMuo],"kTOFnSigmaMuo/D"); break;
 935   case AliDielectronVarManager::kTOFnSigmaKao:
 936     fTree->Branch("kTOFnSigmaKao",&fgData[AliDielectronVarManager::kTOFnSigmaKao],"kTOFnSigmaKao/D"); break;
 937   case AliDielectronVarManager::kTOFnSigmaPro:
 938     fTree->Branch("kTOFnSigmaPro",&fgData[AliDielectronVarManager::kTOFnSigmaPro],"kTOFnSigmaPro/D"); break;
 939   case AliDielectronVarManager::kKinkIndex0:
 940     fTree->Branch("kKinkIndex0",&fgData[AliDielectronVarManager::kKinkIndex0],"kKinkIndex0/D"); break;
 941   case AliDielectronVarManager::kChi2NDF:
 942     fTree->Branch("kChi2NDF",&fgData[AliDielectronVarManager::kChi2NDF],"kChi2NDF/D"); break;
 943   case AliDielectronVarManager::kDecayLength:
 944     fTree->Branch("kDecayLength",&fgData[AliDielectronVarManager::kDecayLength],"kDecayLength/D"); break;
 945   case AliDielectronVarManager::kR:
 946     fTree->Branch("kR",&fgData[AliDielectronVarManager::kR],"kR/D"); break;
 947   case AliDielectronVarManager::kOpeningAngle:
 948     fTree->Branch("kOpeningAngle",&fgData[AliDielectronVarManager::kOpeningAngle],"kOpeningAngle/D"); break;
 949   case AliDielectronVarManager::kThetaHE:
 950     fTree->Branch("kThetaHE",&fgData[AliDielectronVarManager::kThetaHE],"kThetaHE/D"); break;
 951   case AliDielectronVarManager::kPhiHE:
 952     fTree->Branch("kPhiHE",&fgData[AliDielectronVarManager::kPhiHE],"kPhiHE/D"); break;
 953   case AliDielectronVarManager::kThetaCS:
 954     fTree->Branch("kThetaCS",&fgData[AliDielectronVarManager::kThetaCS],"kThetaCS/D"); break;
 955   case AliDielectronVarManager::kPhiCS:
 956     fTree->Branch("kPhiCS",&fgData[AliDielectronVarManager::kPhiCS],"kPhiCS/D"); break;
 957   case AliDielectronVarManager::kLegDist:
 958     fTree->Branch("kLegDist",&fgData[AliDielectronVarManager::kLegDist],"kLegDist/D"); break;
 959   case AliDielectronVarManager::kLegDistXY:
 960     fTree->Branch("kLegDistXY",&fgData[AliDielectronVarManager::kLegDistXY],"kLegDistXY/D"); break;
 961   case AliDielectronVarManager::kDeltaEta:
 962     fTree->Branch("kDeltaEta",&fgData[AliDielectronVarManager::kDeltaEta],"kDeltaEta/D"); break;
 963   case AliDielectronVarManager::kDeltaPhi:
 964     fTree->Branch("kDeltaPhi",&fgData[AliDielectronVarManager::kDeltaPhi],"kDeltaPhi/D"); break;
 965   case AliDielectronVarManager::kMerr:
 966     fTree->Branch("kMerr",&fgData[AliDielectronVarManager::kMerr],"kMerr/D"); break;
 967   case AliDielectronVarManager::kDCA:
 968     fTree->Branch("kDCA",&fgData[AliDielectronVarManager::kDCA],"kDCA/D"); break;
 969   case AliDielectronVarManager::kPairType:
 970     fTree->Branch("kPairType",&fgData[AliDielectronVarManager::kPairType],"kPairType/D"); break;
 971   case AliDielectronVarManager::kPseudoProperTime:
 972     fTree->Branch("kPseudoProperTime",&fgData[AliDielectronVarManager::kPseudoProperTime],"kPseudoProperTime/D"); break;
 973   case AliDielectronVarManager::kXvPrim:
 974     fTree->Branch("kXvPrim",&fgData[AliDielectronVarManager::kXvPrim],"kXvPrim=kPairMax/D"); break;
 975   case AliDielectronVarManager::kYvPrim:
 976     fTree->Branch("kYvPrim",&fgData[AliDielectronVarManager::kYvPrim],"kYvPrim/D"); break;
 977   case AliDielectronVarManager::kZvPrim:
 978     fTree->Branch("kZvPrim",&fgData[AliDielectronVarManager::kZvPrim],"kZvPrim/D"); break;
 979   case AliDielectronVarManager::kXRes:
 980     fTree->Branch("kXRes",&fgData[AliDielectronVarManager::kXRes],"kXRes/D"); break;
 981   case AliDielectronVarManager::kYRes:
 982     fTree->Branch("kYRes",&fgData[AliDielectronVarManager::kYRes],"kYRes/D"); break;
 983   case AliDielectronVarManager::kZRes:
 984     fTree->Branch("kZRes",&fgData[AliDielectronVarManager::kZRes],"kZRes/D"); break;
 985   case AliDielectronVarManager::kNTrk:
 986     fTree->Branch("kNTrk",&fgData[AliDielectronVarManager::kNTrk],"kNTrk/D"); break;
 987   case AliDielectronVarManager::kTracks:
 988     fTree->Branch("kTracks",&fgData[AliDielectronVarManager::kTracks],"kTracks/D"); break;
 989   case AliDielectronVarManager::kNacc:
 990     fTree->Branch("kNacc",&fgData[AliDielectronVarManager::kNacc],"kNacc/D"); break;
 991   case AliDielectronVarManager::kNaccTrcklts:
 992     fTree->Branch("kNaccTrcklts",&fgData[AliDielectronVarManager::kNaccTrcklts],"kNaccTrcklts/D"); break;
 993   case AliDielectronVarManager::kNch:
 994     fTree->Branch("kNch",&fgData[AliDielectronVarManager::kNch],"kNch/D"); break;
 995   case AliDielectronVarManager::kCentrality:
 996     fTree->Branch("kCentrality",&fgData[AliDielectronVarManager::kCentrality],"kCentrality/D"); break;
 997   case AliDielectronVarManager::kNevents:
 998     fTree->Branch("kNevents",&fgData[AliDielectronVarManager::kNevents],"kNevents/D"); break;
 999   }
1000   fTreeList.Add(fTree);
1001 }
1002
1003 //_____________________________________________________________________________
1004 void AliDielectronHistosTaku::FillTree(Int_t nValues, const Double_t *values)
1005 {
1006
1007   for(int i=0;i<nValues;i++){
1008     fgData[i]=values[i];
1009   }
1010
1011   //std::cout<<" --> "<<fgData[AliDielectronVarManager::kPIn]<<" "<<fgData[AliDielectronVarManager::kTPCsignal]<<" "<<fgData[AliDielectronVarManager::kTOFbeta]<<std::endl;
1012   //fTree->Fill();
1013 }
1014
1015 //_____________________________________________________________________________
1016 void AliDielectronHistosTaku::SetTreeList(THashList &list, Bool_t setOwner/*=kTRUE*/)
1017 {
1018   //
1019   // set histogram classes and histograms to this instance. It will take onwnership!
1020   //
1021   ResetHistogramList();
1022   TString name(GetName());
1023   if (name == "AliDielectronHistosTaku") SetName(list.GetName());
1024   TIter next(&list);
1025   TObject *o;
1026   while ( (o=next()) ){
1027     fTreeList.Add(o);
1028   }
1029   if (setOwner){
1030     list.SetOwner(kFALSE);
1031     fTreeList.SetOwner(kTRUE);
1032   } else {
1033     fTreeList.SetOwner(kFALSE);
1034   }
1035 }