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   fSDigitsTitle       = branchTitle ;
  86   fDigitsTitle        = branchTitle ;
  87   fRecPointsTitle     = branchTitle ;
  88   fRecParticlesTitle  = branchTitle ;
  89   fTrackSegmentsTitle = branchTitle ;
  90
  91   fPrimaries = new TObjArray(1) ;
  92
  93   if ( fHeaderFile != "aliroot" ) { // to call the getter without a file
  94
  95     //open headers file
  96     TFile * file = (TFile*) gROOT->GetFile(fHeaderFile.Data() ) ;
  97
  98     if(file == 0){    //if file was not opened yet, read gAlice
  99       if(fHeaderFile.Contains("rfio")) // if we read file using HPSS
 100         file =  TFile::Open(fHeaderFile.Data(),"update") ;
 101       else
 102         file = new TFile(fHeaderFile.Data(),"update") ;
 103
 104       if (!file->IsOpen()) {
 105         cerr << "ERROR : AliPHOSGetter::AliPHOSGetter -> Cannot open " << fHeaderFile.Data() << endl ;
 106         abort() ;
 107       }
 108
 109       gAlice = (AliRun *) file->Get("gAlice") ;
 110
 111       if (!gAlice) {
 112         cerr << "ERROR : AliPHOSGetter::AliPHOSGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ;
 113         abort() ;
 114       }
 115     }
 116   }
 117 }
 118 //____________________________________________________________________________
 119 void AliPHOSGetter::CreateWhiteBoard() const
 120 {
 121   // Posts a few item to the white board (folders)
 122
 123   // -- the geometry
 124   Post(fHeaderFile, "G") ;
 125
 126   // -- the hits
 127   Post(fHeaderFile, "H") ;
 128
 129 }
 130
 131 //____________________________________________________________________________
 132 AliPHOSGetter * AliPHOSGetter::GetInstance()
 133 {
 134   // Returns the pointer of the unique instance already defined
 135
 136   AliPHOSGetter * rv = 0 ;
 137   if ( fgObjGetter )
 138     rv = fgObjGetter ;
 139   else
 140     cout << "AliPHOSGetter::GetInstance ERROR: not yet initialized" << endl ;
 141
 142   return rv ;
 143 }
 144
 145 //____________________________________________________________________________
 146 AliPHOSGetter * AliPHOSGetter::GetInstance(const char* headerFile,
 147                                            const char* branchTitle)
 148 {
 149   // Creates and returns the pointer of the unique instance
 150   // Must be called only when the environment has changed
 151
 152
 153   if ( fgObjGetter )      // delete it if already exists
 154     delete fgObjGetter ;
 155
 156   fgObjGetter = new AliPHOSGetter(headerFile,branchTitle) ;
 157
 158   // Posts a few item to the white board (folders)
 159   fgObjGetter->CreateWhiteBoard() ;
 160
 161   // Get the first event into the arrays posted on the white board
 162   // branchTitle = 0, means simulation run and no event yet
 163   if (branchTitle)
 164     fgObjGetter->Event(0) ;
 165
 166   return fgObjGetter ;
 167
 168 }
 169
 170 //____________________________________________________________________________
 171  const  AliPHOS * AliPHOSGetter::PHOS() const
 172 {
 173   // returns the PHOS object
 174   return ( (AliPHOS*)gAlice->GetDetector("PHOS") );
 175 }
 176
 177 //____________________________________________________________________________
 178   const AliPHOSGeometry *  AliPHOSGetter::PHOSGeometry() const
 179 {
 180   // retrieves the geometr from the folder
 181
 182   TString path("YSAlice/WhiteBoard/Geometry/PHOS/") ;
 183   path += PHOS()->GetTitle() ;
 184   return (AliPHOSGeometry*)gROOT->FindObjectAny(path.Data()) ;
 185 }
 186
 187 //____________________________________________________________________________
 188 void AliPHOSGetter::Post(const char * headerFile, const char * opt, const char * name, const Int_t event) const
 189 {
 190   // Adds a new folder for summable digits
 191
 192   TString foldertitle ;
 193   if ( event >= 0 )
 194     foldertitle += event ;
 195   else
 196     foldertitle = "" ;
 197
 198   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
 199
 200   if ( strcmp(opt, "G") == 0 ) { // Geometry
 201     // the hierarchy is //YSALICE/WhiteBoard/Geometry/PHOS/
 202     AliPHOSGeometry * geom = AliPHOSGeometry::GetInstance(PHOS()->GetTitle(),"") ;
 203     TFolder * geomF  = (TFolder*)aliceF->FindObject("WhiteBoard/Geometry/PHOS") ;
 204     if ( !geomF ) {
 205       cerr << "ERROR: AliPHOSGetter::Post G -> Folder WhiteBoard/Geometry/PHOS/" << " not found!" << endl;
 206       abort() ;
 207     }
 208     else
 209       geomF->Add((TObject*)geom) ;
 210
 211   } else if ( strcmp(opt, "H") == 0 ) { // Hits
 212     // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/Hits
 213     TClonesArray * hits = new TClonesArray("AliPHOSHit",1000) ;
 214     hits->SetName("Hits") ;
 215     TFolder * hitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Hits/PHOS") ;
 216     if ( !hitsF ) {
 217       cerr << "ERROR: AliPHOSGetter::Post H -> Folder WhiteBoard/Hits/PHOS/" << " not found!" << endl;
 218       abort() ;
 219     }
 220     else
 221       hitsF->Add(hits) ;
 222
 223   } else if ( strcmp(opt, "S") == 0 ) { // summable digits
 224     // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/headerFile/sdigitsname
 225     // because you can have sdigits from several hit files for mixing
 226     TClonesArray * sdigits = new TClonesArray("AliPHOSDigit",1000) ;
 227     TString sdigitsName ;
 228     if (name)
 229       sdigitsName = name ;
 230     else
 231       sdigitsName = "SDigits" ;
 232     sdigits->SetName( sdigitsName.Data() ) ;
 233     TFolder * sdigitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/SDigits/PHOS") ;
 234     TFolder * sdigitsF2 = 0 ;
 235     TString subdir(headerFile) ;
 236     if ( !(sdigitsF2=(TFolder*)sdigitsF->FindObject(subdir)) )
 237       sdigitsF2 = sdigitsF->AddFolder(subdir, foldertitle);
 238     else {
 239       if ( sdigitsF2->FindObject( sdigitsName.Data() ) ) {
 240         cerr <<"INFO: AliPHOSGetter::Post S -> Folder " << subdir << ", " << foldertitle
 241              << " already exists!" << endl ;
 242         return ;
 243       }
 244     }
 245     if ( !sdigitsF2 ) {
 246       cerr << "ERROR: AliPHOSGetter::Post S -> Folder WhiteBoard/SDigits/PHOS/" << subdir << " not created!" << endl;
 247       abort() ;
 248     }
 249     else
 250       sdigitsF2->Add(sdigits) ;
 251
 252   } else if ( strcmp(opt, "Ser") == 0 ) { // sdigizer
 253     // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/sdigitsname
 254     AliPHOSSDigitizer * sdigitizer = new AliPHOSSDigitizer() ;
 255     TString sdigitsName ;
 256     if (name)
 257       sdigitsName = name ;
 258     else
 259       sdigitsName = "SDigitizer" ;
 260     sdigitizer->SetName( sdigitsName.Data() ) ;
 261     TTask * sdigitsF  = (TTask*)aliceF->FindObject("tasks/SDigitizer") ;
 262     if ( !sdigitsF ) {
 263       cerr << "ERROR: AliPHOSGetter::Post Ser -> Task tasks/SDigitizer" << " not found!" << endl;
 264       abort() ;
 265     }
 266     TTask * phos = (TTask*)sdigitsF->GetListOfTasks()->FindObject("PHOS") ;
 267     if ( !phos )  {
 268       cerr <<"ERROR: AliPHOSGetter::Post Ser -> tasks/SDigitizer/PHOS" << " not found!" << endl;
 269       abort() ;
 270     } else {
 271       AliPHOSSDigitizer * phossd = (AliPHOSSDigitizer*)phos->GetListOfTasks()->FindObject(sdigitsName.Data()) ;
 272       if (phossd) {
 273         cout << "INFO: AliPHOSGetter::Post Ser -> Task " << sdigitsName.Data() << " already exists" << endl ;
 274         return ;
 275       } else
 276         phos->Add(sdigitizer) ;
 277     }
 278
 279   } else if ( strcmp(opt, "D") == 0 ) { // digits
 280     // the hierarchy is //YSALICE/WhiteBoard/Digits/PHOS/digitsname
 281     TClonesArray * digits  = new TClonesArray("AliPHOSDigit",20000) ;
 282     TString digitsName ;
 283     if (name)
 284       digitsName = name ;
 285     else
 286       digitsName = "Digits" ;
 287     digits->SetName( digitsName.Data() ) ;
 288     TFolder * digitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Digits/PHOS") ;
 289     if ( !digitsF ) {
 290       cerr << "ERROR: AliPHOSGetter::Post D -> Folder WhiteBoard/Digits/PHOS/" << " not found!" << endl;
 291       abort() ;
 292     }
 293     digitsF->SetTitle(foldertitle) ;
 294     if ( digitsF->FindObject( digitsName.Data() ) ) {
 295       cerr <<"INFO: AliPHOSGetter::Post D -> Object " << digitsName.Data()
 296            << " already exists!" << endl ;
 297       return ;
 298     }
 299     else
 300       digitsF->Add(digits) ;
 301
 302   } else if ( strcmp(opt, "Der") == 0 ) { // sdigizer
 303     // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/digitsname
 304     AliPHOSDigitizer * digitizer = new AliPHOSDigitizer() ;
 305     TString digitsName ;
 306     if (name)
 307       digitsName = name ;
 308     else
 309       digitsName = "Digitizer" ;
 310     digitizer->SetName( digitsName.Data() ) ;
 311     TTask * digitsF  = (TTask*)aliceF->FindObject("tasks/Digitizer") ;
 312     if ( !digitsF ) {
 313       cerr << "ERROR: AliPHOSGetter::Post Der -> Task tasks/Digitizer" << " not found!" << endl;
 314       abort() ;
 315     }
 316     TTask * phos = (TTask*)digitsF->GetListOfTasks()->FindObject("PHOS") ;
 317     if ( !phos )  {
 318       cerr <<"ERROR: AliPHOSGetter::Post Der -> tasks/Digitizer/PHOS" << " not found!" << endl;
 319       abort() ;
 320     } else {
 321       AliPHOSDigitizer * phosd = (AliPHOSDigitizer*)phos->GetListOfTasks()->FindObject(digitsName.Data()) ;
 322       if (phosd) {
 323         cout << "INFO: AliPHOSGetter::Post Der -> Task " << digitsName.Data() << " already exists" << endl ;
 324         return ;
 325       } else
 326         phos->Add(digitizer) ;
 327     }
 328
 329   } else if ( strcmp(opt, "R") == 0 ) { // RecPoints
 330     // the hierarchy is //YSALICE/WhiteBoard/RecPoints/PHOS/emc/recpointsname
 331     //                  //YSALICE/WhiteBoard/RecPoints/PHOS/cpv/recpointsname
 332     TObjArray * emcrp  = new TObjArray(100) ;
 333     TObjArray * cpvrp  = new TObjArray(100) ;
 334     TString recpointsName ;
 335     if (name)
 336       recpointsName = name ;
 337     else
 338       recpointsName = "RecPoints" ;
 339     emcrp->SetName( recpointsName.Data() ) ;
 340     cpvrp->SetName( recpointsName.Data() ) ;
 341     TFolder * emcrpF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/emc") ;
 342     TFolder * cpvrpF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/cpv") ;
 343     emcrpF->SetTitle(foldertitle) ;
 344     cpvrpF->SetTitle(foldertitle) ;
 345     if ( !emcrpF || !cpvrpF ) {
 346       cerr << "ERROR: AliPHOSGetter::Post R -> Folder WhiteBoard/RecPoints/PHOS/emc(cpv)" << " not found!" << endl;
 347       abort() ;
 348     }
 349     // TString title("PHOS Digits") ;
 350     if ( emcrpF->FindObject( recpointsName.Data() ) ||  cpvrpF->FindObject( recpointsName.Data() ) ) {
 351       cerr <<"INFO: AliPHOSGetter::Post R -> Object " << recpointsName.Data()
 352            << " already exists!" << endl ;
 353       return ;
 354     }
 355     else {
 356       emcrpF->Add(emcrp) ;
 357       cpvrpF->Add(cpvrp) ;
 358     }
 359
 360   } else if ( strcmp(opt, "Rer") == 0 ) { // clusterizer
 361     // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recpointsname
 362     AliPHOSClusterizer * clusterizer;
 363     if ( strstr(name, "clu-v1") != 0 )
 364          clusterizer = new AliPHOSClusterizerv1() ;
 365     else {
 366       cerr << "ERROR: AliPHOSGetter::Post Rer -> " << name << " unknown clusterizer version" << endl ;
 367       abort() ;
 368     }
 369     TString recpointsName ;
 370     if (name)
 371       recpointsName = name ;
 372     else
 373       recpointsName = "Clusterizer" ;
 374     clusterizer->SetName( recpointsName.Data() ) ;
 375     TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ;
 376     if ( !reF ) {
 377       cerr << "ERROR: AliPHOSGetter::Post Rer -> Task tasks/Reconstructioner" << " not found!" << endl;
 378       abort() ;
 379     }
 380     TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 381     if ( !phos )  {
 382       cerr <<"ERROR: AliPHOSGetter::Post Rer -> tasks/Reconstructioner/PHOS" << " not found!" << endl;
 383       abort() ;
 384     } else {
 385        AliPHOSClusterizer * phoscl = (AliPHOSClusterizer*)phos->GetListOfTasks()->FindObject(recpointsName.Data()) ;
 386       if (phoscl) {
 387         cout << "INFO: AliPHOSGetter::Post Rer -> Task " << recpointsName.Data() << " already exists" << endl ;
 388         return ;
 389       } else
 390         phos->Add(clusterizer) ;
 391     }
 392
 393   } else if ( strcmp(opt, "T") == 0 ) { //TrackSegments
 394     // the hierarchy is //YSALICE/WhiteBoard/TrackSegments/PHOS/tracksegmentsname
 395
 396     TClonesArray * tracksegments  = new TClonesArray("AliPHOSTrackSegment", 200) ;
 397     TString tracksegmentsName ;
 398     if (name)
 399       tracksegmentsName = name ;
 400     else
 401       tracksegmentsName = "TrackSegments" ;
 402     tracksegments->SetName( tracksegmentsName.Data() ) ;
 403     TFolder * tracksegmentsF  = (TFolder*)aliceF->FindObject("WhiteBoard/TrackSegments/PHOS") ;
 404     tracksegmentsF->SetTitle(foldertitle) ;
 405     if ( !tracksegmentsF) {
 406       cerr << "ERROR: AliPHOSGetter::Post T -> Folder WhiteBoard/TrackSegments/PHOS" << " not found!" << endl;
 407       abort() ;
 408     }
 409     if ( tracksegmentsF->FindObject( tracksegmentsName.Data() ) ) {
 410       cerr <<"INFO: AliPHOSGetter::Post T -> Object " << tracksegmentsName.Data()
 411            << " already exists!" << endl ;
 412       return ;
 413     }
 414     else
 415       tracksegmentsF->Add(tracksegments) ;
 416
 417   } else if ( strcmp(opt, "Ter") == 0 ) { // TrackSegmentsMaker
 418     // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/tracksegmentsname
 419     AliPHOSTrackSegmentMaker * tracksegmentmaker ;
 420     if ( strstr(name, "tsm-v1") != 0 )
 421          tracksegmentmaker = new AliPHOSTrackSegmentMakerv1() ;
 422     else {
 423       cerr << "ERROR: AliPHOSGetter::Post Ter -> " << name << " unknown track segment maker version" << endl ;
 424       abort() ;
 425     }
 426     TString tracksegmentsName ;
 427     if (name)
 428       tracksegmentsName = name ;
 429     else
 430       tracksegmentsName = "TrackSegmentMaker" ;
 431     tracksegmentmaker->SetName( tracksegmentsName.Data() ) ;
 432     TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ;
 433     if ( !reF ) {
 434       cerr << "ERROR: AliPHOSGetter::Post Ter -> Task tasks/Reconstructioner" << " not found!" << endl;
 435       abort() ;
 436     }
 437     TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 438     if ( !phos )  {
 439       cerr <<"ERROR: AliPHOSGetter::Post Ter -> tasks/Reconstructioner/PHOS" << " not found!" << endl;
 440       abort() ;
 441     } else {
 442        AliPHOSTrackSegmentMaker * phosts = (AliPHOSTrackSegmentMaker*)phos->GetListOfTasks()->FindObject(tracksegmentsName.Data()) ;
 443       if (phosts) {
 444         cout << "INFO: AliPHOSGetter::Post Ter -> Task " << tracksegmentsName.Data() << " already exists" << endl ;
 445         return ;
 446       } else
 447         phos->Add(tracksegmentmaker) ;
 448     }
 449
 450   } else if ( strcmp(opt, "P") == 0 ) { // RecParticles
 451     // the hierarchy is //YSALICE/WhiteBoard/RecParticles/PHOS/recparticlesname
 452
 453     TClonesArray * recparticles  = new TClonesArray("AliPHOSRecParticle", 200) ;
 454     TString recparticlesName ;
 455     if (name)
 456       recparticlesName = name ;
 457     else
 458       recparticlesName = "RecParticles" ;
 459     recparticles->SetName( recparticlesName.Data() ) ;
 460     TFolder * recparticlesF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecParticles/PHOS") ;
 461     recparticlesF->SetTitle(foldertitle) ;
 462     if ( !recparticlesF) {
 463       cerr << "ERROR: AliPHOSGetter::Post P -> Folder WhiteBoard/RecParticles/PHOS" << " not found!" << endl;
 464       abort() ;
 465     }
 466     if ( recparticlesF->FindObject( recparticlesName.Data() ) ) {
 467       cerr <<"INFO: AliPHOSGetter::Post P -> Object " << recparticlesName.Data()
 468            << " already exists!" << endl ;
 469       return ;
 470     }
 471     else
 472       recparticlesF->Add(recparticles) ;
 473
 474   } else if ( strcmp(opt, "Per") == 0 ) { // PID Maker
 475     // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recparticlesname
 476     AliPHOSPID * pid ;
 477     if ( strstr(name, "pid-v1") != 0 )
 478          pid = new AliPHOSPIDv1() ;
 479     else {
 480       cerr << "ERROR: AliPHOSGetter::Post Per -> " << name << " unknown PID maker version" << endl ;
 481       abort() ;
 482     }
 483     TString recparticlesName ;
 484     if (name)
 485       recparticlesName = name ;
 486     else
 487       recparticlesName = "PID" ;
 488     pid->SetName( recparticlesName.Data() ) ;
 489     TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ;
 490     if ( !reF ) {
 491       cerr << "ERROR: AliPHOSGetter::Post Per -> Task tasks/Reconstructioner" << " not found!" << endl;
 492       abort() ;
 493     }
 494     TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;
 495     if ( !phos )  {
 496       cerr <<"ERROR: AliPHOSGetter::Post Per -> tasks/Reconstructioner/PHOS" << " not found!" << endl;
 497       abort() ;
 498     } else {
 499        AliPHOSPID * phospid = (AliPHOSPID*)phos->GetListOfTasks()->FindObject(recparticlesName.Data()) ;
 500       if (phospid) {
 501         cout << "INFO: AliPHOSGetter::Post Per -> Task " << recparticlesName.Data() << " already exists" << endl ;
 502         return ;
 503       } else
 504         phos->Add(pid) ;
 505     }
 506   }
 507   else if ( strcmp(opt, "QA") == 0 ) { // Alarms
 508     // the hierarchy is //YSALICE/WhiteBoard/Alarms/PHOS/
 509
 510     TFolder * alarmsF  = new TFolder() ;
 511     TString alarmsName ;
 512     if (name)
 513       alarmsName = name ;
 514     else
 515       alarmsName = "Alarm with no name" ;
 516     alarmsF->SetName( alarmsName.Data() ) ;
 517     alarmsF->SetTitle(foldertitle) ;
 518     TFolder * qaaF  = (TFolder*)aliceF->FindObject("WhiteBoard/QAAlarms") ;
 519     if ( !qaaF) {
 520       cerr << "ERROR: AliPHOSGetter::Post QA -> Folder WhiteBoard/QAAlarms/" << " not found!" << endl;
 521       return ;
 522     }
 523     if ( qaaF->FindObject( alarmsName.Data() ) )
 524       qaaF->RecursiveRemove(  qaaF->FindObject( alarmsName.Data() ) ) ;
 525
 526     qaaF->Add(alarmsF) ;
 527
 528   }
 529 }
 530
 531 //____________________________________________________________________________
 532 const TParticle * AliPHOSGetter::Primary(Int_t index) const
 533 {
 534   // Return primary particle numbered by <index>
 535
 536   if(index < 0)
 537     return 0 ;
 538
 539   Int_t primaryIndex = index % 10000000 ;
 540   Int_t primaryList = (Int_t ) ((index-primaryIndex)/10000000.)  ;
 541
 542   if ( primaryList > 0  ) {
 543     cout << " Getter does not support currently Mixing of primary " << endl ;
 544     cout << "   can not return primary: " << index<< " (list "<< primaryList<< " primary # " << primaryIndex << " )"<<endl ;
 545     return 0;
 546   }
 547
 548   return gAlice->Particle(primaryIndex) ;
 549
 550 }
 551
 552 //____________________________________________________________________________
 553 void AliPHOSGetter::ReadTreeD()
 554 {
 555   // Read the digit tree gAlice->TreeD()
 556   if(gAlice->TreeD()== 0){
 557     cerr <<   "ERROR: AliPHOSGetter::ReadTreeD: can not read TreeD " << endl ;
 558   return ;
 559   }
 560
 561   TObjArray * lob = (TObjArray*)gAlice->TreeD()->GetListOfBranches() ;
 562   TIter next(lob) ;
 563   TBranch * branch = 0 ;
 564   TBranch * digitsbranch = 0 ;
 565   TBranch * digitizerbranch = 0 ;
 566   Bool_t phosfound = kFALSE, digitizerfound = kFALSE ;
 567
 568   while ( (branch = (TBranch*)next()) && (!phosfound || !digitizerfound) ) {
 569     if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
 570       digitsbranch = branch ;
 571       phosfound = kTRUE ;
 572     }
 573     else if ( (strcmp(branch->GetName(), "AliPHOSDigitizer")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
 574       digitizerbranch = branch ;
 575       digitizerfound = kTRUE ;
 576     }
 577   }
 578
 579   if ( !phosfound || !digitizerfound ) {
 580     cerr << "WARNING: AliPHOSGetter::ReadTreeD -> Cannot find Digits and/or Digitizer with name " << fDigitsTitle << endl ;
 581     return ;
 582   }
 583
 584
 585  // Post the Digits
 586   Post(fHeaderFile, "D", fDigitsTitle) ;
 587
 588    // Post the Digitizer
 589   Post(fHeaderFile, "Der", fDigitsTitle) ;
 590
 591   TClonesArray * digits = Digits(fDigitsTitle) ;
 592   digits->Clear() ;
 593   digitsbranch   ->SetAddress(&digits) ;
 594
 595   AliPHOSDigitizer * digitizer = Digitizer(fDigitsTitle) ;
 596   digitizerbranch->SetAddress(&digitizer) ;
 597
 598   digitsbranch   ->GetEntry(0) ;
 599   digitizerbranch->GetEntry(0) ;
 600
 601 }
 602
 603 //____________________________________________________________________________
 604 void AliPHOSGetter::ReadTreeH()
 605 {
 606   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
 607
 608   if(gAlice->TreeH()== 0){
 609     cerr <<   "ERROR: AliPHOSGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
 610     return ;
 611   }
 612
 613   TBranch * hitsbranch = (TBranch*)gAlice->TreeH()->GetListOfBranches()->FindObject("PHOS") ;
 614   if ( !hitsbranch ) {
 615     cerr << "WARNING:  AliPHOSGetter::ReadTreeH -> Cannot find branch PHOS" << endl ;
 616   } else {
 617     TClonesArray * hits = Hits() ;
 618     hits->Clear() ;
 619     hitsbranch->SetAddress(&hits) ;
 620     hitsbranch->GetEntry(0) ;
 621   }
 622 }
 623
 624 //____________________________________________________________________________
 625 void AliPHOSGetter::ReadTreeQA()
 626 {
 627   // Read the digit tree gAlice->TreeQA()
 628   // so far only PHOS knows about this Tree
 629
 630   if(PHOS()->TreeQA()== 0){
 631     cerr <<   "ERROR: AliPHOSGetter::ReadTreeQA: can not read TreeQA " << endl ;
 632     return ;
 633   }
 634
 635   TBranch * qabranch = PHOS()->TreeQA()->GetBranch("PHOS") ;
 636   if (!qabranch) {
 637     cerr << "WARNING: AliPHOSGetter::ReadTreeQA -> Cannot find QA Alarms for PHOS" << endl ;
 638     return ;
 639   }
 640
 641  // Post the QA Alarms
 642   Post(fHeaderFile, "QA", "PHOS") ;
 643   TFolder * alarmsF = Alarms() ;
 644   alarmsF->Clear() ;
 645   qabranch->SetAddress(&alarmsF) ;
 646   qabranch->GetEntry(0) ;
 647
 648 }
 649
 650 //____________________________________________________________________________
 651 void AliPHOSGetter::ReadTreeR()
 652 {
 653   // Read the reconstrunction tree gAlice->TreeR()
 654
 655   if(gAlice->TreeR()== 0){
 656     cout <<   "ERROR: AliPHOSGetter::ReadTreeR: can not read TreeR " << endl ;
 657    return ;
 658   }
 659   // RecPoints
 660   TObjArray * lob = (TObjArray*)gAlice->TreeR()->GetListOfBranches() ;
 661   TIter next(lob) ;
 662   TBranch * branch = 0 ;
 663   TBranch * emcbranch = 0 ;
 664   TBranch * cpvbranch = 0 ;
 665   TBranch * clusterizerbranch = 0 ;
 666   Bool_t phosemcrpfound = kFALSE, phoscpvrpfound = kFALSE, clusterizerfound = kFALSE ;
 667
 668   while ( (branch = (TBranch*)next()) && (!phosemcrpfound || !phoscpvrpfound || !clusterizerfound) ) {
 669     if ( (strcmp(branch->GetName(), "PHOSEmcRP")==0) && (strcmp(branch->GetTitle(), fRecPointsTitle)==0) ) {
 670       emcbranch = branch ;
 671       phosemcrpfound = kTRUE ;
 672     }
 673     else if ( (strcmp(branch->GetName(), "PHOSCpvRP")==0) && (strcmp(branch->GetTitle(), fRecPointsTitle)==0) ) {
 674       cpvbranch = branch ;
 675       phoscpvrpfound = kTRUE ;
 676     }
 677     else if ( (strcmp(branch->GetName(), "AliPHOSClusterizer")==0) && (strcmp(branch->GetTitle(), fRecPointsTitle)==0) ) {
 678       clusterizerbranch = branch ;
 679       clusterizerfound = kTRUE ;
 680     }
 681   }
 682
 683   if ( !phosemcrpfound || !phoscpvrpfound || !clusterizerfound ) {
 684     cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find RecPoints and/or Clusterizer with name " << fRecPointsTitle << endl ;
 685     return ;
 686   }
 687
 688  // Post the RecPoints
 689   Post(fHeaderFile, "R", fRecPointsTitle) ;
 690
 691   // Post the Clusterizer
 692   //  Need the version first
 693   AliPHOSClusterizer * clusterizer = 0 ;
 694   clusterizerbranch->SetAddress(&clusterizer) ;
 695   clusterizerbranch->GetEntry(0) ;
 696   TString clusterizerName(fRecPointsTitle) ;
 697   clusterizerName.Append(clusterizer->Version()) ;
 698   delete clusterizer ;
 699   Post(fHeaderFile, "Rer", clusterizerName) ;
 700
 701   TObjArray * emcRecPoints = EmcRecPoints(fRecPointsTitle) ;
 702   emcRecPoints->Clear() ;
 703   emcbranch->SetAddress(&emcRecPoints) ;
 704
 705   TObjArray * cpvRecPoints = CpvRecPoints(fRecPointsTitle) ;
 706   cpvRecPoints->Clear() ;
 707   cpvbranch->SetAddress(&cpvRecPoints) ;
 708
 709   clusterizer = Clusterizer(clusterizerName) ;
 710   clusterizerbranch->SetAddress(&clusterizer) ;
 711
 712   emcbranch        ->GetEntry(0) ;
 713   cpvbranch        ->GetEntry(0) ;
 714   clusterizerbranch->GetEntry(0) ;
 715
 716   // TrackSegments
 717   next.Reset() ;
 718   TBranch * tsbranch = 0 ;
 719   TBranch * tsmakerbranch = 0 ;
 720   Bool_t phostsfound = kFALSE, tsmakerfound = kFALSE ;
 721
 722   while ( (branch = (TBranch*)next()) && (!phostsfound || !tsmakerfound) ) {
 723     if ( (strcmp(branch->GetName(), "PHOSTS")==0) && (strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0) ) {
 724       tsbranch = branch ;
 725       phostsfound = kTRUE ;
 726     }
 727     else if ( (strcmp(branch->GetName(), "AliPHOSTrackSegmentMaker")==0) && (strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0) ) {
 728       tsmakerbranch = branch ;
 729       tsmakerfound  = kTRUE ;
 730     }
 731   }
 732
 733   if ( !phostsfound || !tsmakerfound ) {
 734     cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find TrackSegments and/or TrackSegmentMaker with name " << fTrackSegmentsTitle << endl ;
 735     return ;
 736   }
 737
 738  // Post the TrackSegments
 739   Post(fHeaderFile, "T", fTrackSegmentsTitle) ;
 740
 741   // Post the TrackSegment Maker
 742   //  Need the version first
 743   AliPHOSTrackSegmentMaker * tsmaker = 0 ;
 744   tsmakerbranch->SetAddress(&tsmaker) ;
 745   tsmakerbranch->GetEntry(0) ;
 746   TString tsmakerName(fTrackSegmentsTitle) ;
 747   tsmakerName.Append(tsmaker->Version()) ;
 748   delete tsmaker ;
 749   Post(fHeaderFile, "Ter", tsmakerName) ;
 750
 751   TClonesArray * tracksegments = TrackSegments(fTrackSegmentsTitle) ;
 752   tracksegments->Clear() ;
 753   tsbranch->SetAddress(&tracksegments) ;
 754
 755   tsmaker = TrackSegmentMaker(tsmakerName) ;
 756   tsmakerbranch->SetAddress(&tsmaker) ;
 757
 758   tsmakerbranch    ->GetEntry(0) ;
 759   tsbranch         ->GetEntry(0) ;
 760
 761   // RecParticles
 762   next.Reset() ;
 763   TBranch * rpabranch = 0 ;
 764   TBranch * pidbranch = 0 ;
 765   Bool_t phosrpafound = kFALSE, pidfound = kFALSE ;
 766
 767   while ( (branch = (TBranch*)next()) && (!phosrpafound || !pidfound) ) {
 768     if ( (strcmp(branch->GetName(), "PHOSRP")==0) && (strcmp(branch->GetTitle(), fRecParticlesTitle)==0) ) {
 769       rpabranch = branch ;
 770       phosrpafound = kTRUE ;
 771     }
 772     else if ( (strcmp(branch->GetName(), "AliPHOSPID")==0) && (strcmp(branch->GetTitle(), fRecParticlesTitle)==0) ) {
 773       pidbranch = branch ;
 774       pidfound  = kTRUE ;
 775     }
 776   }
 777
 778   if ( !phosrpafound || !pidfound ) {
 779     cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find RecParticles and/or PID with name " << fRecParticlesTitle << endl ;
 780     return ;
 781   }
 782
 783   // Post the RecParticles
 784   Post(fHeaderFile, "P", fRecParticlesTitle) ;
 785
 786   // Post the PID
 787   //  Need the version first
 788   AliPHOSPID * pid = 0 ;
 789   pidbranch->SetAddress(&pid) ;
 790   pidbranch->GetEntry(0) ;
 791   TString pidName(fRecParticlesTitle) ;
 792   pidName.Append(pid->Version()) ;
 793   delete pid ;
 794
 795   Post(fHeaderFile, "Per", pidName) ;
 796
 797   TClonesArray * recParticles = RecParticles(fRecParticlesTitle) ;
 798   recParticles->Clear() ;
 799   rpabranch->SetAddress(&recParticles) ;
 800
 801   pid = PID(pidName) ;
 802   pidbranch->SetAddress(&pid) ;
 803
 804   pidbranch        ->GetEntry(0) ;
 805   rpabranch        ->GetEntry(0) ;
 806
 807 }
 808
 809 //____________________________________________________________________________
 810 void AliPHOSGetter::ReadTreeS()
 811 {
 812   // Read the summable digits tree gAlice->TreeS()
 813
 814   if(gAlice->TreeS()== 0){
 815     cerr <<   "ERROR: AliPHOSGetter::ReadTreeS -> Cannot find TreeS " << endl ;
 816     return ;
 817   }
 818
 819   TObjArray * lob = (TObjArray*)gAlice->TreeS()->GetListOfBranches() ;
 820   TIter next(lob) ;
 821   TBranch * branch = 0 ;
 822   TBranch * sdigitsbranch = 0 ;
 823   TBranch * sdigitizerbranch = 0 ;
 824   Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ;
 825
 826   while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
 827     if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
 828       sdigitsbranch = branch ;
 829       phosfound = kTRUE ;
 830     }
 831     else if ( (strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
 832       sdigitizerbranch = branch ;
 833       sdigitizerfound = kTRUE ;
 834     }
 835   }
 836
 837   if ( !phosfound || !sdigitizerfound ) {
 838     cerr << "WARNING: AliPHOSGetter::ReadTreeS -> Cannot find SDigits and/or SDigitizer with name " << fSDigitsTitle << endl ;
 839     return ;
 840   }
 841
 842   // -- the SDigits
 843   Post(fHeaderFile, "S", fSDigitsTitle) ;
 844
 845   // Post the SDigitizer
 846   Post(fHeaderFile, "Ser", fSDigitsTitle) ;
 847
 848   TClonesArray * sdigits = SDigits(fSDigitsTitle) ;
 849   sdigits->Clear() ;
 850   sdigitsbranch->SetAddress(&sdigits) ;
 851
 852   AliPHOSSDigitizer * sdigitizer = SDigitizer(fSDigitsTitle) ;
 853   sdigitizerbranch->SetAddress(&sdigitizer) ;
 854
 855   sdigitsbranch->GetEvent(0) ;
 856   sdigitizerbranch->GetEvent(0) ;
 857
 858 }
 859
 860 //____________________________________________________________________________
 861 void AliPHOSGetter::ReadPrimaries()
 862 {
 863   // Reads specific branches of primaries
 864
 865   fNPrimaries = gAlice->GetNtrack();
 866
 867   //   //Check, is it necessary to open new files
 868   //   TArrayI* events = fDigitizer->GetCurrentEvents() ;
 869   //   TClonesArray * filenames = fDigitizer->GetHeadersFiles() ;
 870 //   Int_t input ;
 871 //   for(input = 0; input < filenames->GetEntriesFast(); input++){
 872
 873 //     TObjString * filename = (TObjString *) filenames->At(input) ;
 874
 875 //     //Test, if this file already open
 876 //     TFile *file = (TFile*) gROOT->GetFile( filename->GetString() ) ;
 877 //     if(file == 0)
 878 //       file = new TFile( filename->GetString()) ;
 879 //     file->cd() ;
 880
 881 //     // Get Kine Tree from file
 882 // //     char treeName[20];
 883 // //     sprintf(treeName,"TreeK%d",events->At(input));
 884 // //     TTree * treeK = (TTree*)gDirectory->Get(treeName);
 885 // //     if (treeK)
 886 // //       treeK->SetBranchAddress("Particles", &fParticleBuffer);
 887 // //     else
 888 // //       cout << "AliPHOSGetter: cannot find Kine Tree for event:" << events->At(input) << endl;
 889
 890 // //     // Create the particle stack
 891 // //     if(!fParticles) fParticles = new TClonesArray("TParticle",1000);
 892 // //     // Build the pointer list
 893 // //     if(fParticleMap) {     <----
 894 // //       fParticleMap->Clear();
 895 // //       fParticleMap->Expand(treeK->GetEntries());
 896 // //     } else
 897 // //       fParticleMap = new TObjArray(treeK->GetEntries());
 898
 899 //     // From gAlice->Particle(i)
 900
 901
 902 // //   if(!(*fParticleMap)[i]) {
 903 // //     Int_t nentries = fParticles->GetEntries();
 904
 905 // //     // algorithmic way of getting entry index
 906 // //     // (primary particles are filled after secondaries)
 907 // //     Int_t entry;
 908 // //     if (i<fHeader.GetNprimary())
 909 // //       entry = i+fHeader.GetNsecondary();
 910 // //     else
 911 // //       entry = i-fHeader.GetNprimary();
 912
 913 // //     // only check the algorithmic way and give
 914 // //     // the fatal error if it is wrong
 915 // //     if (entry != fParticleFileMap[i]) {
 916 // //       Fatal("Particle",
 917 // //         "!!!! The algorithmic way is WRONG: !!!\n entry: %d map: %d",
 918 // //   entry, fParticleFileMap[i]);
 919 // //     }
 920
 921 // //     fTreeK->GetEntry(fParticleFileMap[i]);
 922 // //     new ((*fParticles)[nentries]) TParticle(*fParticleBuffer);
 923 // //     fParticleMap->AddAt((*fParticles)[nentries],i);
 924 // //   }
 925 // //   return (TParticle *) (*fParticleMap)[i];
 926
 927
 928
 929 //   }
 930
 931
 932 //   //scan over opened files and read corresponding TreeK##
 933
 934   return ;
 935 }
 936 //____________________________________________________________________________
 937 void AliPHOSGetter::Event(Int_t event)
 938 {
 939   // Reads the content of all Tree's S, D and R
 940
 941   if ( event > gAlice->TreeE()->GetEntries() ) {
 942     cerr << "ERROR: AliPHOSGetter::Event -> There are only " << gAlice->TreeE()->GetEntries() << " events in this file" << endl ;
 943     return ;
 944   }
 945
 946   gAlice->GetEvent(event) ;
 947
 948   ReadTreeH() ;
 949   ReadTreeS() ;
 950   ReadTreeD() ;
 951   ReadTreeR() ;
 952   ReadTreeQA() ;
 953   ReadPrimaries() ;
 954
 955 }
 956
 957 //____________________________________________________________________________
 958 const TObject * AliPHOSGetter::ReturnO(TString what, TString name, TString file) const
 959 {
 960   // get the object named "what" from the folder
 961   // folders are named like //YSAlice/WhiteBoard/what/PHOS/name
 962
 963   if ( file.IsNull() )
 964     file = fHeaderFile ;
 965   TString path("WhiteBoard/") ;
 966   if ( name.IsNull() ) {
 967     if ( what.CompareTo("Hits") == 0 ) {
 968       path += what ;
 969       path += "/PHOS/";
 970       path += what ;
 971     }
 972     else if ( what.CompareTo("SDigits") == 0 ) {
 973       path += what ;
 974       path += "/PHOS/";
 975       path += file ;
 976       path += "/" ;
 977       path += fSDigitsTitle ;
 978     }
 979     else if ( what.CompareTo("Digits") == 0 ){
 980       path += what ;
 981       path += "/PHOS/";
 982       path += fDigitsTitle ;
 983     }
 984     else if ( what.CompareTo("EmcRecPoints") == 0 ) {
 985       path += "RecPoints/PHOS/";
 986       path += "emc/" ;
 987       path += fRecPointsTitle ;
 988     }
 989     else if ( what.CompareTo("CpvRecPoints") == 0 ) {
 990       path += "RecPoints/PHOS/";
 991       path += "cpv/" ;
 992       path += fRecPointsTitle ;
 993     }
 994     else if ( what.CompareTo("TrackSegments") == 0 ) {
 995       path += "TrackSegments/PHOS/";
 996       path += fTrackSegmentsTitle ;
 997     }
 998     else if ( what.CompareTo("RecParticles") == 0 ) {
 999       path += "RecParticles/PHOS/";
1000       path += fRecParticlesTitle ;
1001     }
1002      else if ( what.CompareTo("Alarms") == 0 ) {
1003       path += "QAAlarms/PHOS";
1004     }
1005   }
1006   else {
1007     if ( what.CompareTo("SDigits") == 0 ) {
1008       path += what ;
1009       path += "/PHOS/";
1010       path += file ;
1011       path += "/" ;
1012       path += name ;
1013     }
1014     else if ( what.CompareTo("Digits") == 0 ) {
1015       path += what ;
1016       path += "/PHOS/";
1017       path += name ;
1018     }
1019     else if ( what.CompareTo("EmcRecPoints") == 0 ) {
1020       path += "RecPoints/PHOS/";
1021       path += "emc/" ;
1022       path += name ;
1023     }
1024     else if ( what.CompareTo("CpvRecPoints") == 0 ) {
1025       path += "RecPoints/PHOS/";
1026       path += "cpv/" ;
1027       path += name ;
1028     }
1029     else if ( what.CompareTo("TrackSegments") == 0 ) {
1030       path += "TrackSegments/PHOS/";
1031       path += name ;
1032     }
1033     else if ( what.CompareTo("RecParticles") == 0 ) {
1034       path += "RecParticles/PHOS/";
1035       path += name ;
1036     }
1037     else if ( what.CompareTo("Alarms") == 0 ) {
1038       path += "QAAlarms/PHOS/";
1039       path += name ;
1040     }
1041   }
1042   path.Prepend("YSAlice/") ;
1043   TObject * phosO  = (TObject*)gROOT->FindObjectAny(path) ;
1044   if (!phosO) {
1045     cerr << "ERROR : AliPHOSGetter::ReturnO -> Object " << path << " not found!" << endl ;
1046     abort() ;
1047   }
1048   return phosO ;
1049 }
1050
1051 //____________________________________________________________________________
1052 const TTask * AliPHOSGetter::ReturnT(TString what, TString name) const
1053 {
1054   // get the TTask named "what" from the folder
1055   // folders are named like //YSAlice/Tasks/what/PHOS/name
1056
1057   TString path("tasks") ;
1058
1059   if ( what.CompareTo("SDigitizer") == 0 )
1060     path += "/SDigitizer" ;
1061   else if ( what.CompareTo("Digitizer") == 0 )
1062     path += "/Digitizer" ;
1063   else if ( what.CompareTo("Clusterizer") == 0 )
1064     path += "/Reconstructioner" ;
1065   else if ( what.CompareTo("TrackSegmentMaker") == 0 )
1066     path += "/Reconstructioner" ;
1067   else if ( what.CompareTo("PID") == 0 )
1068     path += "/Reconstructioner" ;
1069   else if ( what.CompareTo("QATasks") == 0 )
1070     path += "/QA" ;
1071
1072   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ;
1073   TTask * aliceT  = (TTask*)aliceF->FindObject(path) ;
1074
1075   if (!aliceT) {
1076     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << " not found!" << endl ;
1077     abort() ;
1078   }
1079
1080   TTask * phosT = (TTask*)aliceT->GetListOfTasks()->FindObject("PHOS") ;
1081   if (!phosT) {
1082     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << "/PHOS not found!" << endl ;
1083     abort() ;
1084   }
1085   TList * l = phosT->GetListOfTasks() ;
1086
1087   if (what.CompareTo("SDigitizer") == 0) {
1088     if ( name.IsNull() )
1089       name =  fSDigitsTitle ;
1090   } else  if (what.CompareTo("Digitizer") == 0){
1091     if ( name.IsNull() )
1092       name =  fDigitsTitle ;
1093   } else  if (what.CompareTo("Clusterizer") == 0){
1094     if ( name.IsNull() )
1095       name =  fRecPointsTitle ;
1096   }
1097   else  if (what.CompareTo("TrackSegmentMaker") == 0){
1098     if ( name.IsNull() )
1099       name =  fTrackSegmentsTitle ;
1100   }
1101   else  if (what.CompareTo("PID") == 0){
1102     if ( name.IsNull() )
1103       name =  fRecParticlesTitle ;
1104   }
1105     else  if (what.CompareTo("QATasks") == 0){
1106     if ( name.IsNull() )
1107       return phosT ;
1108   }
1109
1110   TTask * task = (TTask*)l->FindObject(name) ;
1111
1112   if (!task)
1113     cout << "WARNING: AliPHOSGetter::ReturnT -> Task " << path << "/" << name << " not found!" << endl ;
1114
1115   return task ;
1116 }