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