PHOS/AliPHOSGetter.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, 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 /* $Id:  */
  17
  18 /* $Log:
  19    29.05.2001 Yuri Kharlov:
  20               Everywhere reading the treese TTree->GetEvent(i)
  21               is replaced by reading the branches TBranch->GetEntry(0)
  22 */
  23
  24 //_________________________________________________________________________
  25 //  A singleton. This class should be used in the analysis stage to get
  26 //  reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
  27 //  instead of directly reading them from galice.root file. This container
  28 //  ensures, that one reads Digits, made of these particular digits, RecPoints,
  29 //  made of these particular RecPoints, TrackSegments and RecParticles.
  30 //  This becomes non trivial if there are several identical branches, produced with
  31 //  different set of parameters.
  32 //
  33 //  An example of how to use (see also class AliPHOSAnalyser):
  34 //  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("galice.root","test") ;
  35 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
  36 //     AliPHOSRecParticle * part = gime->RecParticle(1) ;
  37 //     ................
  38 //  please->GetEvent(event) ;    // reads new event from galice.root
  39 //
  40 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
  41 //*--         Completely redesigned by Dmitri Peressounko March 2001
  42 //
  43 //*-- YS June 2001 : renamed the original AliPHOSIndexToObject and make
  44 //*--         systematic usage of TFolders without changing the interface
  45 //////////////////////////////////////////////////////////////////////////////
  46
  47
  48 // --- ROOT system ---
  49
  50 #include "TFile.h"
  51 #include "TTree.h"
  52 #include "TROOT.h"
  53 #include "TObjString.h"
  54 #include "TFolder.h"
  55
  56 // --- Standard library ---
  57 #include <iostream.h>
  58
  59 // --- AliRoot header files ---
  60
  61 #include "AliRun.h"
  62 #include "AliPHOSGetter.h"
  63 #include "AliPHOS.h"
  64 #include "AliPHOSDigitizer.h"
  65 #include "AliPHOSSDigitizer.h"
  66 #include "AliPHOSClusterizer.h"
  67 #include "AliPHOSClusterizerv1.h"
  68 #include "AliPHOSTrackSegmentMaker.h"
  69 #include "AliPHOSTrackSegmentMakerv1.h"
  70 #include "AliPHOSTrackSegment.h"
  71 #include "AliPHOSPID.h"
  72 #include "AliPHOSPIDv1.h"
  73 #include "AliPHOSGeometry.h"
  74
  75 ClassImp(AliPHOSGetter)
  76
  77   AliPHOSGetter * AliPHOSGetter::fgObjGetter = 0 ;
  78
  79 //____________________________________________________________________________
  80 AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* branchTitle )
  81 {
  82   //Initialize  all lists
  83
  84   fHeaderFile         = headerFile ;
  85   fBranchTitle        = branchTitle ;
  86   fSDigitsTitle       = branchTitle ;
  87   fDigitsTitle        = branchTitle ;
  88   fRecPointsTitle     = branchTitle ;
  89   fRecParticlesTitle  = branchTitle ;
  90   fTrackSegmentsTitle = branchTitle ;
  91
  92   fPrimaries = new TObjArray(1) ;
  93
  94   if ( fHeaderFile != "aliroot"  ) { // to call the getter without a file
  95
  96     //open headers file
  97     TFile * file = (TFile*) gROOT->GetFile(fHeaderFile.Data() ) ;
  98
  99     if(file == 0){    //if file was not opened yet, read gAlice
 100       if(fHeaderFile.Contains("rfio")) // if we read file using HPSS
 101         file =  TFile::Open(fHeaderFile.Data(),"update") ;
 102       else
 103         file = new TFile(fHeaderFile.Data(),"update") ;
 104
 105       if (!file->IsOpen()) {
 106         cerr << "ERROR : AliPHOSGetter::AliPHOSGetter -> Cannot open " << fHeaderFile.Data() << endl ;
 107         abort() ;
 108       }
 109
 110       gAlice = (AliRun *) file->Get("gAlice") ;
 111
 112       if (!gAlice) {
 113         cerr << "ERROR : AliPHOSGetter::AliPHOSGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ;
 114         abort() ;
 115       }
 116     }
 117   }
 118   fDebug=0;
 119 }
 120 //____________________________________________________________________________
 121 void AliPHOSGetter::CreateWhiteBoard() const
 122 {
 123   // Posts a few item to the white board (folders)
 124
 125   // -- the geometry
 126   if(!PostGeometry() ) abort() ;
 127
 128 }
 129
 130 //____________________________________________________________________________
 131 AliPHOSGetter * AliPHOSGetter::GetInstance()
 132 {
 133   // Returns the pointer of the unique instance already defined
 134
 135   AliPHOSGetter * rv = 0 ;
 136   if ( fgObjGetter )
 137     rv = fgObjGetter ;
 138   else
 139     cout << "AliPHOSGetter::GetInstance ERROR: not yet initialized" << endl ;
 140
 141   return rv ;
 142 }
 143
 144 //____________________________________________________________________________
 145 AliPHOSGetter * AliPHOSGetter::GetInstance(const char* headerFile,
 146                                            const char* branchTitle)
 147 {
 148   // Creates and returns the pointer of the unique instance
 149   // Must be called only when the environment has changed
 150
 151   if ( fgObjGetter )
 152     if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0) &&
 153        (fgObjGetter->fHeaderFile.CompareTo(headerFile)==0))
 154       return fgObjGetter ;
 155     else
 156       delete fgObjGetter ;  // delete it if already exists another version
 157
 158   fgObjGetter = new AliPHOSGetter(headerFile,branchTitle) ;
 159
 160   // Posts a few item to the white board (folders)
 161   fgObjGetter->CreateWhiteBoard() ;
 162
 163   return fgObjGetter ;
 164
 165 }
 166
 167 //____________________________________________________________________________
 168  const  AliPHOS * AliPHOSGetter::PHOS() const
 169 {
 170   // returns the PHOS object
 171   return ( (AliPHOS*)gAlice->GetDetector("PHOS") );
 172 }
 173
 174 //____________________________________________________________________________
 175   const AliPHOSGeometry *  AliPHOSGetter::PHOSGeometry() const
 176 {
 177   // retrieves the geometr from the folder
 178
 179   TString path("YSAlice/WhiteBoard/Geometry/PHOS/") ;
 180   path += PHOS()->GetTitle() ;
 181   return (AliPHOSGeometry*)gROOT->FindObjectAny(path.Data()) ;
 182 }
 183
 184 //____________________________________________________________________________
 185 Bool_t AliPHOSGetter::PostGeometry() const
 186 {  //--------Geometry --------------
 187
 188   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 189
 190   // the hierarchy is //YSALICE/WhiteBoard/Geometry/PHOS/
 191   TFolder * geomF  = (TFolder*)aliceF->FindObject("WhiteBoard/Geometry/PHOS") ;
 192   if ( !geomF ) {
 193     cerr << "ERROR: AliPHOSGetter::Post G -> Folder WhiteBoard/Geometry/PHOS/" << " not found!" << endl;
 194     return kFALSE ;
 195   }
 196   else {
 197     AliPHOSGeometry * geom = AliPHOSGeometry::GetInstance(PHOS()->GetTitle(),"") ;
 198     geomF->Add((TObject*)geom) ;
 199   }
 200   return kTRUE;
 201 }
 202 //____________________________________________________________________________
 203 Bool_t AliPHOSGetter::PostHits(void) const
 204 {  //------- Hits ----------------------
 205
 206   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 207
 208   // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/Hits
 209   TFolder * hitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Hits/PHOS") ;
 210   if ( !hitsF ) {
 211     cerr << "ERROR: AliPHOSGetter::Post H -> Folder WhiteBoard/Hits/PHOS/" << " not found!" << endl;
 212     return kFALSE ;
 213   }
 214
 215   TObject * h = hitsF->FindObject("Hits") ;
 216
 217   if(!h){
 218     TClonesArray *hits=  new TClonesArray("AliPHOSHit",1000) ;
 219     hits->SetName("Hits") ;
 220     hitsF->Add(hits) ;
 221   }
 222
 223   return kTRUE;
 224 }
 225 //____________________________________________________________________________
 226 TClonesArray ** AliPHOSGetter::HitsRef(void) const
 227 {  //------- Hits ----------------------
 228
 229   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 230
 231   // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/Hits
 232   TFolder * hitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Hits/PHOS") ;
 233   if ( !hitsF ) {
 234     cerr << "ERROR: AliPHOSGetter::Post H -> Folder WhiteBoard/Hits/PHOS/" << " not found!" << endl;
 235     return 0;
 236   }
 237
 238   TObject * h = hitsF->FindObject("Hits") ;
 239   if(!h)
 240     return 0 ;
 241   else
 242     return (TClonesArray **) hitsF->GetListOfFolders()->GetObjectRef(h) ;
 243
 244 }
 245 //____________________________________________________________________________
 246 Bool_t AliPHOSGetter::PostSDigits(const char * name, const char * headerFile) const
 247 {  //---------- SDigits -------------------------
 248
 249   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 250
 251   // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/headerFile/sdigitsname
 252   // because you can have sdigits from several hit files for mixing
 253
 254   TFolder * sdigitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/SDigits/PHOS") ;
 255   TString subdir(headerFile) ;
 256   TFolder * sdigitsF2 = (sdigitsF2=(TFolder*)sdigitsF->FindObject(subdir)) ;
 257   if ( !sdigitsF2 )
 258     sdigitsF2 = sdigitsF->AddFolder(subdir, "");
 259
 260   TObject * sd  = sdigitsF2->FindObject(name );
 261   if ( sd ) {
 262     if (fDebug)
 263       cerr <<"INFO: AliPHOSGetter::Post S -> Folder " << subdir
 264            << " already exists!" << endl ;
 265   }else{
 266     TClonesArray * sdigits = new TClonesArray("AliPHOSDigit",1000) ;
 267     sdigits->SetName(name) ;
 268     sdigitsF2->Add(sdigits) ;
 269   }
 270
 271   return kTRUE;
 272 }
 273 //____________________________________________________________________________
 274 TClonesArray ** AliPHOSGetter::SDigitsRef(const char * name, const char * file) const
 275 {  //------- Hits ----------------------
 276
 277   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 278
 279   // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/Hits
 280   TFolder * sdisF  = (TFolder*)aliceF->FindObject("WhiteBoard/SDigits/PHOS") ;
 281   if ( !sdisF ) {
 282     cerr << "ERROR: AliPHOSGetter::SDRef -> Folder WhiteBoard/SDigits/PHOS/" << " not found!" << endl;
 283     return 0;
 284   }
 285   TFolder * fileF ;
 286   if(file)
 287     fileF = (TFolder *) sdisF->FindObject(file) ;
 288   else
 289     fileF = (TFolder *) sdisF->FindObject(fHeaderFile) ;
 290
 291   if(!fileF)
 292     abort() ;
 293
 294   TObject * dis = fileF->FindObject(name) ;
 295   if(!dis)
 296     return 0 ;
 297   else
 298     return (TClonesArray **) fileF->GetListOfFolders()->GetObjectRef(dis) ;
 299
 300 }
 301
 302 //____________________________________________________________________________
 303 Bool_t AliPHOSGetter::PostSDigitizer(AliPHOSSDigitizer * sdigitizer) const
 304 {  //---------- SDigitizer -------------------------
 305
 306   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 307
 308   // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/sdigitsname
 309   TTask * sdigitsF  = (TTask*)aliceF->FindObject("tasks/SDigitizer") ;
 310   if ( !sdigitsF ) {
 311     cerr << "ERROR: AliPHOSGetter::Post Ser -> Task tasks/SDigitizer" << " not found!" << endl;
 312     return kFALSE ;
 313   }
 314   TTask * phos = (TTask*)sdigitsF->GetListOfTasks()->FindObject("PHOS") ;
 315   if ( !phos )  {
 316     cerr <<"ERROR: AliPHOSGetter::Post Ser -> tasks/SDigitizer/PHOS" << " not found!" << endl;
 317     return kFALSE ;
 318   }
 319   AliPHOSSDigitizer * phossd  = (AliPHOSSDigitizer *) phos->GetListOfTasks()->FindObject( sdigitizer->GetName() );
 320   if (phossd) {
 321     if (fDebug)
 322       cout << "INFO: AliPHOSGetter::Post Ser -> Task " << sdigitizer->GetName() << " already exists" << endl ;
 323     phos->GetListOfTasks()->Remove(phossd) ;
 324   }
 325   phos->Add(sdigitizer) ;
 326   return kTRUE;
 327
 328 }
 329 //____________________________________________________________________________
 330 AliPHOSSDigitizer ** AliPHOSGetter::SDigitizerRef(const char * name) const
 331 {
 332
 333   TString path("tasks/SDigitizer") ;
 334
 335   TFolder * aliceF  = (TFolder*)gROOT ->FindObjectAny("YSAlice") ;
 336   TTask   * aliceT  = (TTask*)  aliceF->FindObject(path) ;
 337
 338   if (!aliceT) {
 339     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << " not found!" << endl ;
 340     abort() ;
 341   }
 342
 343   TTask   * phosT   = (TTask*)  aliceT->GetListOfTasks()->FindObject("PHOS") ;
 344   if (!phosT) {
 345     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << "/PHOS not found!" << endl ;
 346     abort() ;
 347   }
 348   TList * l = phosT->GetListOfTasks() ;
 349
 350   TTask * task = (TTask*)l->FindObject(name) ;
 351
 352   return (AliPHOSSDigitizer **) l->GetObjectRef(task) ;
 353
 354 }
 355
 356
 357 //____________________________________________________________________________
 358 Bool_t AliPHOSGetter::PostSDigitizer(const char * name, const char * file) const
 359 {  //---------- SDigitizer -------------------------
 360
 361   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 362
 363   // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/sdigitsname
 364   TTask * sdigitsF  = (TTask*)aliceF->FindObject("tasks/SDigitizer") ;
 365   if ( !sdigitsF ) {
 366     cerr << "ERROR: AliPHOSGetter::Post Ser -> Task tasks/SDigitizer" << " not found!" << endl;
 367     return kFALSE ;
 368   }
 369   TTask * phos = (TTask*)sdigitsF->GetListOfTasks()->FindObject("PHOS") ;
 370   if ( !phos )  {
 371     cerr <<"ERROR: AliPHOSGetter::Post Ser -> tasks/SDigitizer/PHOS" << " not found!" << endl;
 372     return kFALSE ;
 373   }
 374   TString sdname(name) ;
 375   sdname.Append(":") ;
 376   sdname.Append(file);
 377   AliPHOSSDigitizer * phossd  = (AliPHOSSDigitizer *) phos->GetListOfTasks()->FindObject( sdname );
 378   if (!phossd) {
 379     phossd = new AliPHOSSDigitizer() ;
 380     //Note, we can not call constructor with parameters: it will call Getter and scrud up everething
 381     phossd->SetName(sdname) ;
 382     phossd->SetTitle(file) ;
 383     phos->Add(phossd) ;
 384   }
 385   return kTRUE;
 386
 387 }
 388 //____________________________________________________________________________
 389 Bool_t AliPHOSGetter::PostDigits(const char * name) const
 390 {  //---------- Digits -------------------------
 391
 392   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 393
 394   // the hierarchy is //YSALICE/WhiteBoard/Digits/PHOS/digitsname
 395   TFolder * digitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Digits/PHOS") ;
 396   if ( !digitsF ) {
 397     cerr << "ERROR: AliPHOSGetter::Post D -> Folder WhiteBoard/Digits/PHOS/" << " not found!" << endl;
 398     return kFALSE ;
 399   }
 400   digitsF->SetTitle("") ;
 401   TObject*  dig = digitsF->FindObject( name ) ;
 402   if ( !dig ) {
 403     TClonesArray * digits = new TClonesArray("AliPHOSDigit",1000) ;
 404     digits->SetName(name) ;
 405     digitsF->Add(digits) ;
 406   }
 407   return kTRUE;
 408 }
 409 //____________________________________________________________________________
 410 TClonesArray ** AliPHOSGetter::DigitsRef(const char * name) const
 411 {
 412
 413   TFolder * digitsF  = (TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/Digits/PHOS") ;
 414
 415    if ( !digitsF ) {
 416     cerr << "ERROR: AliPHOSGetter::DRef -> Folder WhiteBoard/Digits/PHOS/" << " not found!" << endl;
 417     return 0;
 418   }
 419
 420   TObject * d = digitsF->FindObject(name) ;
 421   if(!d)
 422     return 0 ;
 423   else
 424     return (TClonesArray **) digitsF->GetListOfFolders()->GetObjectRef(d) ;
 425
 426 }
 427
 428
 429 //____________________________________________________________________________
 430 Bool_t AliPHOSGetter::PostDigitizer(AliPHOSDigitizer * digitizer) const
 431 {  //---------- Digitizer -------------------------
 432
 433   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 434
 435   // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/digitsname
 436   TTask * digitsF  = (TTask*)aliceF->FindObject("tasks/Digitizer") ;
 437   if ( !digitsF ) {
 438     cerr << "ERROR: AliPHOSGetter::Post Der -> Task tasks/Digitizer" << " not found!" << endl;
 439     return kFALSE ;
 440   }
 441   TTask * phos = (TTask*)digitsF->GetListOfTasks()->FindObject("PHOS") ;
 442   if ( !phos )  {
 443     cerr <<"ERROR: AliPHOSGetter::Post Der -> tasks/Digitizer/PHOS" << " not found!" << endl;
 444     return kFALSE ;
 445   } else {
 446     AliPHOSDigitizer * phosd = (AliPHOSDigitizer*)phos->GetListOfTasks()->FindObject(digitizer->GetName()) ;
 447     if (phosd) {
 448       phosd->Delete() ;
 449       phos->GetListOfTasks()->Remove(phosd) ;
 450     }
 451     phos->Add((TTask*)digitizer) ;
 452     return kTRUE;
 453   }
 454 }
 455 //____________________________________________________________________________
 456 Bool_t AliPHOSGetter::PostDigitizer(const char * name) const
 457 {  //---------- Digitizer -------------------------
 458
 459   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 460
 461   // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/digitsname
 462   TTask * digitsF  = (TTask*)aliceF->FindObject("tasks/Digitizer") ;
 463   if ( !digitsF ) {
 464     cerr << "ERROR: AliPHOSGetter::Post Der -> Task tasks/Digitizer" << " not found!" << endl;
 465     return kFALSE ;
 466   }
 467   TTask * phos = (TTask*)digitsF->GetListOfTasks()->FindObject("PHOS") ;
 468   if ( !phos )  {
 469     cerr <<"ERROR: AliPHOSGetter::Post Der -> tasks/Digitizer/PHOS" << " not found!" << endl;
 470     return kFALSE ;
 471   }
 472
 473   AliPHOSDigitizer * phosd = (AliPHOSDigitizer*)phos->GetListOfTasks()->FindObject(name) ;
 474   if (!phosd) {
 475     phosd = new AliPHOSDigitizer() ;
 476     phosd->SetName(fDigitsTitle) ;
 477     phosd->SetTitle(fHeaderFile) ;
 478     phos->Add(phosd) ;
 479   }
 480   return kTRUE;
 481 }
 482
 483 //____________________________________________________________________________
 484 AliPHOSDigitizer ** AliPHOSGetter::DigitizerRef(const char * name) const
 485 {
 486
 487   TString path("tasks/Digitizer") ;
 488
 489   TFolder * aliceF  = (TFolder*)gROOT ->FindObjectAny("YSAlice") ;
 490   TTask   * aliceT  = (TTask*)  aliceF->FindObject(path) ;
 491
 492   if (!aliceT) {
 493     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << " not found!" << endl ;
 494     abort() ;
 495   }
 496
 497   TTask   * phosT   = (TTask*)  aliceT->GetListOfTasks()->FindObject("PHOS") ;
 498   if (!phosT) {
 499     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << "/PHOS not found!" << endl ;
 500     abort() ;
 501   }
 502   TList * l = phosT->GetListOfTasks() ;
 503
 504   TTask * task = (TTask*)l->FindObject(name) ;
 505
 506   return (AliPHOSDigitizer **) l->GetObjectRef(task) ;
 507
 508 }
 509
 510 //____________________________________________________________________________
 511 Bool_t AliPHOSGetter::PostRecPoints(const char * name) const
 512 { // -------------- RecPoints -------------------------------------------
 513
 514   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 515
 516   // the hierarchy is //YSALICE/WhiteBoard/RecPoints/PHOS/emc/recpointsname
 517   TFolder * emcrpF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/emc") ;
 518
 519   if ( !emcrpF ) {
 520     cerr << "ERROR: AliPHOSGetter::Post R -> Folder WhiteBoard/RecPoints/PHOS/emc"
 521          << " not found!" << endl;
 522     return kFALSE ;
 523   }
 524   emcrpF->SetTitle("") ;
 525   TObject * erp = emcrpF->FindObject(name ) ;
 526   if ( !erp )   {
 527     TObjArray * emcrp = new TObjArray(100) ;
 528     emcrp->SetName(name) ;
 529     emcrpF->Add(emcrp) ;
 530   }
 531
 532   TFolder * cpvrpF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/cpv") ;
 533
 534   if ( !cpvrpF ) {
 535     cerr << "ERROR: AliPHOSGetter::Post R -> Folder WhiteBoard/RecPoints/PHOS/cpv"
 536          << " not found!" << endl;
 537     return kFALSE ;
 538   }
 539   cpvrpF->SetTitle("") ;
 540   TObject * crp =  cpvrpF->FindObject( name ) ;
 541   if ( !crp )   {
 542     TObjArray * cpvrp = new TObjArray(100) ;
 543     cpvrp->SetName(name) ;
 544     cpvrpF->Add(cpvrp) ;
 545   }
 546   return kTRUE;
 547 }
 548
 549 //____________________________________________________________________________
 550 TObjArray ** AliPHOSGetter::EmcRecPointsRef(const char * name) const
 551 { // -------------- RecPoints -------------------------------------------
 552
 553   TFolder * emcrpF  = (TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/RecPoints/PHOS/emc") ;
 554
 555   if ( !emcrpF ) {
 556     cerr << "ERROR: AliPHOSGetter::EmcRecPointsRef -> Folder WhiteBoard/RecPoints/PHOS/emc"
 557          << " not found!" << endl;
 558     return 0 ;
 559   }
 560
 561   TObject * erp = emcrpF->FindObject(name ) ;
 562   if ( !erp )   {
 563     return 0 ;
 564   }
 565   return (TObjArray **) emcrpF->GetListOfFolders()->GetObjectRef(erp) ;
 566
 567 }
 568 //____________________________________________________________________________
 569 TObjArray ** AliPHOSGetter::CpvRecPointsRef(const char * name) const
 570 { // -------------- RecPoints -------------------------------------------
 571
 572   TFolder * cpvrpF  = (TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/RecPoints/PHOS/cpv") ;
 573
 574   if ( !cpvrpF ) {
 575     cerr << "ERROR: AliPHOSGetter::CpvRecPointsRef -> Folder WhiteBoard/RecPoints/PHOS/cpv"
 576          << " not found!" << endl;
 577     return 0 ;
 578   }
 579   TObject * crp = cpvrpF->FindObject(name ) ;
 580   if ( !crp )   {
 581     return 0 ;
 582   }
 583   return (TObjArray **) cpvrpF->GetListOfFolders()->GetObjectRef(crp) ;
 584
 585 }
 586
 587 //____________________________________________________________________________
 588 Bool_t AliPHOSGetter::PostClusterizer(AliPHOSClusterizer * clu) const
 589 { // ------------------ AliPHOSClusterizer ------------------------
 590
 591   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 592
 593   // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recpointsname
 594   TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ;
 595   if ( !reF ) {
 596     cerr << "ERROR: AliPHOSGetter::Post Rer -> Task tasks/Reconstructioner" << " not found!" << endl;
 597     return kFALSE ;
 598   }
 599
 600   TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 601
 602   if ( !phos )  {
 603     cerr <<"ERROR: AliPHOSGetter::Post Rer -> tasks/Reconstructioner/PHOS" << " not found!" << endl;
 604     return kFALSE ;
 605   } else {
 606     AliPHOSClusterizer * phoscl = (AliPHOSClusterizer*)phos->GetListOfTasks()->FindObject(clu->GetName()) ;
 607     if (phoscl) {
 608       if (fDebug)
 609         cout << "INFO: AliPHOSGetter::Post Rer -> Task " << clu->GetName() << " already exists" << endl ;
 610       phos->GetListOfTasks()->Remove(phoscl) ;
 611     }
 612     phos->Add(clu) ;
 613     return kTRUE;
 614   }
 615 }
 616
 617 //____________________________________________________________________________
 618 AliPHOSClusterizer ** AliPHOSGetter::ClusterizerRef(const char * name) const
 619 { // ------------------ AliPHOSClusterizer ------------------------
 620
 621   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 622
 623   // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recpointsname
 624   TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ;
 625   if ( !reF ) {
 626     cerr << "ERROR: AliPHOSGetter::Post Rer -> Task tasks/Reconstructioner" << " not found!" << endl;
 627     return kFALSE ;
 628   }
 629
 630   TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 631
 632   if ( !phos )  {
 633     cerr <<"ERROR: AliPHOSGetter::Post Rer -> tasks/Reconstructioner/PHOS" << " not found!" << endl;
 634     return 0 ;
 635   }
 636   TList * l = phos->GetListOfTasks() ;
 637   TIter it(l) ;
 638   TTask * task ;
 639   TTask * clu = 0 ;
 640   TString cluname(name) ;
 641   cluname+=":clu-" ;
 642   while((task = (TTask *)it.Next()) ){
 643     TString taskname(task->GetName()) ;
 644     if(taskname.BeginsWith(cluname)){
 645       clu = task ;
 646       break ;
 647     }
 648   }
 649
 650   if(clu)
 651     return (AliPHOSClusterizer **) l->GetObjectRef(clu) ;
 652   else
 653     return 0 ;
 654 }
 655
 656 //____________________________________________________________________________
 657 Bool_t AliPHOSGetter::PostClusterizer(const char * name) const
 658 { // ------------------ AliPHOSClusterizer ------------------------
 659
 660   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 661
 662   // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recpointsname
 663   TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ;
 664   if ( !reF ) {
 665     cerr << "ERROR: AliPHOSGetter::Post Rer -> Task tasks/Reconstructioner" << " not found!" << endl;
 666     return kFALSE ;
 667   }
 668
 669   TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 670
 671   if ( !phos )  {
 672     cerr <<"ERROR: AliPHOSGetter::Post Rer -> tasks/Reconstructioner/PHOS" << " not found!" << endl;
 673     return kFALSE ;
 674   }
 675   AliPHOSClusterizer * phoscl = new AliPHOSClusterizerv1() ;
 676   TString clun(name) ;
 677   clun+=":clu-v1" ;
 678   phoscl->SetName(clun) ;
 679   phos->Add(phoscl) ;
 680   return kTRUE;
 681
 682 }
 683 //____________________________________________________________________________
 684 Bool_t AliPHOSGetter::PostTrackSegments(const char * name) const
 685 { // ---------------TrackSegments -----------------------------------
 686
 687   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 688   // the hierarchy is //YSALICE/WhiteBoard/TrackSegments/PHOS/tracksegmentsname
 689   TFolder * tracksegmentsF  = (TFolder*)aliceF->FindObject("WhiteBoard/TrackSegments/PHOS") ;
 690   tracksegmentsF->SetTitle("") ;
 691   if ( !tracksegmentsF) {
 692     cerr << "ERROR: AliPHOSGetter::Post T -> Folder WhiteBoard/TrackSegments/PHOS" << " not found!" << endl;
 693     return kFALSE ;
 694   }
 695   TObject * tss =  tracksegmentsF->FindObject(name  ) ;
 696   if (!tss) {
 697     TClonesArray * ts = new TClonesArray("AliPHOSTrackSegment",100) ;
 698     ts->SetName(name) ;
 699     tracksegmentsF->Add(ts) ;
 700   }
 701   return kTRUE;
 702 }
 703
 704 //____________________________________________________________________________
 705 TClonesArray ** AliPHOSGetter::TrackSegmentsRef(const char * name) const
 706 { // ---------------TrackSegments -----------------------------------
 707
 708   TFolder * phosF  = (TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/TrackSegments/PHOS") ;
 709   if ( !phosF) {
 710     cerr << "ERROR: AliPHOSGetter::TrackSegmentsRef -> Folder WhiteBoard/TrackSegments/PHOS" << " not found!" << endl;
 711     return 0 ;
 712   }
 713
 714   TObject * tss =  phosF->FindObject(name) ;
 715   if (!tss) {
 716     return 0 ;
 717   }
 718   return (TClonesArray **) phosF->GetListOfFolders()->GetObjectRef(tss) ;
 719 }
 720
 721 //____________________________________________________________________________
 722 Bool_t AliPHOSGetter::PostTrackSegmentMaker(AliPHOSTrackSegmentMaker * tsmaker) const
 723 { //------------Track Segment Maker ------------------------------
 724
 725   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 726
 727   // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/tracksegmentsname
 728   TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ;
 729   if ( !reF ) {
 730     cerr << "ERROR: AliPHOSGetter::Post Ter -> Task tasks/Reconstructioner" << " not found!" << endl;
 731     return kFALSE ;
 732   }
 733   TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 734   if ( !phos )  {
 735     cerr <<"ERROR: AliPHOSGetter::Post Ter -> tasks/Reconstructioner/PHOS" << " not found!" << endl;
 736     return kFALSE ;
 737   }
 738
 739   AliPHOSTrackSegmentMaker * phosts =
 740     (AliPHOSTrackSegmentMaker*)phos->GetListOfTasks()->FindObject(tsmaker->GetName()) ;
 741   if (phosts) {
 742     phosts->Delete() ;
 743     phos->GetListOfTasks()->Remove(phosts) ;
 744   }
 745   phos->Add(tsmaker) ;
 746   return kTRUE;
 747
 748 }
 749 //____________________________________________________________________________
 750 Bool_t AliPHOSGetter::PostTrackSegmentMaker(const char * name) const
 751 { //------------Track Segment Maker ------------------------------
 752
 753   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 754
 755   // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/tracksegmentsname
 756   TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ;
 757   if ( !reF ) {
 758     cerr << "ERROR: AliPHOSGetter::Post Ter -> Task tasks/Reconstructioner" << " not found!" << endl;
 759     return kFALSE ;
 760   }
 761   TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 762   if ( !phos )  {
 763     cerr <<"ERROR: AliPHOSGetter::Post Ter -> tasks/Reconstructioner/PHOS" << " not found!" << endl;
 764     return kFALSE ;
 765   }
 766   AliPHOSTrackSegmentMaker * phosts =
 767     (AliPHOSTrackSegmentMaker*)phos->GetListOfTasks()->FindObject(name) ;
 768   if (!phosts) {
 769     phosts = new AliPHOSTrackSegmentMakerv1() ;
 770     TString tsn(name);
 771     tsn+=":tsm-v1" ;
 772     phosts->SetName(tsn) ;
 773     phos->Add(phosts) ;
 774   }
 775   return kTRUE;
 776
 777 }
 778 //____________________________________________________________________________
 779 AliPHOSTrackSegmentMaker ** AliPHOSGetter::TSMakerRef(const char * name) const
 780 { //------------Track Segment Maker ------------------------------
 781
 782   TTask * reF  = (TTask*)gROOT->FindObjectAny("YSAlice/tasks/Reconstructioner") ;
 783   if ( !reF ) {
 784     cerr << "ERROR: AliPHOSGetter::TrackSegmentMakerRef -> Task tasks/Reconstructioner"
 785          << " not found!" << endl;
 786     return 0 ;
 787   }
 788
 789   TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 790   if ( !phos ) {
 791     cerr << "ERROR: AliPHOSGetter::TrackSegmentMakerRef -> Task tasks/Reconstructioner/PHOS"
 792          << " not found!" << endl;
 793     return 0 ;
 794   }
 795   TList * l = phos->GetListOfTasks() ;
 796   TIter it(l) ;
 797   TTask * task ;
 798   TTask * tsm = 0 ;
 799   TString tsmname(name) ;
 800   tsmname+=":tsm-" ;
 801   while((task = (TTask *)it.Next()) ){
 802     TString taskname(task->GetName()) ;
 803     if(taskname.BeginsWith(tsmname)){
 804       tsm = task ;
 805       break ;
 806     }
 807   }
 808
 809   if(tsm)
 810     return (AliPHOSTrackSegmentMaker **) l->GetObjectRef(tsm) ;
 811   else
 812     return 0 ;
 813
 814 }
 815
 816 //____________________________________________________________________________
 817 Bool_t AliPHOSGetter::PostRecParticles(const char * name) const
 818 {  // -------------------- RecParticles ------------------------
 819
 820   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 821
 822   // the hierarchy is //YSALICE/WhiteBoard/RecParticles/PHOS/recparticlesname
 823   TFolder * recparticlesF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecParticles/PHOS") ;
 824   recparticlesF->SetTitle("") ;
 825   if ( !recparticlesF) {
 826     cerr << "ERROR: AliPHOSGetter::Post P -> Folder WhiteBoard/RecParticles/PHOS" << " not found!" << endl;
 827     return kFALSE ;
 828   }
 829   TObject * rps = recparticlesF->FindObject( name )  ;
 830   if ( !rps ) {
 831     TClonesArray * rp = new TClonesArray("AliPHOSRecParticle",100) ;
 832     rp->SetName(name) ;
 833     recparticlesF->Add(rp) ;
 834   }
 835   return kTRUE;
 836 }
 837 //____________________________________________________________________________
 838 TClonesArray ** AliPHOSGetter::RecParticlesRef(const char * name) const
 839 { // ---------------TrackSegments -----------------------------------
 840
 841   TFolder * tsF  = (TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/RecParticles/PHOS") ;
 842   if ( !tsF) {
 843     cerr << "ERROR: AliPHOSGetter::RecParticlesRef -> Folder WhiteBoard/RecParticles/PHOS" << " not found!" << endl;
 844     return 0 ;
 845   }
 846   TObject * tss =  tsF->FindObject(name  ) ;
 847   if (!tss) {
 848     return 0 ;
 849   }
 850   return (TClonesArray **) tsF->GetListOfFolders()->GetObjectRef(tss) ;
 851 }
 852
 853 //____________________________________________________________________________
 854 Bool_t AliPHOSGetter::PostPID(AliPHOSPID * pid) const
 855 {
 856   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 857
 858   // ------------AliPHOS PID -----------------------------
 859   // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recparticlesname
 860   TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ;
 861   if ( !reF ) {
 862     cerr << "ERROR: AliPHOSGetter::Post Per -> Task tasks/Reconstructioner" << " not found!" << endl;
 863     return kFALSE ;
 864   }
 865   TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 866   if ( !phos )  {
 867     cerr <<"ERROR: AliPHOSGetter::Post Per -> tasks/Reconstructioner/PHOS" << " not found!" << endl;
 868     return kFALSE ;
 869   }
 870   AliPHOSPID * phospid = (AliPHOSPID*)phos->GetListOfTasks()->FindObject(pid->GetName()) ;
 871   if (phospid) {
 872     if (fDebug)
 873       cout << "INFO: AliPHOSGetter::Post Per -> Task " << pid->GetName()
 874            << " already exists" << endl ;
 875     phos->GetListOfTasks()->Remove(phospid) ;
 876   }
 877
 878   phos->Add(pid) ;
 879   return kTRUE;
 880 }
 881 //____________________________________________________________________________
 882 Bool_t AliPHOSGetter::PostPID(const char * name) const
 883 {
 884   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 885
 886   // ------------AliPHOS PID -----------------------------
 887   // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recparticlesname
 888   TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ;
 889   if ( !reF ) {
 890     cerr << "ERROR: AliPHOSGetter::Post Per -> Task tasks/Reconstructioner" << " not found!" << endl;
 891     return kFALSE ;
 892   }
 893   TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 894   if ( !phos )  {
 895     cerr <<"ERROR: AliPHOSGetter::Post Per -> tasks/Reconstructioner/PHOS" << " not found!" << endl;
 896     return kFALSE ;
 897   }
 898
 899   TList * l = phos->GetListOfTasks() ;
 900   TIter it(l) ;
 901   TString pidname(name) ;
 902   pidname+=":pid" ;
 903   TTask * task ;
 904   while((task = (TTask *)it.Next()) ){
 905     TString taskname(task->GetName()) ;
 906     if(taskname.BeginsWith(pidname))
 907       return kTRUE ;
 908   }
 909
 910   AliPHOSPIDv1 * phospid = new AliPHOSPIDv1() ;
 911   pidname+="-v1" ;
 912   phospid->SetName(pidname) ;
 913   phos->Add(phospid) ;
 914
 915   return kTRUE;
 916 }
 917 //____________________________________________________________________________
 918 AliPHOSPID ** AliPHOSGetter::PIDRef(const char * name) const
 919 { //------------PID ------------------------------
 920
 921   TTask * reF  = (TTask*)gROOT->FindObjectAny("YSAlice/tasks/Reconstructioner") ;
 922   if ( !reF ) {
 923     cerr << "ERROR: AliPHOSGetter::PIDRef -> Task tasks/Reconstructioner"
 924          << " not found!" << endl;
 925     return 0 ;
 926   }
 927
 928   TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 929
 930   if ( !phos ) {
 931     cerr << "ERROR: AliPHOSGetter::PIDRef -> Task tasks/Reconstructioner/PHOS"
 932          << " not found!" << endl;
 933     return 0 ;
 934   }
 935   TList * l = phos->GetListOfTasks() ;
 936   TIter it(l) ;
 937   TTask * task ;
 938   TTask * pid = 0 ;
 939   TString pidname(name) ;
 940   pidname+=":pid-" ;
 941   while((task = (TTask *)it.Next()) ){
 942     TString taskname(task->GetName()) ;
 943     if(taskname.BeginsWith(pidname)){
 944       pid = task ;
 945       break ;
 946     }
 947   }
 948
 949   if(pid)
 950     return (AliPHOSPID **) l->GetObjectRef(pid) ;
 951   else
 952     return 0 ;
 953
 954 }
 955
 956 //____________________________________________________________________________
 957 Bool_t AliPHOSGetter::PostQA( const char * name) const
 958 {
 959   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 960
 961   // ------------------ QA ---------------------------------
 962   // the hierarchy is //YSALICE/WhiteBoard/Alarms/PHOS/
 963
 964   TFolder * alarmsF  = new TFolder() ;
 965   TString alarmsName ;
 966   if (name)
 967     alarmsName = name ;
 968   else
 969     alarmsName = "Alarm with no name" ;
 970   alarmsF->SetName( alarmsName.Data() ) ;
 971   alarmsF->SetTitle("") ;
 972   TFolder * qaaF  = (TFolder*)aliceF->FindObject("WhiteBoard/QAAlarms") ;
 973   if ( !qaaF) {
 974     cerr << "ERROR: AliPHOSGetter::Post QA -> Folder WhiteBoard/QAAlarms/" << " not found!" << endl;
 975     return kFALSE;
 976   }
 977   if ( qaaF->FindObject( alarmsName.Data() ) )
 978     qaaF->RecursiveRemove(  qaaF->FindObject( alarmsName.Data() ) ) ;
 979
 980   qaaF->Add(alarmsF) ;
 981
 982   return kTRUE;
 983 }
 984
 985 //____________________________________________________________________________
 986 const TParticle * AliPHOSGetter::Primary(Int_t index) const
 987 {
 988   // Return primary particle numbered by <index>
 989
 990   if(index < 0)
 991     return 0 ;
 992
 993   Int_t primaryIndex = index % 10000000 ;
 994   Int_t primaryList = (Int_t ) ((index-primaryIndex)/10000000.)  ;
 995
 996   if ( primaryList > 0  ) {
 997     cout << " Getter does not support currently Mixing of primary " << endl ;
 998     cout << "   can not return primary: " << index<< " (list "<< primaryList<< " primary # " << primaryIndex << " )"<<endl ;
 999     return 0;
1000   }
1001
1002   return gAlice->Particle(primaryIndex) ;
1003
1004 }
1005
1006 //____________________________________________________________________________
1007 void AliPHOSGetter::ReadTreeD()
1008 {
1009   // Read the digit tree gAlice->TreeD()
1010   if(gAlice->TreeD()== 0){
1011     cerr <<   "ERROR: AliPHOSGetter::ReadTreeD: can not read TreeD " << endl ;
1012   return ;
1013   }
1014
1015   TObjArray * lob = (TObjArray*)gAlice->TreeD()->GetListOfBranches() ;
1016   TIter next(lob) ;
1017   TBranch * branch = 0 ;
1018   TBranch * digitsbranch = 0 ;
1019   TBranch * digitizerbranch = 0 ;
1020   Bool_t phosfound = kFALSE, digitizerfound = kFALSE ;
1021
1022   while ( (branch = (TBranch*)next()) && (!phosfound || !digitizerfound) ) {
1023     if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1024       digitsbranch = branch ;
1025       phosfound = kTRUE ;
1026     }
1027     else if ( (strcmp(branch->GetName(), "AliPHOSDigitizer")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1028       digitizerbranch = branch ;
1029       digitizerfound = kTRUE ;
1030     }
1031   }
1032
1033   if ( !phosfound || !digitizerfound ) {
1034     cerr << "WARNING: AliPHOSGetter::ReadTreeD -> Cannot find Digits and/or Digitizer with name "
1035          << fDigitsTitle << endl ;
1036     return ;
1037   }
1038
1039   //read digits
1040   if(!Digits(fDigitsTitle) )
1041     PostDigits(fDigitsTitle);
1042   digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ;
1043   digitsbranch->GetEntry(0) ;
1044
1045
1046   // read  the Digitizer
1047   if(!Digitizer(fDigitsTitle))
1048     PostDigitizer(fDigitsTitle) ;
1049   digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ;
1050   digitizerbranch->GetEntry(0) ;
1051
1052
1053 }
1054
1055 //____________________________________________________________________________
1056 void AliPHOSGetter::ReadTreeH()
1057 {
1058   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
1059
1060   if(gAlice->TreeH()== 0){
1061     cerr <<   "ERROR: AliPHOSGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
1062     return ;
1063   }
1064
1065   TBranch * hitsbranch = (TBranch*)gAlice->TreeH()->GetBranch("PHOS") ;
1066   if ( !hitsbranch ) {
1067     cerr << "WARNING:  AliPHOSGetter::ReadTreeH -> Cannot find branch PHOS" << endl ;
1068     return ;
1069   }
1070   if(!Hits())
1071     PostHits() ;
1072
1073   hitsbranch->SetAddress(HitsRef()) ;
1074
1075   hitsbranch->GetEntry(0) ;
1076
1077 }
1078
1079 //____________________________________________________________________________
1080 void AliPHOSGetter::Track(Int_t itrack)
1081 {
1082   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
1083
1084   if(gAlice->TreeH()== 0){
1085     cerr <<   "ERROR: AliPHOSGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
1086     return ;
1087   }
1088
1089   TBranch * hitsbranch = (TBranch*)gAlice->TreeH()->GetListOfBranches()->FindObject("PHOS") ;
1090   if ( !hitsbranch ) {
1091     cerr << "WARNING:  AliPHOSGetter::ReadTreeH -> Cannot find branch PHOS" << endl ;
1092     return ;
1093   }
1094   if(!Hits())
1095     PostHits() ;
1096   hitsbranch->SetAddress(HitsRef()) ;
1097   hitsbranch->GetEntry(itrack) ;
1098
1099
1100 }
1101 //____________________________________________________________________________
1102 void AliPHOSGetter::ReadTreeQA()
1103 {
1104   // Read the digit tree gAlice->TreeQA()
1105   // so far only PHOS knows about this Tree
1106
1107   if(PHOS()->TreeQA()== 0){
1108     cerr <<   "ERROR: AliPHOSGetter::ReadTreeQA: can not read TreeQA " << endl ;
1109     return ;
1110   }
1111
1112   TBranch * qabranch = PHOS()->TreeQA()->GetBranch("PHOS") ;
1113   if (!qabranch) {
1114     cerr << "WARNING: AliPHOSGetter::ReadTreeQA -> Cannot find QA Alarms for PHOS" << endl ;
1115     return ;
1116   }
1117
1118   // Post the QA Alarms
1119   PostQA("PHOS") ;
1120   TFolder * alarmsF = Alarms() ;
1121   alarmsF->Clear() ;
1122   qabranch->SetAddress(&alarmsF) ;
1123   qabranch->GetEntry(0) ;
1124
1125 }
1126
1127 //____________________________________________________________________________
1128 void AliPHOSGetter::ReadTreeR()
1129 {
1130   // Read the reconstrunction tree gAlice->TreeR()
1131
1132   if(gAlice->TreeR()== 0){
1133     cout <<   "ERROR: AliPHOSGetter::ReadTreeR: can not read TreeR " << endl ;
1134     return ;
1135   }
1136
1137   // RecPoints
1138   TObjArray * lob = (TObjArray*)gAlice->TreeR()->GetListOfBranches() ;
1139   TIter next(lob) ;
1140   TBranch * branch = 0 ;
1141   TBranch * emcbranch = 0 ;
1142   TBranch * cpvbranch = 0 ;
1143   TBranch * clusterizerbranch = 0 ;
1144   Bool_t phosemcrpfound = kFALSE, phoscpvrpfound = kFALSE, clusterizerfound = kFALSE ;
1145
1146   while ( (branch = (TBranch*)next()) && (!phosemcrpfound || !phoscpvrpfound || !clusterizerfound) )
1147     if(strcmp(branch->GetTitle(), fRecPointsTitle)==0) {
1148       if ( strcmp(branch->GetName(), "PHOSEmcRP")==0) {
1149         emcbranch = branch ;
1150         phosemcrpfound = kTRUE ;
1151       }
1152       else if ( strcmp(branch->GetName(), "PHOSCpvRP")==0) {
1153         cpvbranch = branch ;
1154         phoscpvrpfound = kTRUE ;
1155       }
1156       else if(strcmp(branch->GetName(), "AliPHOSClusterizer")==0){
1157         clusterizerbranch = branch ;
1158         clusterizerfound = kTRUE ;
1159       }
1160     }
1161
1162   if ( !phosemcrpfound ) {
1163     cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find EmcRecPoints with title "
1164          << fRecPointsTitle << endl ;
1165     return ;
1166   }
1167   if ( !phoscpvrpfound ) {
1168     cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find CpvRecPoints with title "
1169          << fRecPointsTitle << endl ;
1170     return ;
1171   }
1172   if ( !clusterizerfound ) {
1173     cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Can not find Clusterizer with title "
1174          << fRecPointsTitle << endl ;
1175     return ;
1176   }
1177
1178   // Read and Post the RecPoints
1179   if(!EmcRecPoints(fRecPointsTitle) )
1180     PostRecPoints(fRecPointsTitle) ;
1181   emcbranch->SetAddress(EmcRecPointsRef(fRecPointsTitle)) ;
1182   emcbranch->GetEntry(0) ;
1183
1184   cpvbranch->SetAddress(CpvRecPointsRef(fRecPointsTitle)) ;
1185   cpvbranch->GetEntry(0) ;
1186
1187   if(!Clusterizer(fRecPointsTitle) )
1188     PostClusterizer(fRecPointsTitle) ;
1189   clusterizerbranch->SetAddress(ClusterizerRef(fRecPointsTitle)) ;
1190   clusterizerbranch->GetEntry(0) ;
1191
1192
1193   //------------------- TrackSegments ---------------------
1194   next.Reset() ;
1195   TBranch * tsbranch = 0 ;
1196   TBranch * tsmakerbranch = 0 ;
1197   Bool_t phostsfound = kFALSE, tsmakerfound = kFALSE ;
1198
1199   while ( (branch = (TBranch*)next()) && (!phostsfound || !tsmakerfound) )
1200     if(strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0)  {
1201       if ( strcmp(branch->GetName(), "PHOSTS")==0){
1202         tsbranch = branch ;
1203         phostsfound = kTRUE ;
1204       }
1205       else if(strcmp(branch->GetName(), "AliPHOSTrackSegmentMaker")==0) {
1206         tsmakerbranch = branch ;
1207         tsmakerfound  = kTRUE ;
1208       }
1209     }
1210
1211   if ( !phostsfound || !tsmakerfound ) {
1212     cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find TrackSegments and/or TrackSegmentMaker with name "
1213          << fTrackSegmentsTitle << endl ;
1214     return ;
1215   }
1216
1217   // Read and Post the TrackSegments
1218   if(!TrackSegments(fTrackSegmentsTitle))
1219     PostTrackSegments(fTrackSegmentsTitle) ;
1220   tsbranch->SetAddress(TrackSegmentsRef(fTrackSegmentsTitle)) ;
1221   tsbranch->GetEntry(0) ;
1222
1223   // Read and Post the TrackSegment Maker
1224   if(!TrackSegmentMaker(fTrackSegmentsTitle))
1225     PostTrackSegmentMaker(fTrackSegmentsTitle) ;
1226   tsmakerbranch->SetAddress(TSMakerRef(fTrackSegmentsTitle)) ;
1227   tsmakerbranch->GetEntry(0) ;
1228
1229
1230   //------------ RecParticles ----------------------------
1231   next.Reset() ;
1232   TBranch * rpabranch = 0 ;
1233   TBranch * pidbranch = 0 ;
1234   Bool_t phosrpafound = kFALSE, pidfound = kFALSE ;
1235
1236   while ( (branch = (TBranch*)next()) && (!phosrpafound || !pidfound) )
1237     if(strcmp(branch->GetTitle(), fRecParticlesTitle)==0) {
1238       if ( strcmp(branch->GetName(), "PHOSRP")==0) {
1239         rpabranch = branch ;
1240         phosrpafound = kTRUE ;
1241       }
1242       else if (strcmp(branch->GetName(), "AliPHOSPID")==0) {
1243         pidbranch = branch ;
1244         pidfound  = kTRUE ;
1245       }
1246     }
1247
1248   if ( !phosrpafound || !pidfound ) {
1249     cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find RecParticles and/or PID with name "
1250          << fRecParticlesTitle << endl ;
1251     return ;
1252   }
1253
1254   // Read and Post the RecParticles
1255   if(!RecParticles(fRecParticlesTitle))
1256     PostRecParticles(fRecParticlesTitle) ;
1257   rpabranch->SetAddress(RecParticlesRef(fRecParticlesTitle)) ;
1258   rpabranch->GetEntry(0) ;
1259
1260   // Read and Post the PID
1261   if(!PID(fRecParticlesTitle))
1262     PostPID(fRecParticlesTitle) ;
1263   pidbranch->SetAddress(PIDRef(fRecParticlesTitle)) ;
1264   pidbranch->GetEntry(0) ;
1265
1266
1267 }
1268
1269 //____________________________________________________________________________
1270 void AliPHOSGetter::ReadTreeS(Int_t event)
1271 {
1272   // Read the summable digits tree gAlice->TreeS()
1273
1274   // loop over all opened files and read their SDigits to the White Board
1275   TFolder * phosF = (TFolder *)gROOT->FindObjectAny("YSAlice/WhiteBoard/SDigits/PHOS") ;
1276   TCollection * folderslist = phosF->GetListOfFolders() ;
1277
1278   //Add current file to list if it is not there yet
1279   if ( (fHeaderFile != "aliroot") && ( !folderslist->Contains(fHeaderFile) ) ){
1280     phosF->AddFolder(fHeaderFile, "");
1281     folderslist = phosF->GetListOfFolders() ;
1282   }
1283
1284   TIter next(folderslist) ;
1285   TFolder * folder = 0 ;
1286   TFile * file;
1287   TTree * treeS = 0;
1288   while ( (folder = (TFolder*)next()) ) {
1289     if(fHeaderFile.CompareTo(folder->GetName()) == 0 )
1290       treeS=gAlice->TreeS() ;
1291     else{
1292       file = (TFile*)gROOT->GetFile(folder->GetName());
1293       file->cd() ;
1294
1295       // Get SDigits Tree header from file
1296       TString treeName("TreeS") ;
1297       treeName += event ;
1298       treeS = (TTree*)gDirectory->Get(treeName.Data());
1299     }
1300     if(treeS==0){
1301       cerr << "ERROR: AliPHOSGetter::ReadTreeS There is no SDigit Tree" << endl;
1302       return ;
1303     }
1304
1305     //set address of the SDigits and SDigitizer
1306     TBranch   * sdigitsBranch    = 0;
1307     TBranch   * sdigitizerBranch = 0;
1308     TBranch   * branch           = 0 ;
1309     TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
1310     TIter next(lob) ;
1311     Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ;
1312
1313     while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
1314       if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
1315         phosfound = kTRUE ;
1316         sdigitsBranch = branch ;
1317       }
1318
1319       else if ( (strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
1320         sdigitizerfound = kTRUE ;
1321         sdigitizerBranch = branch ;
1322       }
1323     }
1324     if ( !phosfound || !sdigitizerfound ) {
1325       cerr << "WARNING: AliPHOSDigitizer::ReadSDigits -> Digits and/or Digitizer branch with name " << GetName()
1326            << " not found" << endl ;
1327       return ;
1328     }
1329
1330     if ( !folder->FindObject(fSDigitsTitle) )
1331       PostSDigits(fSDigitsTitle,folder->GetName()) ;
1332     sdigitsBranch->SetAddress(SDigitsRef(fSDigitsTitle,folder->GetName())) ;
1333     sdigitsBranch->GetEntry(0) ;
1334
1335     TString sdname(fSDigitsTitle) ;
1336     sdname+=":" ;
1337     sdname+=folder->GetName() ;
1338     if(!SDigitizer(sdname) )
1339       PostSDigitizer(fSDigitsTitle,folder->GetName()) ;
1340     sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
1341     sdigitizerBranch->GetEntry(0) ;
1342
1343   }
1344
1345   // After SDigits have been read from all files, return to the first one
1346
1347   next.Reset();
1348   folder = (TFolder*)next();
1349   if(folder){
1350     file   = (TFile*)gROOT->GetFile(folder->GetName());
1351     file   ->cd() ;
1352   }
1353
1354 }
1355 //____________________________________________________________________________
1356 void AliPHOSGetter::ReadTreeS(TTree * treeS, Int_t input)
1357 {  // Read the summable digits fron treeS()
1358
1359   TString filename("mergefile") ;
1360   filename+= input ;
1361   TFolder * phosF =(TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/SDigits/PHOS")  ;
1362   TFolder * folder=(TFolder*)phosF->FindObject(filename) ;
1363   //set address of the SDigits and SDigitizer
1364   TBranch   * sdigitsBranch    = 0;
1365   TBranch   * sdigitizerBranch = 0;
1366   TBranch   * branch           = 0 ;
1367   TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
1368   TIter next(lob) ;
1369   Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ;
1370
1371   while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
1372     if ( strcmp(branch->GetName(), "PHOS")==0) {
1373       phosfound = kTRUE ;
1374       sdigitsBranch = branch ;
1375     }
1376
1377     else if ( strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) {
1378       sdigitizerfound = kTRUE ;
1379       sdigitizerBranch = branch ;
1380     }
1381   }
1382   if ( !phosfound || !sdigitizerfound ) {
1383     cerr << "WARNING: AliPHOSGetter::ReadTreeS -> Digits and/or Digitizer branch not found" << endl ;
1384     return ;
1385   }
1386
1387   if (!folder || !(folder->FindObject(sdigitsBranch->GetTitle()) ) )
1388     PostSDigits(sdigitsBranch->GetTitle(),filename) ;
1389
1390   sdigitsBranch->SetAddress(SDigitsRef(sdigitsBranch->GetTitle(),filename)) ;
1391
1392   TString sdname(sdigitsBranch->GetTitle()) ;
1393   sdname+=":" ;
1394   sdname+=filename ;
1395   if(!SDigitizer(sdigitsBranch->GetTitle()) )
1396     PostSDigitizer(sdigitsBranch->GetTitle(),filename) ;
1397   sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
1398
1399   sdigitsBranch->GetEntry(0) ;
1400   sdigitizerBranch->GetEntry(0) ;
1401
1402 }
1403
1404
1405 //____________________________________________________________________________
1406 void AliPHOSGetter::ReadPrimaries()
1407 {
1408   // Reads specific branches of primaries
1409
1410   fNPrimaries = gAlice->GetNtrack();
1411
1412   //   //Check, is it necessary to open new files
1413   //   TArrayI* events = fDigitizer->GetCurrentEvents() ;
1414   //   TClonesArray * filenames = fDigitizer->GetHeadersFiles() ;
1415 //   Int_t input ;
1416 //   for(input = 0; input < filenames->GetEntriesFast(); input++){
1417
1418 //     TObjString * filename = (TObjString *) filenames->At(input) ;
1419
1420 //     //Test, if this file already open
1421 //     TFile *file = (TFile*) gROOT->GetFile( filename->GetString() ) ;
1422 //     if(file == 0)
1423 //       file = new TFile( filename->GetString()) ;
1424 //     file->cd() ;
1425
1426 //     // Get Kine Tree from file
1427 // //     char treeName[20];
1428 // //     sprintf(treeName,"TreeK%d",events->At(input));
1429 // //     TTree * treeK = (TTree*)gDirectory->Get(treeName);
1430 // //     if (treeK)
1431 // //       treeK->SetBranchAddress("Particles", &fParticleBuffer);
1432 // //     else
1433 // //       cout << "AliPHOSGetter: cannot find Kine Tree for event:" << events->At(input) << endl;
1434
1435 // //     // Create the particle stack
1436 // //     if(!fParticles) fParticles = new TClonesArray("TParticle",1000);
1437 // //     // Build the pointer list
1438 // //     if(fParticleMap) {     <----
1439 // //       fParticleMap->Clear();
1440 // //       fParticleMap->Expand(treeK->GetEntries());
1441 // //     } else
1442 // //       fParticleMap = new TObjArray(treeK->GetEntries());
1443
1444 //     // From gAlice->Particle(i)
1445
1446
1447 // //   if(!(*fParticleMap)[i]) {
1448 // //     Int_t nentries = fParticles->GetEntries();
1449
1450 // //     // algorithmic way of getting entry index
1451 // //     // (primary particles are filled after secondaries)
1452 // //     Int_t entry;
1453 // //     if (i<fHeader.GetNprimary())
1454 // //       entry = i+fHeader.GetNsecondary();
1455 // //     else
1456 // //       entry = i-fHeader.GetNprimary();
1457
1458 // //     // only check the algorithmic way and give
1459 // //     // the fatal error if it is wrong
1460 // //     if (entry != fParticleFileMap[i]) {
1461 // //       Fatal("Particle",
1462 // //         "!!!! The algorithmic way is WRONG: !!!\n entry: %d map: %d",
1463 // //   entry, fParticleFileMap[i]);
1464 // //     }
1465
1466 // //     fTreeK->GetEntry(fParticleFileMap[i]);
1467 // //     new ((*fParticles)[nentries]) TParticle(*fParticleBuffer);
1468 // //     fParticleMap->AddAt((*fParticles)[nentries],i);
1469 // //   }
1470 // //   return (TParticle *) (*fParticleMap)[i];
1471
1472
1473
1474 //   }
1475
1476
1477 //   //scan over opened files and read corresponding TreeK##
1478
1479   return ;
1480 }
1481 //____________________________________________________________________________
1482 void AliPHOSGetter::Event(Int_t event, const char* opt)
1483 {
1484   // Reads the content of all Tree's S, D and R
1485
1486   if ( event > gAlice->TreeE()->GetEntries() ) {
1487     cerr << "ERROR: AliPHOSGetter::Event -> There are only "
1488          << gAlice->TreeE()->GetEntries() << " events in this file" << endl ;
1489     return ;
1490   }
1491
1492   gAlice->GetEvent(event) ;
1493
1494   if(strstr(opt,"H") )
1495     ReadTreeH() ;
1496
1497   if(strstr(opt,"S") )
1498     ReadTreeS(event) ;
1499
1500   if( strstr(opt,"D") )
1501     ReadTreeD() ;
1502
1503   if( strstr(opt,"R") )
1504     ReadTreeR() ;
1505
1506   if( strstr(opt,"Q") )
1507     ReadTreeQA() ;
1508
1509   if( strstr(opt,"P") )
1510     ReadPrimaries() ;
1511
1512 }
1513
1514 //____________________________________________________________________________
1515 const TObject * AliPHOSGetter::ReturnO(TString what, TString name, TString file) const
1516 {
1517   // get the object named "what" from the folder
1518   // folders are named like //YSAlice/WhiteBoard/what/PHOS/name
1519
1520   if ( file.IsNull() )
1521     file = fHeaderFile ;
1522   TString path("WhiteBoard/") ;
1523   if ( name.IsNull() ) {
1524     if ( what.CompareTo("Hits") == 0 ) {
1525       path += what ;
1526       path += "/PHOS/";
1527       path += what ;
1528     }
1529     else if ( what.CompareTo("SDigits") == 0 ) {
1530       path += what ;
1531       path += "/PHOS/";
1532       path += file ;
1533       path += "/" ;
1534       path += fSDigitsTitle ;
1535     }
1536     else if ( what.CompareTo("Digits") == 0 ){
1537       path += what ;
1538       path += "/PHOS/";
1539       path += fDigitsTitle ;
1540     }
1541     else if ( what.CompareTo("EmcRecPoints") == 0 ) {
1542       path += "RecPoints/PHOS/";
1543       path += "emc/" ;
1544       path += fRecPointsTitle ;
1545     }
1546     else if ( what.CompareTo("CpvRecPoints") == 0 ) {
1547       path += "RecPoints/PHOS/";
1548       path += "cpv/" ;
1549       path += fRecPointsTitle ;
1550     }
1551     else if ( what.CompareTo("TrackSegments") == 0 ) {
1552       path += "TrackSegments/PHOS/";
1553       path += fTrackSegmentsTitle ;
1554     }
1555     else if ( what.CompareTo("RecParticles") == 0 ) {
1556       path += "RecParticles/PHOS/";
1557       path += fRecParticlesTitle ;
1558     }
1559      else if ( what.CompareTo("Alarms") == 0 ) {
1560       path += "QAAlarms/PHOS";
1561     }
1562   }
1563   else {
1564     if ( what.CompareTo("SDigits") == 0 ) {
1565       path += what ;
1566       path += "/PHOS/";
1567       path += file ;
1568       path += "/" ;
1569       path += name ;
1570     }
1571     else if ( what.CompareTo("Digits") == 0 ) {
1572       path += what ;
1573       path += "/PHOS/";
1574       path += name ;
1575     }
1576     else if ( what.CompareTo("EmcRecPoints") == 0 ) {
1577       path += "RecPoints/PHOS/";
1578       path += "emc/" ;
1579       path += name ;
1580     }
1581     else if ( what.CompareTo("CpvRecPoints") == 0 ) {
1582       path += "RecPoints/PHOS/";
1583       path += "cpv/" ;
1584       path += name ;
1585     }
1586     else if ( what.CompareTo("TrackSegments") == 0 ) {
1587       path += "TrackSegments/PHOS/";
1588       path += name ;
1589     }
1590     else if ( what.CompareTo("RecParticles") == 0 ) {
1591       path += "RecParticles/PHOS/";
1592       path += name ;
1593     }
1594     else if ( what.CompareTo("Alarms") == 0 ) {
1595       path += "QAAlarms/PHOS/";
1596       path += name ;
1597     }
1598   }
1599   path.Prepend("YSAlice/") ;
1600   TObject * phosO  = (TObject*)gROOT->FindObjectAny(path) ;
1601   if (!phosO) {
1602     if(fDebug)
1603       cerr << "ERROR : AliPHOSGetter::ReturnO -> Object " << path << " not found!" << endl ;
1604     return 0 ;
1605   }
1606   return phosO ;
1607 }
1608
1609 //____________________________________________________________________________
1610 const TTask * AliPHOSGetter::ReturnT(TString what, TString name) const
1611 {
1612   // get the TTask named "what" from the folder
1613   // folders are named like //YSAlice/Tasks/what/PHOS/name
1614
1615   TString path("tasks") ;
1616
1617   if ( what.CompareTo("SDigitizer") == 0 )
1618     path += "/SDigitizer" ;
1619   else if ( what.CompareTo("Digitizer") == 0 )
1620     path += "/Digitizer" ;
1621   else if ( what.CompareTo("Clusterizer") == 0 )
1622     path += "/Reconstructioner" ;
1623   else if ( what.CompareTo("TrackSegmentMaker") == 0 )
1624     path += "/Reconstructioner" ;
1625   else if ( what.CompareTo("PID") == 0 )
1626     path += "/Reconstructioner" ;
1627   else if ( what.CompareTo("QATasks") == 0 )
1628     path += "/QA" ;
1629
1630   TFolder * aliceF  = (TFolder*)gROOT ->FindObjectAny("YSAlice") ;
1631   TTask   * aliceT  = (TTask*)  aliceF->FindObject(path) ;
1632
1633   if (!aliceT) {
1634     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << " not found!" << endl ;
1635     abort() ;
1636   }
1637
1638   TTask   * phosT   = (TTask*)  aliceT->GetListOfTasks()->FindObject("PHOS") ;
1639   if (!phosT) {
1640     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << "/PHOS not found!" << endl ;
1641     abort() ;
1642   }
1643   TList * l = phosT->GetListOfTasks() ;
1644
1645   if (what.CompareTo("SDigitizer") == 0) {
1646     if ( name.IsNull() )
1647       name =  fSDigitsTitle ;
1648   } else  if (what.CompareTo("Digitizer") == 0){
1649     if ( name.IsNull() )
1650       name =  fDigitsTitle ;
1651   } else  if (what.CompareTo("Clusterizer") == 0){
1652     if ( name.IsNull() )
1653       name =  fRecPointsTitle ;
1654     name.Append(":clu") ;
1655   }
1656   else  if (what.CompareTo("TrackSegmentMaker") == 0){
1657     if ( name.IsNull() )
1658       name =  fTrackSegmentsTitle ;
1659     name.Append(":tsm") ;
1660   }
1661   else  if (what.CompareTo("PID") == 0){
1662     if ( name.IsNull() )
1663       name =  fRecParticlesTitle ;
1664     name.Append(":pid") ;
1665   }
1666   else  if (what.CompareTo("QATasks") == 0){
1667     if ( name.IsNull() )
1668       return phosT ;
1669   }
1670
1671   TIter it(l) ;
1672   TTask * task = 0 ;
1673   while((task = (TTask *)it.Next()) ){
1674     TString taskname(task->GetName()) ;
1675     if(taskname.BeginsWith(name))
1676       return task ;
1677   }
1678
1679   if(fDebug)
1680     cerr << "WARNING: AliPHOSGetter::ReturnT -> Task " << path << "/" << name << " not found!" << endl ;
1681   return 0 ;
1682 }