Added a collaborative work between Getter and Tasks (Digitizer and Clustrizer) so...
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALGetter.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 AliEMCALAnalyser):
34 //  AliEMCALGetter * gime = AliEMCALGetter::GetInstance("galice.root","test") ;
35 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
36 //     AliEMCALRecParticle * 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 AliEMCALIndexToObject 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 "AliConfig.h"
63 #include "AliEMCALGetter.h"
64 #include "AliEMCALHit.h"
65 #include "AliEMCALv1.h"
66 #include "AliEMCALDigitizer.h"
67 #include "AliEMCALSDigitizer.h"
68 #include "AliEMCALClusterizer.h"
69 #include "AliEMCALClusterizerv1.h"
70 //#include "AliEMCALTrackSegmentMaker.h"
71 //#include "AliEMCALTrackSegmentMakerv1.h"
72 //#include "AliEMCALTrackSegment.h"
73 //#include "AliEMCALPID.h" 
74 //#include "AliEMCALPIDv1.h" 
75 #include "AliEMCALGeometry.h"
76
77 ClassImp(AliEMCALGetter)
78   
79   AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ; 
80   TFile * AliEMCALGetter::fFile = 0 ; 
81
82 //____________________________________________________________________________ 
83 AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* branchTitle, const Option_t * rw)
84 {
85   //Initialize  all lists
86
87   fDebug = 0 ; 
88   
89   fAlice = 0 ; 
90  
91   fHeaderFile         = headerFile ; 
92   fBranchTitle        = branchTitle ;
93   fSDigitsTitle       = branchTitle ; 
94   fDigitsTitle        = branchTitle ; 
95   fRecPointsTitle     = branchTitle ; 
96   //fRecParticlesTitle  = branchTitle ; 
97   //fTrackSegmentsTitle = branchTitle ; 
98
99   fPrimaries = new TObjArray(1) ;
100
101   fModuleFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Configuration/Modules")); 
102   fPrimariesFolder = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data")); 
103   fHitsFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/Hits")); 
104   fSDigitsFolder   = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/SDigits")); 
105   fDigitsFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/Data")); 
106   fRecoFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/RecData")); 
107   //fQAFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Conditions/QA")); 
108   fTasksFolder     = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Tasks")) ; 
109
110   fFailed = kFALSE ; 
111                    
112   if ( fHeaderFile != "aliroot"  ) { // to call the getter without a file
113
114     //open headers file
115     fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
116     if(!fFile){    //if file was not opened yet, read gAlice
117       if ( fHeaderFile.Contains("_") ) {
118         cerr << "AliPHOSGetter::AliPHOSGetter -> Invalid file name (_ not allowed) " << fHeaderFile.Data() << endl ;
119         abort() ; 
120       }
121       fFile =   TFile::Open(fHeaderFile.Data(),rw) ;   
122       
123       if (!fFile->IsOpen()) {
124         cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot open " << fHeaderFile.Data() << endl ; 
125         fFailed = kTRUE ;
126         return ;  
127       }
128       gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
129     }
130   }
131   
132
133   if (!gAlice) {
134     cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ; 
135     fFailed = kTRUE ;
136     return ; 
137   }
138   if (!EMCAL()) {
139     if (fDebug)
140       cout << "INFO: AliEMCALGetter -> Posting EMCAL to Folders" << endl ; 
141     if (gAlice->GetDetector("EMCAL")) {
142       AliConfig * conf = AliConfig::Instance() ;
143       conf->Add(static_cast<AliDetector*>(gAlice->GetDetector("EMCAL"))) ; 
144       conf->Add(static_cast<AliModule*>(gAlice->GetDetector("EMCAL"))) ;
145     }
146     else 
147       cerr << "ERROR: AliEMCALGetter -> detector EMCAL not found" << endl ;
148   }
149   
150   fDebug=0;
151 }
152 //____________________________________________________________________________ 
153 AliEMCALGetter::~AliEMCALGetter()
154 {
155   if (fPrimaries) {
156     fPrimaries->Delete() ; 
157     delete fPrimaries ; 
158   }
159
160   TFolder * emcalF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
161   TCollection * folderslist = emcalF->GetListOfFolders() ; 
162   TIter next(folderslist) ; 
163   TFolder * folder = 0 ; 
164   while ( (folder = static_cast<TFolder*>(next())) ) 
165     emcalF->Remove(folder) ; 
166
167   delete fFile ; 
168   fFile = 0 ;
169
170   fgObjGetter = 0 ; 
171
172 }
173
174 //____________________________________________________________________________ 
175 void AliEMCALGetter::CreateWhiteBoard() const
176 {
177
178 }
179
180 //____________________________________________________________________________ 
181 void AliEMCALGetter::CloseFile()
182 {
183   delete gAlice ; 
184   gAlice = 0 ; 
185   delete fAlice ; 
186   fAlice = 0 ; 
187 }
188
189 //____________________________________________________________________________ 
190 const TFolder * AliEMCALGetter::Folder(const TString what) const {
191
192   // returns the EMCAL folder required by what
193   // what = hits, sdigits, digits
194
195   if ( what == "hits" ) 
196     return dynamic_cast<const TFolder *>(fHitsFolder->FindObject("EMCAL")) ; 
197   else if ( what == "sdigits" ) 
198     return  dynamic_cast<const TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ; 
199   else if ( what == "digits" ) 
200     return  dynamic_cast<const TFolder *>(fDigitsFolder->FindObject("EMCAL")) ; 
201   else {
202     cerr << "ERROR: AliEMCALGetter::GetFolder -> " << what.Data() << " illegal option (hits, sdigits, digits) " << endl ; 
203     return 0 ; 
204   }
205 }
206 //____________________________________________________________________________ 
207 AliEMCALGetter * AliEMCALGetter::GetInstance()
208 {
209   // Returns the pointer of the unique instance already defined
210   
211   if ( fgObjGetter ) {
212     fFile->cd() ; 
213     return fgObjGetter ;
214   }
215   else {
216     // cout << "AliEMCALGetter::GetInstance ERROR: not yet initialized" << endl ;
217     return 0 ;
218   }
219 }
220
221 //____________________________________________________________________________ 
222 AliEMCALGetter * AliEMCALGetter::GetInstance(const char* headerFile,
223                                            const char* branchTitle, const Option_t * rw)
224 {
225   // Creates and returns the pointer of the unique instance
226   // Must be called only when the environment has changed 
227
228   if ( fgObjGetter && fFile->IsOpen()) // an instance exists and the file is still open        
229     if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0) && 
230        (fgObjGetter->fHeaderFile.CompareTo(headerFile)==0)) {
231       fFile->cd() ; 
232       return fgObjGetter ;
233     }
234     else // another file than the existing one is required, scratch the getter
235       fgObjGetter->~AliEMCALGetter() ;  // delete it already exists another version
236
237   fgObjGetter = new AliEMCALGetter(headerFile,branchTitle, rw) ; 
238
239   if (fgObjGetter->HasFailed() ) 
240     fgObjGetter = 0 ; 
241     
242   fFile->cd() ; 
243   return fgObjGetter ; 
244   
245 }
246
247 //____________________________________________________________________________ 
248 const AliEMCALv1 * AliEMCALGetter::EMCAL() 
249 {
250   // returns the EMCAL object 
251   AliEMCALv1 * emcal = dynamic_cast<AliEMCALv1*>(fModuleFolder->FindObject("EMCAL")) ;  
252   if (!emcal) 
253     if (fDebug)
254       cout << "WARNING: AliEMCALGetter::EMCAL -> EMCAL module not found in Folders" << endl ; 
255   return emcal ; 
256 }  
257
258 //____________________________________________________________________________ 
259 AliEMCALGeometry * AliEMCALGetter::EMCALGeometry() 
260 {
261   AliEMCALGeometry * rv = 0 ; 
262   if (EMCAL() )
263     rv =  EMCAL()->GetGeometry() ;
264   return rv ; 
265
266
267 //____________________________________________________________________________ 
268 Bool_t AliEMCALGetter::PostPrimaries(void) const 
269 {  //------- Primaries ----------------------
270
271   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
272   
273   TFolder * primariesFolder = dynamic_cast<TFolder*>(fPrimariesFolder->FindObject("Primaries")) ; 
274   if ( !primariesFolder ) {
275     if (fDebug) {
276       cout << "WARNING: AliEMCALGetter::Post Primaries -> Folder //" << fPrimariesFolder->GetName() << "/Primaries/ not found!" << endl;
277       cout << "INFO:    AliEMCALGetter::Post Primaries -> Adding Folder //" << fPrimariesFolder->GetName() << "/Primaries/"  << endl;
278     }
279     primariesFolder = fPrimariesFolder->AddFolder("Primaries", "Primaries particles from TreeK") ; 
280   }    
281   TClonesArray *primaries=  new TClonesArray("TParticle",1000) ;
282   primaries->SetName("Primaries") ;
283   primariesFolder->Add(primaries) ; 
284   
285   return kTRUE;
286
287
288 //____________________________________________________________________________ 
289 TObject** AliEMCALGetter::PrimariesRef(void) const 
290 {  //------- Primaries ----------------------
291
292   
293   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
294   if ( !fPrimariesFolder ) {
295     cerr << "ERROR: AliEMCALGetter::PrimariesRef -> Folder //" << fPrimariesFolder << " not found!" << endl;
296     abort() ;
297   }    
298  
299   TFolder * primariesFolder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ;
300   if ( !primariesFolder ) {
301     cerr << "ERROR: AliEMCALGetter::PrimariesRef -> Folder //" << fPrimariesFolder << "/Primaries/ not found!" << endl;  
302     abort() ;
303   }
304  
305   TObject * p = primariesFolder->FindObject("Primaries") ;
306   if(!p) {
307     cerr << "ERROR: AliEMCALGetter::PrimariesRef -> " << primariesFolder->GetName() << "/Primaries not found !" << endl ; 
308     abort() ;
309   }
310   else
311     return primariesFolder->GetListOfFolders()->GetObjectRef(p) ;
312 }
313
314 //____________________________________________________________________________ 
315 Bool_t AliEMCALGetter::PostHits(void) const 
316 {  //------- Hits ----------------------
317
318   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
319   
320   TFolder * emcalFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ; 
321   if ( !emcalFolder ) {
322     if (fDebug) {
323       cout << "WARNING: AliEMCALGetter::Post H -> Folder //" << fHitsFolder << "/EMCAL/ not found!" << endl;
324       cout << "INFO:    AliEMCALGetter::Post H -> Adding Folder //" << fHitsFolder << "/EMCAL/"  << endl;
325     }
326     emcalFolder = fHitsFolder->AddFolder("EMCAL", "Hits from EMCAL") ; 
327   }    
328   TClonesArray *hits=  new TClonesArray("AliEMCALHit",1000) ;
329   hits->SetName("Hits") ;
330   emcalFolder->Add(hits) ; 
331   
332   return kTRUE;
333
334
335 //____________________________________________________________________________ 
336 TObject ** AliEMCALGetter::HitsRef(void) const 
337 {  //------- Hits ----------------------
338
339   
340   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
341   if ( !fHitsFolder ) {
342     cerr << "ERROR: AliEMCALGetter::Post H -> Folder //" << fHitsFolder << " not found!" << endl;
343     return 0;
344   }    
345  
346   TFolder * emcalFolder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("EMCAL")) ;
347   if ( !emcalFolder ) {
348     cerr << "ERROR: AliEMCALGetter::Post HRef -> Folder //" << fHitsFolder << "/EMCAL/ not found!" << endl;  
349     return 0;
350   }
351  
352   TObject * h = emcalFolder->FindObject("Hits") ;
353   if(!h) {
354     cerr << "ERROR: AliEMCALGetter::HRef -> " << emcalFolder->GetName() << "/Hits not found !" << endl ; 
355     return 0 ;
356   }
357   else
358     return emcalFolder->GetListOfFolders()->GetObjectRef(h) ;
359 }
360
361 //____________________________________________________________________________ 
362 Bool_t AliEMCALGetter::PostSDigits(const char * name, const char * headerFile) const 
363 {  //---------- SDigits -------------------------
364
365   
366   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/headerFile/sdigitsname
367   // because you can have sdigits from several hit files for mixing
368   
369   TFolder * emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
370   if ( !emcalFolder ) {
371     if (fDebug) {
372       cout << "WARNING: AliEMCALGetter::Post S -> Folder //" << fSDigitsFolder << "/EMCAL/ not found!" << endl;
373       cout << "INFO:    AliEMCALGetter::Post S -> Adding Folder //" << fHitsFolder << "/EMCAL/" << endl;
374     }
375     emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; 
376   }    
377   TString subdir(headerFile) ;
378   subdir.ReplaceAll("/", "_") ; 
379   TFolder * emcalSubFolder = dynamic_cast<TFolder*>(emcalFolder->FindObject(subdir)) ; 
380   if ( !emcalSubFolder ) 
381     emcalSubFolder = emcalFolder->AddFolder(subdir, ""); 
382   
383   TObject * sd  = emcalSubFolder->FindObject(name); 
384   if ( sd ) {
385     if (fDebug)
386       cerr <<"INFO: AliEMCALGetter::Post S -> Folder " << subdir 
387            << " already exists!" << endl ;  
388   }else{
389     TClonesArray * sdigits = new TClonesArray("AliEMCALDigit",1) ;
390     sdigits->SetName(name) ;
391     emcalSubFolder->Add(sdigits) ;
392   }
393   
394   return kTRUE;
395
396 //____________________________________________________________________________ 
397 TObject ** AliEMCALGetter::SDigitsRef(const char * name, const char * file) const 
398 {  //------- SDigits ----------------------
399   
400   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/filename/SDigits
401
402   if ( !fSDigitsFolder ) {
403     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //" << fSDigitsFolder << " not found!" << endl;
404     return 0;
405   }    
406  
407   TFolder * emcalFolder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
408   if ( !emcalFolder ) {
409     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //" << fSDigitsFolder << "/EMCAL/ not found!" << endl;
410     return 0;
411   }
412
413   TFolder * emcalSubFolder = 0 ;
414   if(file)
415     emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(file)) ;
416   else
417     emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(fHeaderFile)) ;
418   
419   if(!emcalSubFolder) {
420     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //Folders/RunMC/Event/Data/EMCAL/" << file << "not found!" << endl;
421     return 0;
422   }
423
424   TObject * dis = emcalSubFolder->FindObject(name) ;
425   if(!dis)
426     return 0 ;
427   else
428     return emcalSubFolder->GetListOfFolders()->GetObjectRef(dis) ;
429
430 }
431
432 //____________________________________________________________________________ 
433 Bool_t AliEMCALGetter::PostSDigitizer(AliEMCALSDigitizer * sdigitizer) const 
434 {  //---------- SDigitizer -------------------------
435     
436   // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
437
438
439   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
440
441   if ( !sd ) {
442     cerr << "ERROR: AliEMCALGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
443     return kFALSE ;
444   }        
445   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
446   if ( !emcal )  {
447     if (fDebug) {
448       cout <<"WARNING: AliEMCALGetter::Post Ser ->//" << fTasksFolder << "/SDigitizer/EMCAL/ not found!" << endl;  
449       cout <<"INFO: AliEMCALGetter::Post Ser -> Adding //" << fTasksFolder << "/SDigitizer/EMCAL/" << endl;
450     }
451     emcal = new TTask("EMCAL", "") ; 
452     sd->Add(emcal) ; 
453   } 
454   AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdigitizer->GetName() )); 
455   if (emcalsd) { 
456     if (fDebug)
457       cout << "INFO: AliEMCALGetter::Post Ser -> Task " << sdigitizer->GetName() << " already exists" << endl ; 
458     emcal->GetListOfTasks()->Remove(emcalsd) ;
459   }
460   emcal->Add(sdigitizer) ;      
461   return kTRUE; 
462   
463 }
464
465 //____________________________________________________________________________ 
466 TObject ** AliEMCALGetter::SDigitizerRef(const char * name) const 
467 {  
468
469   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
470   if ( !sd ) {
471     cerr << "ERROR: AliEMCALGetter::Post SerRef -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
472     abort();
473   }        
474
475   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
476   if ( !emcal )  {
477     cerr <<"ERROR: AliEMCALGetter::Post SerRef ->  //" << fTasksFolder << "/SDigitizer/EMCAL not found!" << endl;
478     abort();
479   }        
480
481   TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ; 
482
483   return emcal->GetListOfTasks()->GetObjectRef(task) ;
484
485 }
486
487 //____________________________________________________________________________ 
488 Bool_t AliEMCALGetter::PostSDigitizer(const char * name, const char * file) const 
489 {  //---------- SDigitizer -------------------------
490   
491  // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
492
493
494   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
495   if ( !sd ) {
496     cerr << "ERROR: AliEMCALGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
497     return kFALSE ;
498   }        
499
500   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
501   if ( !emcal )  {
502     if (fDebug) {
503       cout <<"WARNING: AliEMCALGetter::Post Ser ->  //" << fTasksFolder << "/SDigitizer/EMCAL/ not found!" << endl;
504       cout <<"INFO: AliEMCALGetter::Post Ser -> Adding  //" << fTasksFolder << "/SDigitizer/EMCAL" << endl;
505     }
506     emcal = new TTask("EMCAL", "") ; 
507     sd->Add(emcal) ; 
508   } 
509
510   TString sdname(name) ;
511   sdname.Append(":") ;
512   sdname.Append(file);
513   sdname.ReplaceAll("/","_") ; 
514   AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdname )); 
515   if (!emcalsd) {
516     emcalsd = new AliEMCALSDigitizer() ;  
517     //Note, we can not call constructor with parameters: it will call Getter and screw up everething
518     emcalsd->SetName(sdname) ;
519     emcalsd->SetTitle(file) ;
520     emcal->Add(emcalsd) ;       
521   }
522   return kTRUE; 
523   
524 }
525
526 //____________________________________________________________________________ 
527 Bool_t AliEMCALGetter::PostDigits(const char * name) const 
528 {  //---------- Digits -------------------------
529
530   // the hierarchy is //Folders/Run/Event/Data/EMCAL/SDigits/name
531
532   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
533
534   if ( !emcalFolder ) {
535     if (fDebug) {
536       cout << "WARNING: AliEMCALGetter::Post D -> Folder //" << fDigitsFolder << "/EMCAL/ not found!" << endl;
537       cout << "INFO:    AliEMCALGetter::Post D -> Adding Folder //" << fDigitsFolder << "/EMCAL/" << endl;
538     }
539     emcalFolder = fDigitsFolder->AddFolder("EMCAL", "Digits from EMCAL") ;  
540   }    
541  
542   TObject*  dig = emcalFolder->FindObject( name ) ;
543   if ( !dig ) {
544     TClonesArray * digits = new TClonesArray("AliEMCALDigit",1000) ;
545     digits->SetName(name) ;
546     emcalFolder->Add(digits) ;  
547   }
548   return kTRUE; 
549 }
550
551 //____________________________________________________________________________ 
552 TObject ** AliEMCALGetter::DigitsRef(const char * name) const 
553 { //------- Digits ----------------------
554   
555   // the hierarchy is //Folders/Run/Event/Data/EMCAL/Digits/name
556
557   if ( !fDigitsFolder ) {
558     cerr << "ERROR: AliEMCALGetter::Post DRef -> Folder //" << fDigitsFolder << " not found!" << endl;
559     return 0;
560   }    
561   
562   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ; 
563   if ( !emcalFolder ) {
564     cerr << "ERROR: AliEMCALGetter::DRef -> Folder //" << fDigitsFolder << "/EMCAL/ not found!" << endl;
565     return 0;
566   }    
567
568   TObject * d = emcalFolder->FindObject(name) ;
569   if(!d)
570     return 0 ;
571   else
572     return emcalFolder->GetListOfFolders()->GetObjectRef(d) ;
573
574 }
575
576 //____________________________________________________________________________ 
577 Bool_t AliEMCALGetter::PostDigitizer(AliEMCALDigitizer * digitizer) const 
578 {  //---------- Digitizer -------------------------
579   
580   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
581
582   if ( !sd ) {
583     cerr << "ERROR: AliEMCALGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
584     return kFALSE ;
585   }        
586   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
587   if ( !emcal )  {
588     if (fDebug) {
589       cout <<"WARNING: AliEMCALGetter::Post Der ->  //" << fTasksFolder << "/Digitizer/EMCAL not found!" << endl;
590       cout <<"INFO: AliEMCALGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/EMCAL" << endl; 
591     }
592     emcal = new TTask("EMCAL", "") ; 
593     sd->Add(emcal) ; 
594   } 
595
596     AliEMCALDigitizer * emcald = dynamic_cast<AliEMCALDigitizer*>(emcal->GetListOfTasks()->FindObject(digitizer->GetName())) ; 
597     if (emcald) { 
598       emcald->Delete() ;
599       emcal->GetListOfTasks()->Remove(emcald) ;
600     }
601     emcal->Add(digitizer) ; 
602     return kTRUE; 
603 }  
604
605 //____________________________________________________________________________ 
606 Bool_t AliEMCALGetter::PostDigitizer(const char * name) const 
607 {  //---------- Digitizer -------------------------
608   
609  // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
610
611   TTask * d  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
612   if ( !d ) {
613     cerr << "ERROR: AliEMCALGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
614     return kFALSE ;
615   }        
616
617   TTask * emcal = dynamic_cast<TTask*>(d->GetListOfTasks()->FindObject("EMCAL")) ; 
618   if ( !emcal )  {
619     if (fDebug) {
620       cout <<"WARNING: AliEMCALGetter::Post Der -> //" << fTasksFolder << "/Digitizer/EMCAL not found!" << endl; 
621       cout <<"INFO: AliEMCALGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/EMCAL" << endl;
622     }
623     emcal = new TTask("EMCAL", "") ; 
624     d->Add(emcal) ; 
625
626
627   AliEMCALDigitizer * emcald = dynamic_cast<AliEMCALDigitizer*>(emcal->GetListOfTasks()->FindObject(name)) ; 
628   if (!emcald) { 
629     emcald = new AliEMCALDigitizer() ;
630     emcald->SetName(fDigitsTitle) ;
631     emcald->SetTitle(fHeaderFile) ;
632     emcal->Add(emcald) ;
633   }
634   return kTRUE;  
635 }
636
637 //____________________________________________________________________________ 
638 TObject ** AliEMCALGetter::DigitizerRef(const char * name) const 
639 {  
640   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
641   if ( !sd ) {
642     cerr << "ERROR: AliEMCALGetter::Post DerRef -> Task //" << fTasksFolder->GetName() << "/Digitizer not found!" << endl;
643     abort();
644   }        
645
646   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
647   if ( !emcal )  {
648     cerr <<"ERROR: AliEMCALGetter::Post DerRef ->  //" << fTasksFolder->GetName() << "/Digitizer/EMCAL" << endl;
649     abort();
650   }        
651
652   TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ; 
653
654   return emcal->GetListOfTasks()->GetObjectRef(task) ;
655
656 }
657  
658 //____________________________________________________________________________ 
659 Bool_t AliEMCALGetter::PostRecPoints(const char * name) const 
660 { // -------------- RecPoints -------------------------------------------
661   
662   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TowerRecPoints/name
663   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/PreShoRecPoints/name
664
665   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ; 
666   
667   if ( !emcalFolder ) {
668     if (fDebug) {
669       cout << "WARNING: AliEMCALGetter::Post RPo -> Folder //" << fRecoFolder << "/EMCAL/ not found!" << endl;
670       cout << "INFO:    AliEMCALGetter::Post Rpo -> Adding Folder //" << fRecoFolder << "/EMCAL/" << endl;
671     }
672     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;  
673   }    
674   
675   // Tower RecPoints 
676   TFolder * emcalRPoTowerFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("TowerRecPoints")) ;
677   if ( !emcalRPoTowerFolder ) {
678     if (fDebug) {
679       cout << "WARNING: AliEMCALGetter::Post RPo -> Folder //" << fRecoFolder << "/EMCAL/TowerRecPoints/ not found!" << endl;
680       cout << "INFO:    AliEMCALGetter::Post Rpo -> Adding Folder //" << fRecoFolder << "/EMCAL/TowerRecPoints not found!" << endl;
681     }
682     emcalRPoTowerFolder = emcalFolder->AddFolder("TowerRecPoints", "Tower RecPoints from EMCAL") ;  
683   }    
684   
685   TObject * erp = emcalFolder->FindObject( name ) ;
686   if ( !erp )   {
687     TObjArray * towerrp = new TObjArray(100) ;
688     towerrp->SetName(name) ;
689     emcalRPoTowerFolder->Add(towerrp) ;  
690   }
691
692   // Pre Shower RecPoints 
693   TFolder * emcalRPoPreShoFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("PreShoRecPoints")) ;
694   if ( !emcalRPoPreShoFolder ) {
695     if (fDebug) {
696       cout << "WARNING: AliEMCALGetter::Post RPo -> Folder //" << fRecoFolder << "/EMCAL/PreShoRecPoints/ not found!" << endl;
697       cout << "INFO:    AliEMCALGetter::Post Rpo -> Adding Folder //" << fRecoFolder << "/EMCAL/PreShoRecPoints/" << endl;
698     }
699     emcalRPoPreShoFolder = emcalFolder->AddFolder("PreShoRecPoints", "PreSho RecPoints from EMCAL") ;  
700   }    
701   
702   TObject * crp =  emcalRPoPreShoFolder->FindObject( name ) ;
703   if ( !crp )   {
704     TObjArray * preshorp = new TObjArray(100) ;
705     preshorp->SetName(name) ;
706     emcalRPoPreShoFolder->Add(preshorp) ;  
707   }
708   return kTRUE; 
709 }
710
711 //____________________________________________________________________________ 
712 TObject ** AliEMCALGetter::TowerRecPointsRef(const char * name) const 
713 { // -------------- RecPoints -------------------------------------------
714   
715   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TowerRecPoints/name
716    
717   if ( !fRecoFolder ) {
718     cerr << "ERROR: AliEMCALGetter::TowerRecPointsRef -> Folder //" << fRecoFolder << " not found!" << endl;
719     abort() ; 
720   }    
721
722   TFolder * towerFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TowerRecPoints")) ; 
723   if ( !towerFolder ) {
724     cerr << "ERROR: AliEMCALGetter::TowerRecPointsRef -> Folder //" << fRecoFolder << "/EMCAL/TowerRecPoints/ not found!" << endl;
725     abort() ;
726   }    
727
728
729   TObject * trp = towerFolder->FindObject(name ) ;
730   if ( !trp )   {
731     cerr << "ERROR: AliEMCALGetter::TowerRecPointsRef -> Object " << name << " not found!" << endl  ;
732     abort() ; 
733   }
734   return towerFolder->GetListOfFolders()->GetObjectRef(trp) ;
735
736
737
738 //____________________________________________________________________________ 
739 TObject ** AliEMCALGetter::PreShoRecPointsRef(const char * name) const 
740 { // -------------- RecPoints -------------------------------------------
741   
742   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/PreShoRecPoints/name
743    
744   if ( !fRecoFolder ) {
745     cerr << "ERROR: AliEMCALGetter::PreShoRecPointsRef -> Folder //" << fRecoFolder << " not found!" << endl;
746     abort() ; 
747   }    
748
749   TFolder * preshoFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/PreShoRecPoints")) ; 
750   if ( !preshoFolder ) {
751     cerr << "ERROR: AliEMCALGetter::PreShoRecPointsRef -> Folder //" << fRecoFolder << "/EMCAL/PreShoRecPoints/" << endl;
752     abort() ;
753   }    
754
755   TObject * prp = preshoFolder->FindObject(name ) ;
756   if ( !prp )   {
757     cerr << "ERROR: AliEMCALGetter::PreShoRecPointsRef -> Object " << name << " not found! " << endl ; 
758     abort() ;
759   }
760   return preshoFolder->GetListOfFolders()->GetObjectRef(prp) ;
761
762
763
764 //____________________________________________________________________________ 
765 Bool_t AliEMCALGetter::PostClusterizer(AliEMCALClusterizerv1 * clu) const 
766 { // ------------------ AliEMCALClusterizer ------------------------
767   
768   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
769
770   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
771
772   if ( !tasks ) {
773     cerr << "ERROR: AliEMCALGetter::Post Rer -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
774     return kFALSE ;
775   }        
776         
777   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
778   if ( !emcal )  {
779     if (fDebug) {
780       cout <<"WARNING: AliEMCALGetter::Post Rer -> //" << fTasksFolder << "/ReconstructionerEMCAL not found!" << endl; 
781       cout <<"INFO: AliEMCALGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/EMCAL" << endl; 
782     }
783     emcal = new TTask("EMCAL", "") ; 
784     tasks->Add(emcal) ; 
785   } 
786
787   AliEMCALClusterizerv1 * emcalcl = dynamic_cast<AliEMCALClusterizerv1*>(emcal->GetListOfTasks()->FindObject(clu->GetName())) ; 
788   if (emcalcl) { 
789     if (fDebug)
790       cout << "INFO: AliEMCALGetter::Post Rer -> Task " << clu->GetName() << " already exists" << endl ; 
791     emcalcl->Delete() ; 
792     emcal->GetListOfTasks()->Remove(emcalcl) ;
793   }
794   emcal->Add(clu) ;      
795   return kTRUE; 
796
797
798 //____________________________________________________________________________ 
799 TObject ** AliEMCALGetter::ClusterizerRef(const char * name) const 
800 { // ------------------ AliEMCALClusterizer ------------------------
801   
802   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
803
804   if ( !tasks ) {
805     cerr << "ERROR: AliEMCALGetter::Post RerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
806     abort() ;
807   }        
808         
809   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
810   if ( !emcal )  {
811     cerr <<"WARNING: AliEMCALGetter::Post RerRef -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl; 
812     abort() ; 
813   }   
814
815   TList * l = emcal->GetListOfTasks() ; 
816   TIter it(l) ;
817   TTask * task ;
818   TTask * clu = 0 ;
819   TString cluname(name) ;
820   cluname+=":clu-" ;
821   while((task = static_cast<TTask *>(it.Next()) )){
822     TString taskname(task->GetName()) ;
823     if(taskname.BeginsWith(cluname)){
824       clu = task ;
825       break ;
826     }
827   }
828
829   if(clu) 
830     return l->GetObjectRef(clu) ;
831   else {
832     cerr << "ERROR: AliEMCALGetter::Post RerRef -> task " << task->GetName() << " not found! " << endl ; 
833     abort() ;
834   }
835 }
836
837 //____________________________________________________________________________ 
838 Bool_t AliEMCALGetter::PostClusterizer(const char * name) const 
839 { // ------------------ AliEMCALClusterizer ------------------------
840
841   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
842   
843   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
844
845   if ( !tasks ) {
846     cerr << "ERROR: AliEMCALGetter::Post Rer -> Task//" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl; 
847     return kFALSE ;
848   }        
849   
850   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
851   if ( !emcal )  {
852     if (fDebug) {
853       cout <<"WARNING: AliEMCALGetter::Post Rer -> //" << fTasksFolder << "/Reconstructioner/EMCAL not found!" << endl;
854       cout <<"INFO: AliEMCALGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/EMCAL" << endl;
855     }
856     emcal = new TTask("EMCAL", "") ; 
857     tasks->Add(emcal) ; 
858   } 
859
860   TList * l = emcal->GetListOfTasks() ;   
861   TIter it(l) ;
862   TString clun(name) ;
863   clun+=":clu" ; 
864   TTask * task ;
865   while((task = static_cast<TTask *>(it.Next()) )){
866     TString taskname(task->GetName()) ;
867     if(taskname.BeginsWith(clun))
868       return kTRUE ;
869   }
870
871   AliEMCALClusterizerv1 * emcalcl = new AliEMCALClusterizerv1() ;
872   emcal->Add(emcalcl) ;
873   return kTRUE; 
874   
875 }
876
877 //____________________________________________________________________________ 
878 /*Bool_t AliEMCALGetter::PostTrackSegments(const char * name) const 
879 { // ---------------TrackSegments -----------------------------------
880   
881   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
882
883   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ; 
884   
885   if ( !emcalFolder ) {
886     if (fDebug) {
887       cout << "WARNING: AliEMCALGetter::Post TS -> Folder //" << fRecoFolder << "/EMCAL/ not found!" << endl;
888       cout << "INFO:    AliEMCALGetter::Post TS -> Adding Folder //" << fRecoFolder << "/EMCAL" << endl;
889     }
890     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;  
891   }    
892
893   TFolder * emcalTSFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("TrackSegments")) ;
894   if ( !emcalTSFolder ) {
895     if (fDebug) {
896       cout << "WARNING: AliEMCALGetter::Post TS -> Folder//" << fRecoFolder << "/EMCAL/TrackSegments/ not found!" << endl; 
897       cout << "INFO:    AliEMCALGetter::Post TS -> Adding Folder //" << fRecoFolder << "/EMCAL/TrackSegments/" << endl; 
898     }
899     emcalTSFolder = emcalFolder->AddFolder("TrackSegments", "TrackSegments from EMCAL") ;  
900   }    
901   
902   TObject * tss =  emcalTSFolder->FindObject( name ) ;
903   if (!tss) {
904     TClonesArray * ts = new TClonesArray("AliEMCALTrackSegment",100) ;
905     ts->SetName(name) ;
906     emcalTSFolder->Add(ts) ;  
907   }
908   return kTRUE; 
909
910
911 //____________________________________________________________________________ 
912 TObject ** AliEMCALGetter::TrackSegmentsRef(const char * name) const 
913 { // ---------------TrackSegments -----------------------------------
914   
915   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
916
917  if ( !fRecoFolder ) {
918     cerr << "ERROR: AliEMCALGetter::TrackSegmentsRef -> Folder //" << fRecoFolder << "not found!" << endl;
919     abort() ; 
920   }    
921
922   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TrackSegments")) ; 
923   if ( !emcalFolder ) {
924     cerr << "ERROR: AliEMCALGetter::TrackSegmentsRef -> Folder //" << fRecoFolder << "/EMCAL/TrackSegments/ not found!" << endl;
925     abort();
926   }    
927   
928   TObject * tss =  emcalFolder->FindObject(name) ;
929   if (!tss) {
930     cerr << "ERROR: AliEMCALGetter::TrackSegmentsRef -> object " << name << " not found! " << endl ;  
931     abort() ;  
932   }
933   return emcalFolder->GetListOfFolders()->GetObjectRef(tss) ;
934
935
936 //____________________________________________________________________________ 
937 Bool_t AliEMCALGetter::PostTrackSegmentMaker(AliEMCALTrackSegmentMaker * tsmaker) const 
938 { //------------Track Segment Maker ------------------------------
939   
940   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
941
942   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
943
944   if ( !tasks ) {
945     cerr << "ERROR: AliEMCALGetter::Post Ter -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
946     return kFALSE ;
947   }        
948         
949   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
950   if ( !emcal )  {
951     if (fDebug) {
952       cout <<"WARNING: AliEMCALGetter::Post Rer -> //" << fTasksFolder << "/Reconstructioner/EMCAL not found!" << endl; 
953       cout <<"INFO: AliEMCALGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/EMCAL" << endl;
954     }
955     emcal = new TTask("EMCAL", "") ; 
956     tasks->Add(emcal) ; 
957   } 
958
959   AliEMCALTrackSegmentMaker * emcalts = 
960     dynamic_cast<AliEMCALTrackSegmentMaker*>(emcal->GetListOfTasks()->FindObject(tsmaker->GetName())) ; 
961   if (emcalts) { 
962     emcalts->Delete() ;
963     emcal->GetListOfTasks()->Remove(emcalts) ;
964   }
965   emcal->Add(tsmaker) ;      
966   return kTRUE; 
967   
968
969 //____________________________________________________________________________ 
970 Bool_t AliEMCALGetter::PostTrackSegmentMaker(const char * name) const 
971 { //------------Track Segment Maker ------------------------------
972   
973   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
974   
975   
976   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
977   
978   if ( !tasks ) {
979     cerr << "ERROR: AliEMCALGetter::Post Ter -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
980     return kFALSE ;
981   }        
982   
983   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
984   if ( !emcal )  {
985     if (fDebug) {
986       cout <<"WARNING: AliEMCALGetter::Post Rer -> //" << fTasksFolder << "/Reconstructioner/EMCAL not found!" << endl; 
987       cout <<"INFO: AliEMCALGetter::Post Rer -> Adding //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl;
988     }
989     emcal = new TTask("EMCAL", "") ; 
990     tasks->Add(emcal) ; 
991   } 
992
993   AliEMCALTrackSegmentMaker * emcalts = 
994     dynamic_cast<AliEMCALTrackSegmentMaker*>(emcal->GetListOfTasks()->FindObject(name)) ; 
995   if (!emcalts) { 
996     emcalts = new AliEMCALTrackSegmentMakerv1() ;
997     TString tsn(name);
998     tsn+=":tsm-v1" ;
999     emcalts->SetName(tsn) ;
1000     emcal->Add(emcalts) ;      
1001   }
1002   return kTRUE; 
1003   
1004
1005
1006 //____________________________________________________________________________ 
1007 TObject ** AliEMCALGetter::TSMakerRef(const char * name) const 
1008 { //------------Track Segment Maker ------------------------------
1009   
1010   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1011
1012   if ( !tasks ) {
1013     cerr << "ERROR: AliEMCALGetter::TSLakerRef TerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
1014     abort() ;
1015   }        
1016         
1017   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
1018   if ( !emcal )  {
1019     cerr <<"WARNING: AliEMCALGetter::TSMakerRef TerRef -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
1020     abort() ; 
1021   }   
1022
1023   TList * l = emcal->GetListOfTasks() ; 
1024   TIter it(l) ;
1025   TTask * task ;
1026   TTask * tsm = 0 ;
1027   TString tsmname(name) ;
1028   tsmname+=":tsm-" ;
1029   while((task = static_cast<TTask *>(it.Next()) )){
1030     TString taskname(task->GetName()) ;
1031     if(taskname.BeginsWith(tsmname)){
1032       tsm = task ;
1033       break ;
1034     }
1035   }
1036   
1037   if(tsm) 
1038     return l->GetObjectRef(tsm) ;
1039   else {
1040     cerr << "ERROR: AliEMCALGetter::TSLakerRef -> task " << task->GetName() << " not found! " << endl ; 
1041     abort() ;
1042   }
1043
1044
1045 //____________________________________________________________________________ 
1046 Bool_t AliEMCALGetter::PostRecParticles(const char * name) const 
1047 {  // -------------------- RecParticles ------------------------
1048   
1049   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
1050
1051   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ; 
1052   
1053   if ( !emcalFolder ) {
1054     if (fDebug) {
1055       cout << "WARNING: AliEMCALGetter::Post RPa -> Folder //" << fRecoFolder << "/EMCAL/ not found!" << endl;
1056       cout << "INFO:    AliEMCALGetter::Post Rpa -> Adding Folder //" << fRecoFolder << "/EMCAL/" << endl;
1057     }
1058     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;  
1059   }    
1060
1061  TFolder * emcalRPaFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("RecParticles")) ;
1062   if ( !emcalRPaFolder ) {
1063     if (fDebug) {
1064       cout << "WARNING: AliEMCALGetter::Post RPa -> Folder //" << fRecoFolder << "/EMCAL/RecParticles/ not found!" << endl;
1065       cout << "INFO:    AliEMCALGetter::Post RPa -> Adding Folder //" << fRecoFolder << "/EMCAL/RecParticles/" << endl;
1066     }
1067     emcalRPaFolder = emcalFolder->AddFolder("RecParticles", "RecParticles from EMCAL") ;  
1068   } 
1069
1070   TObject * rps = emcalRPaFolder->FindObject( name )  ;
1071   if ( !rps ) {
1072     TClonesArray * rp = new TClonesArray("AliEMCALRecParticle",100) ;
1073     rp->SetName(name) ;    
1074     emcalRPaFolder->Add(rp) ;  
1075   }
1076   return kTRUE; 
1077
1078
1079 //____________________________________________________________________________ 
1080 TObject ** AliEMCALGetter::RecParticlesRef(const char * name) const 
1081 { // ---------------TrackSegments -----------------------------------
1082   
1083   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
1084
1085  if ( !fRecoFolder ) {
1086     cerr << "ERROR: AliEMCALGetter::RecParticlesRef -> Folder//" << fRecoFolder << " not found!" << endl; 
1087     abort() ; 
1088   }    
1089
1090   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/RecParticles")) ; 
1091   if ( !emcalFolder ) {
1092     cerr << "ERROR: AliEMCALGetter::RecParticlesRef -> Folder //" << fRecoFolder << "/EMCAL/RecParticles/ not found!" << endl;
1093     abort() ;
1094   }    
1095
1096   TObject * tss =  emcalFolder->FindObject(name) ;
1097   if (!tss) {
1098     cerr << "ERROR: AliEMCALGetter::RecParticlesRef -> object " << name << " not found! " << endl ; 
1099     abort() ;  
1100   }
1101   return emcalFolder->GetListOfFolders()->GetObjectRef(tss) ;
1102 }
1103
1104 //____________________________________________________________________________ 
1105 Bool_t AliEMCALGetter::PostPID(AliEMCALPID * pid) const 
1106 {      // ------------AliEMCAL PID -----------------------------
1107
1108   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1109
1110   if ( !tasks ) {
1111     cerr << "ERROR: AliEMCALGetter::Post Per -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
1112     return kFALSE ;
1113   }        
1114   
1115   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
1116   if ( !emcal )  {
1117     if (fDebug) {
1118       cout <<"WARNING: AliEMCALGetter::Post Per -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
1119       cout <<"INFO: AliEMCALGetter::Post Per -> Adding //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl;
1120     }
1121     emcal = new TTask("EMCAL", "") ; 
1122     tasks->Add(emcal) ; 
1123   } 
1124
1125   AliEMCALPID * emcalpid = dynamic_cast<AliEMCALPID*>(emcal->GetListOfTasks()->FindObject(pid->GetName())) ; 
1126   if (emcalpid) { 
1127     if (fDebug)
1128       cout << "INFO: AliEMCALGetter::Post Per -> Task " << pid->GetName()
1129            << " already exists" << endl ; 
1130     emcal->GetListOfTasks()->Remove(emcalpid) ;
1131   }
1132   
1133   emcal->Add(pid) ;      
1134   return kTRUE; 
1135
1136
1137 //____________________________________________________________________________ 
1138 Bool_t AliEMCALGetter::PostPID(const char * name) const 
1139 {     
1140   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
1141   
1142   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1143
1144   if ( !tasks ) {
1145     cerr << "ERROR: AliEMCALGetter::Post Per -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
1146     return kFALSE ;
1147   }        
1148   
1149   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
1150   if ( !emcal )  {
1151     if (fDebug) {
1152       cout <<"WARNING: AliEMCALGetter::Post Per -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
1153       cout <<"INFO: AliEMCALGetter::Post Per -> Adding //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl;
1154     }
1155     emcal = new TTask("EMCAL", "") ; 
1156     tasks->Add(emcal) ; 
1157   } 
1158
1159   TList * l = emcal->GetListOfTasks() ;   
1160   TIter it(l) ;
1161   TString pidname(name) ;
1162   pidname+=":pid" ; 
1163   TTask * task ;
1164   while((task = static_cast<TTask *>(it.Next()) )){
1165     TString taskname(task->GetName()) ;
1166     if(taskname.BeginsWith(pidname))
1167       return kTRUE ;
1168   }
1169  
1170   AliEMCALPIDv1 * emcalpid = new AliEMCALPIDv1() ;
1171   pidname+="-v1" ;
1172   emcalpid->SetName(pidname) ;
1173   emcal->Add(emcalpid) ;      
1174   
1175   return kTRUE; 
1176
1177
1178 //____________________________________________________________________________ 
1179 TObject ** AliEMCALGetter::PIDRef(const char * name) const 
1180 { //------------PID ------------------------------
1181
1182   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1183
1184   if ( !tasks ) {
1185     cerr << "ERROR: AliEMCALGetter::PIDRef PerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
1186     abort() ;
1187   }        
1188         
1189   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
1190   if ( !emcal )  {
1191     cerr <<"WARNING: AliEMCALGetter::PIDRef PerRef -> //" << fTasksFolder->GetName() << "/ReconstructionerEMCAL not found!" << endl; 
1192     abort() ; 
1193   }   
1194   
1195   TList * l = emcal->GetListOfTasks() ; 
1196   TIter it(l) ;
1197   TTask * task ;
1198   TTask * pid = 0 ;
1199   TString pidname(name) ;
1200   pidname+=":pid-" ;
1201   while((task = static_cast<TTask *>(it.Next()) )){
1202     TString taskname(task->GetName()) ;
1203     if(taskname.BeginsWith(pidname)){
1204       pid = task ;
1205       break ;
1206     }
1207   }
1208   
1209   if(pid) 
1210     return l->GetObjectRef(pid) ;
1211   else {
1212     cerr << "ERROR: AliEMCALGetter::PIDRef -> task " << task->GetName() << " not found! " << endl ;  
1213     abort() ;
1214   }
1215
1216
1217 //____________________________________________________________________________ 
1218 Bool_t AliEMCALGetter::PostQA(void) const 
1219 { // ------------------ QA ---------------------------------
1220
1221   // the hierarchy is //Folders/Run/Conditions/QA/EMCAL/alarmsName
1222
1223   TFolder * emcalFolder = dynamic_cast<TFolder*>(fQAFolder->FindObject("EMCAL")) ; 
1224   if ( !emcalFolder ) {
1225     if (fDebug) {
1226       cout << "WARNING: AliEMCALGetter::Post Q -> Folder //" << fQAFolder << "/EMCAL/ not found!" << endl;
1227       cout << "INFO:    AliEMCALGetter::Post Q -> Adding Folder //" << fQAFolder << "/EMCAL/" << endl;
1228     }
1229     emcalFolder = fQAFolder->AddFolder("EMCAL", "QA from EMCAL") ; 
1230   }      
1231
1232   return kTRUE;
1233 }
1234
1235 //____________________________________________________________________________ 
1236 TObject ** AliEMCALGetter::AlarmsRef(void) const 
1237 {  //------- Alarms ----------------------
1238
1239   
1240   // the hierarchy is //Folders/Run/Conditions/QA/EMCAL
1241   if ( !fQAFolder ) {
1242     cerr << "ERROR: AliEMCALGetter::AlarmsRef QRef -> Folder //" << fQAFolder << " not found!" << endl;
1243     abort() ;
1244   }    
1245  
1246   TFolder * emcalFolder = dynamic_cast<TFolder *>(fQAFolder->FindObject("EMCAL")) ;
1247   if ( !emcalFolder ) {
1248     cerr << "ERROR: AliEMCALGetter::AlarmsRef QRef -> Folder //" << fQAFolder << "/EMCAL/ not found!" << endl;
1249     abort() ;
1250   }
1251    
1252   return fQAFolder->GetListOfFolders()->GetObjectRef(emcalFolder) ;
1253 }
1254 */
1255 //____________________________________________________________________________ 
1256 const TParticle * AliEMCALGetter::Primary(Int_t index) const
1257 {
1258   // Return primary particle numbered by <index>
1259   
1260   if(index < 0) 
1261     return 0 ;
1262   TParticle *  p = 0 ;
1263   if (fAlice) 
1264     p = fAlice->Particle(index) ; 
1265   else 
1266     p = gAlice->Particle(index) ; 
1267   //   if (p->GetFirstMother() != -1 ) {
1268   //     cout << "AliEMCALGetter::Primary : Not a primary " << endl ; 
1269   //   }
1270   
1271   return p ; 
1272       
1273 }
1274
1275 //____________________________________________________________________________ 
1276 void AliEMCALGetter::ReadTreeD()
1277 {
1278   // Read the digit tree gAlice->TreeD()  
1279
1280   TTree * treeD = gAlice->TreeD() ;
1281   
1282   if(!treeD) { // TreeD not found in header file
1283     
1284     if (fDebug) 
1285       cout <<   "WARNING: AliEMCALGetter::ReadTreeD -> Cannot find TreeD in " << fHeaderFile << endl ;
1286     
1287     TString searchFileName("") ; 
1288     
1289     if (Digitizer())  // Digitizer found in header file
1290       searchFileName = Digitizer()->GetTitle() ; 
1291     
1292     else if (Clusterizer())  // Clusterizer found in header file
1293       searchFileName = Clusterizer()->GetDigitsFileName() ; 
1294     
1295     if (treeD = TreeD(searchFileName)) { //found TreeD in the file which contains the hits
1296       if (fDebug) 
1297         cout << "INFO: AliEMCALGetter::ReadTreeD -> TreeD found in " << searchFileName.Data() << endl ; 
1298       
1299     } else {
1300       cerr << "ERROR: AliEMCALGetter::ReadTreeD -> TreeD not found " << endl ; 
1301       return ;
1302     }   
1303   }
1304   TObjArray * lob = static_cast<TObjArray*>(gAlice->TreeD()->GetListOfBranches()) ;
1305   TIter next(lob) ; 
1306   TBranch * branch = 0 ; 
1307   TBranch * digitsbranch = 0 ; 
1308   TBranch * digitizerbranch = 0 ; 
1309   Bool_t emcalfound = kFALSE, digitizerfound = kFALSE ; 
1310   
1311   while ( (branch = static_cast<TBranch*>(next())) && (!emcalfound || !digitizerfound) ) {
1312     if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1313       digitsbranch = branch ; 
1314       emcalfound = kTRUE ;
1315     }
1316     else if ( (strcmp(branch->GetName(), "AliEMCALDigitizer")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1317       digitizerbranch = branch ; 
1318       digitizerfound = kTRUE ; 
1319     }
1320   }
1321
1322   if ( !emcalfound || !digitizerfound ) {
1323     if (fDebug)
1324       cout << "WARNING: AliEMCALGetter::ReadTreeD -> Cannot find Digits and/or Digitizer with name " 
1325            << fDigitsTitle << endl ;
1326     return ; 
1327   }   
1328  
1329   //read digits
1330   if(!Digits(fDigitsTitle) ) 
1331     PostDigits(fDigitsTitle);
1332   digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ;
1333   digitsbranch->GetEntry(0) ;
1334   
1335   
1336   // read  the Digitizer
1337   if(!Digitizer(fDigitsTitle))
1338     PostDigitizer(fDigitsTitle) ;
1339
1340   digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ;
1341   digitizerbranch->GetEntry(0) ;
1342  
1343   
1344 }
1345
1346 //____________________________________________________________________________ 
1347 void AliEMCALGetter::ReadTreeH()
1348 {
1349   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
1350
1351   TTree * treeH = gAlice->TreeH() ;
1352   
1353   if(!treeH) {// TreeH not found in header file
1354     
1355     if (fDebug) 
1356       cout <<   "WARNING: AliEMCALGetter::ReadTreeH -> Cannot find TreeH in " << fHeaderFile << endl ;
1357     
1358     TString searchFileName("") ; 
1359     
1360     if (SDigitizer())  // SDigitizer found in header file
1361       searchFileName = SDigitizer()->GetTitle() ;
1362     
1363     else if (Digitizer())  // Digitizer found in header file
1364       searchFileName = Digitizer()->GetHitsFileName() ; 
1365     
1366     else if (Clusterizer())  // Clusterizer found in header file
1367       searchFileName = Clusterizer()->GetHitsFileName() ; 
1368     
1369     if (treeH = TreeH(searchFileName)) { //found TreeH in the file which contains the hits
1370       if (fDebug) 
1371         cout << "INFO: AliEMCALGetter::ReadTreeH -> TreeH found in " << searchFileName.Data() << endl ; 
1372       
1373     } else {
1374       cerr << "ERROR: AliEMCALGetter::ReadTreeH -> TreeH not found " << endl ; 
1375       return ;
1376     }  
1377   }  
1378   
1379   TBranch * hitsbranch = static_cast<TBranch*>(gAlice->TreeH()->GetBranch("EMCAL")) ;
1380   if ( !hitsbranch ) {
1381     if (fDebug)
1382       cout << "WARNING:  AliEMCALGetter::ReadTreeH -> Cannot find branch EMCAL" << endl ; 
1383     return ;
1384   }
1385   if(!Hits())
1386     PostHits() ;
1387  
1388   if (hitsbranch->GetEntries() > 1 ) {
1389     TClonesArray * tempo =  new TClonesArray("AliEMCALHit",1000) ;
1390     TClonesArray * hits = dynamic_cast<TClonesArray*>(*HitsRef()) ; 
1391     hitsbranch->SetAddress(&tempo) ;
1392     Int_t index = 0 ; 
1393     Int_t i = 0 ;
1394     for (i = 0 ; i < hitsbranch->GetEntries() ; i++) {
1395       hitsbranch->GetEntry(i) ;
1396       Int_t j = 0 ; 
1397       for ( j = 0 ; j < tempo->GetEntries() ; j++) { 
1398         const AliEMCALHit * hit = static_cast<const AliEMCALHit *>(tempo->At(j)) ; 
1399         new((*hits)[index]) AliEMCALHit( *hit ) ;
1400         index++ ; 
1401       }
1402     }
1403     delete tempo ; 
1404   }
1405   else {
1406   hitsbranch->SetAddress(HitsRef()) ;
1407   hitsbranch->GetEntry(0) ;
1408   }
1409 }
1410
1411 //____________________________________________________________________________ 
1412 void AliEMCALGetter::Track(Int_t itrack)
1413 {
1414   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
1415
1416   if(gAlice->TreeH()== 0){
1417     cerr <<   "ERROR: AliEMCALGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
1418     return ;
1419   }
1420   
1421   TBranch * hitsbranch = dynamic_cast<TBranch*>(gAlice->TreeH()->GetListOfBranches()->FindObject("EMCAL")) ;
1422   if ( !hitsbranch ) {
1423     if (fDebug)
1424       cout << "WARNING:  AliEMCALGetter::ReadTreeH -> Cannot find branch EMCAL" << endl ; 
1425     return ;
1426   }  
1427   if(!Hits())
1428     PostHits() ;
1429   hitsbranch->SetAddress(HitsRef()) ;
1430   hitsbranch->GetEntry(itrack) ;
1431
1432   
1433 }
1434
1435
1436 //____________________________________________________________________________ 
1437 TTree * AliEMCALGetter::TreeK(TString filename)  
1438 {
1439
1440   // returns TreeK from file filename
1441   // usefull in case of split file
1442
1443   if ( filename.IsNull() ) 
1444     filename = fHeaderFile ; 
1445
1446   TFile * file = 0 ; 
1447   // file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1448   if (!file) {  // file not open yet
1449     //   file->Close() ; 
1450     file = TFile::Open(filename.Data(), "read") ; 
1451     delete fAlice ; 
1452     fAlice = static_cast<AliRun *>(file->Get("gAlice")) ; 
1453   }
1454
1455   TString treeName("TreeK") ; 
1456   treeName += EventNumber()  ; 
1457   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1458   if (!tree && fDebug)  
1459     cout << "WARNING: AliEMCALGetter::TreeK -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
1460   
1461   return tree ;                       
1462 }
1463
1464 //____________________________________________________________________________ 
1465 TTree * AliEMCALGetter::TreeH(TString filename)  
1466 {
1467
1468   // returns TreeH from file filename
1469   // usefull in case of split file
1470
1471   if ( filename.IsNull() ) 
1472     filename = fHeaderFile ; 
1473
1474   TFile * file = 0 ; 
1475   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1476   if (!file) { // file not open yet
1477     file = TFile::Open(filename.Data(), "read") ; 
1478   }
1479   TString treeName("TreeH") ; 
1480   treeName += EventNumber()  ; 
1481   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1482   if (!tree && fDebug)  
1483     cout << "WARNING: AliEMCALGetter::TreeH -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
1484   
1485   return tree ;                       
1486 }
1487
1488 //____________________________________________________________________________ 
1489 TTree * AliEMCALGetter::TreeS(TString filename)  
1490 {
1491
1492   // returns TreeS from file filename
1493   // usefull in case of split file
1494
1495   if ( filename.IsNull() ) 
1496     filename = fHeaderFile ; 
1497
1498   TFile * file = 0 ; 
1499   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1500   if (!file) { // file not open yet
1501     file = TFile::Open(filename.Data(), "read") ; 
1502   }
1503   TString treeName("TreeS") ; 
1504   treeName += EventNumber()  ; 
1505   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1506   if (!tree && fDebug)  
1507     cout << "WARNING: AliEMCALGetter::TreeS -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
1508   
1509   return tree ;                       
1510 }
1511
1512 //____________________________________________________________________________ 
1513 TTree * AliEMCALGetter::TreeD(TString filename)  
1514 {
1515
1516   // returns TreeD from file filename
1517   // usefull in case of split file
1518
1519   if ( filename.IsNull() ) 
1520     filename = fHeaderFile ; 
1521
1522   TFile * file = 0 ; 
1523   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1524   if (!file) { // file not open yet
1525     file = TFile::Open(filename.Data(), "read") ; 
1526   }
1527   TString treeName("TreeD") ; 
1528   treeName += EventNumber()  ; 
1529   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1530   if (!tree && fDebug)  
1531     cout << "WARNING: AliEMCALGetter::TreeD -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
1532   
1533   return tree ;                       
1534 }
1535
1536 //____________________________________________________________________________ 
1537 // void AliEMCALGetter::ReadTreeQA()
1538 //{
1539   // Read the digit tree gAlice->TreeQA()
1540   // so far only EMCAL knows about this Tree  
1541
1542 //   if(EMCAL()->TreeQA()== 0){
1543 //     cerr <<   "ERROR: AliEMCALGetter::ReadTreeQA: can not read TreeQA " << endl ;
1544 //     return ;
1545 //   }
1546   
1547 //   TBranch * qabranch = EMCAL()->TreeQA()->GetBranch("EMCAL") ; 
1548 //   if (!qabranch) { 
1549 //     if (fDebug)
1550 //       cout << "WARNING: AliEMCALGetter::ReadTreeQA -> Cannot find QA Alarms for EMCAL" << endl ;
1551 //     return ; 
1552 //   }   
1553   
1554 //   if(!Alarms())
1555 //     PostQA() ; 
1556
1557 //   qabranch->SetAddress(AlarmsRef()) ;
1558
1559 //   qabranch->GetEntry(0) ;
1560  
1561 //   PostQA("EMCAL") ; 
1562 //   TFolder * alarmsF = Alarms() ; 
1563 //   alarmsF->Clear() ; 
1564 //   qabranch->SetAddress(&alarmsF) ;
1565 //   qabranch->GetEntry(0) ;
1566   
1567 //}
1568   
1569 //____________________________________________________________________________ 
1570 void AliEMCALGetter::ReadTreeR()
1571 {
1572       // Read the reconstrunction tree gAlice->TreeR()
1573
1574   if(gAlice->TreeR()== 0){
1575     if (fDebug) 
1576       cout <<   "WARNING: AliEMCALGetter::ReadTreeR: can not read TreeR " << endl ;
1577     return ;
1578   }
1579   
1580   // RecPoints 
1581   TObjArray * lob = static_cast<TObjArray*>(gAlice->TreeR()->GetListOfBranches()) ;
1582   TIter next(lob) ; 
1583   TBranch * branch = 0 ; 
1584   TBranch * towerbranch = 0 ; 
1585   TBranch * preshobranch = 0 ; 
1586   TBranch * clusterizerbranch = 0 ; 
1587   Bool_t emcaltowerrpfound = kFALSE, emcalpreshorpfound = kFALSE, clusterizerfound = kFALSE ; 
1588   
1589   while ( (branch = static_cast<TBranch*>(next())) && (!emcaltowerrpfound || !emcalpreshorpfound || !clusterizerfound) ) 
1590     if(strcmp(branch->GetTitle(), fRecPointsTitle)==0) {
1591       if ( strcmp(branch->GetName(), "EMCALTowerRP")==0) {
1592         towerbranch = branch ; 
1593         emcaltowerrpfound = kTRUE ;
1594       }
1595       else if ( strcmp(branch->GetName(), "EMCALPreShoRP")==0) {
1596         preshobranch = branch ; 
1597         emcalpreshorpfound = kTRUE ;
1598       }
1599       else if(strcmp(branch->GetName(), "AliEMCALClusterizer")==0){
1600         clusterizerbranch = branch ; 
1601         clusterizerfound = kTRUE ; 
1602       }
1603     }
1604
1605   if ( !emcaltowerrpfound ) {
1606     if (fDebug)
1607       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Cannot find TowerRecPoints with title " 
1608            << fRecPointsTitle << endl ;
1609     return ; 
1610   }   
1611   if ( !emcalpreshorpfound ) {
1612     if (fDebug)
1613       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Cannot find PreShoRecPoints with title " 
1614            << fRecPointsTitle << endl ;
1615     return ; 
1616   }   
1617   if ( !clusterizerfound ) {
1618     if (fDebug)
1619       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Can not find Clusterizer with title " 
1620            << fRecPointsTitle << endl ;
1621     return ; 
1622   }   
1623   
1624   // Read and Post the RecPoints
1625   if(!TowerRecPoints(fRecPointsTitle) )
1626     PostRecPoints(fRecPointsTitle) ;
1627   towerbranch->SetAddress(TowerRecPointsRef(fRecPointsTitle)) ;
1628   towerbranch->GetEntry(0) ;
1629
1630   preshobranch->SetAddress(PreShoRecPointsRef(fRecPointsTitle)) ;
1631   preshobranch->GetEntry(0) ;
1632   
1633   if(!Clusterizer(fRecPointsTitle) )
1634     PostClusterizer(fRecPointsTitle) ;
1635   
1636   clusterizerbranch->SetAddress(ClusterizerRef(fRecPointsTitle)) ;
1637   clusterizerbranch->GetEntry(0) ;
1638  
1639   
1640   //------------------- TrackSegments ---------------------
1641 //   next.Reset() ; 
1642 //   TBranch * tsbranch = 0 ; 
1643 //   TBranch * tsmakerbranch = 0 ; 
1644 //   Bool_t emcaltsfound = kFALSE, tsmakerfound = kFALSE ; 
1645     
1646 //   while ( (branch = static_cast<TBranch*>(next())) && (!emcaltsfound || !tsmakerfound) ) 
1647 //     if(strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0)  {
1648 //       if ( strcmp(branch->GetName(), "EMCALTS")==0){
1649 //      tsbranch = branch ; 
1650 //      emcaltsfound = kTRUE ;
1651 //       }
1652 //       else if(strcmp(branch->GetName(), "AliEMCALTrackSegmentMaker")==0) {
1653 //      tsmakerbranch = branch ; 
1654 //      tsmakerfound  = kTRUE ; 
1655 //       }
1656 //     }
1657   
1658 //   if ( !emcaltsfound || !tsmakerfound ) {
1659 //     if (fDebug)
1660 //       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Cannot find TrackSegments and/or TrackSegmentMaker with name "
1661 //         << fTrackSegmentsTitle << endl ;
1662 //     return ; 
1663 //   } 
1664   
1665 //   // Read and Post the TrackSegments
1666 //   if(!TrackSegments(fTrackSegmentsTitle))
1667 //     PostTrackSegments(fTrackSegmentsTitle) ;
1668 //   tsbranch->SetAddress(TrackSegmentsRef(fTrackSegmentsTitle)) ;
1669 //   tsbranch->GetEntry(0) ;
1670   
1671 //   // Read and Post the TrackSegment Maker
1672 //   if(!TrackSegmentMaker(fTrackSegmentsTitle))
1673 //     PostTrackSegmentMaker(fTrackSegmentsTitle) ;
1674 //   tsmakerbranch->SetAddress(TSMakerRef(fTrackSegmentsTitle)) ;
1675 //   tsmakerbranch->GetEntry(0) ;
1676   
1677   
1678 //   //------------ RecParticles ----------------------------
1679 //   next.Reset() ; 
1680 //   TBranch * rpabranch = 0 ; 
1681 //   TBranch * pidbranch = 0 ; 
1682 //   Bool_t emcalrpafound = kFALSE, pidfound = kFALSE ; 
1683   
1684 //   while ( (branch = static_cast<TBranch*>(next())) && (!emcalrpafound || !pidfound) ) 
1685 //     if(strcmp(branch->GetTitle(), fRecParticlesTitle)==0) {   
1686 //       if ( strcmp(branch->GetName(), "EMCALRP")==0) {   
1687 //      rpabranch = branch ; 
1688 //      emcalrpafound = kTRUE ;
1689 //       }
1690 //       else if (strcmp(branch->GetName(), "AliEMCALPID")==0) {
1691 //      pidbranch = branch ; 
1692 //      pidfound  = kTRUE ; 
1693 //       }
1694 //     }
1695   
1696 //   if ( !emcalrpafound || !pidfound ) {
1697 //     if (fDebug)
1698 //       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Cannot find RecParticles and/or PID with name " 
1699 //         << fRecParticlesTitle << endl ;
1700 //     return ; 
1701 //   } 
1702   
1703 //   // Read and Post the RecParticles
1704 //   if(!RecParticles(fRecParticlesTitle))
1705 //     PostRecParticles(fRecParticlesTitle) ;
1706 //   rpabranch->SetAddress(RecParticlesRef(fRecParticlesTitle)) ;
1707 //   rpabranch->GetEntry(0) ;
1708   
1709 //   // Read and Post the PID
1710 //   if(!PID(fRecParticlesTitle))
1711 //     PostPID(fRecParticlesTitle) ;
1712 //   pidbranch->SetAddress(PIDRef(fRecParticlesTitle)) ;
1713 //   pidbranch->GetEntry(0) ;
1714   
1715   
1716 }
1717
1718 //____________________________________________________________________________ 
1719 void AliEMCALGetter::ReadTreeS(Int_t event)
1720 {
1721   // Read the summable digits tree gAlice->TreeS()  
1722   
1723   // loop over all opened files and read their SDigits to the White Board
1724   TFolder * emcalF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
1725   if (!emcalF) 
1726     emcalF = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; 
1727   TCollection * folderslist = emcalF->GetListOfFolders() ; 
1728   
1729   //Add current file to list if it is not there yet
1730
1731   TString subdir(fHeaderFile) ;
1732   subdir.ReplaceAll("/","_") ; 
1733
1734   if ( (subdir != "aliroot") && ( !folderslist->Contains(subdir) ) ){
1735     emcalF->AddFolder(subdir, ""); 
1736   }
1737
1738   TIter next(folderslist) ; 
1739   TFolder * folder = 0 ; 
1740   TFile * file; 
1741   TTree * treeS = 0;
1742   while ( (folder = static_cast<TFolder*>(next())) ) {
1743    TString fileName(folder->GetName()) ; 
1744    fileName.ReplaceAll("_","/") ; 
1745    if(fHeaderFile.CompareTo(fileName) == 0 ) 
1746       treeS=gAlice->TreeS() ;
1747     else{
1748       file = static_cast<TFile*>(gROOT->GetFile(fileName)); 
1749       file->cd() ;
1750       
1751       // Get SDigits Tree header from file
1752       TString treeName("TreeS") ;
1753       treeName += event ; 
1754       treeS = dynamic_cast<TTree*>(gDirectory->Get(treeName.Data()));
1755     }
1756    if(!treeS){ // TreeS not found in header file
1757      
1758      if (fDebug)
1759        cout << "WARNING: AliEMCALGetter::ReadTreeS -> Cannot find TreeS in " << fHeaderFile << endl;
1760      
1761      TString searchFileName("") ; 
1762      
1763      if (SDigitizer())  // SDigitizer found in header file
1764        searchFileName = SDigitizer()->GetTitle() ;
1765      
1766      else if (Digitizer())  // Digitizer found in header file
1767        searchFileName = Digitizer()->GetSDigitsFileName() ; 
1768      
1769      else if (Clusterizer())  // Clusterizer found in header file
1770        searchFileName = Clusterizer()->GetSDigitsFileName() ; 
1771      
1772      if (treeS = TreeS(searchFileName)) { //found TreeS in the file which contains the hits
1773        if (fDebug) 
1774          cout << "INFO: AliEMCALGetter::ReadTreeS -> TreeS found in " << searchFileName.Data() << endl ; 
1775        
1776      } else {
1777        cerr << "ERROR: AliEMCALGetter::ReadTreeS -> TreeS not found " << endl ; 
1778        return ;
1779      }
1780    }   
1781
1782    //set address of the SDigits and SDigitizer
1783    TBranch   * sdigitsBranch    = 0;
1784    TBranch   * sdigitizerBranch = 0;
1785    TBranch   * branch           = 0 ;  
1786    TObjArray * lob = static_cast<TObjArray*>(treeS->GetListOfBranches()) ;
1787    TIter next(lob) ; 
1788    Bool_t emcalfound = kFALSE, sdigitizerfound = kFALSE ; 
1789    
1790    while ( (branch = static_cast<TBranch*>(next())) && (!emcalfound || !sdigitizerfound) ) {
1791      if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
1792        emcalfound = kTRUE ;
1793        sdigitsBranch = branch ; 
1794      }
1795      
1796      else if ( (strcmp(branch->GetName(), "AliEMCALSDigitizer")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
1797        sdigitizerfound = kTRUE ; 
1798        sdigitizerBranch = branch ;
1799      }
1800    }
1801    if ( !emcalfound || !sdigitizerfound ) {
1802      if (fDebug)
1803        cout << "WARNING: AliEMCALGetter::ReadSDigits -> Digits and/or Digitizer branch with name " <<  fSDigitsTitle
1804             << " not found" << endl ;
1805      return ; 
1806    }   
1807    
1808    if ( !folder->FindObject(fSDigitsTitle) )  
1809      PostSDigits(fSDigitsTitle,folder->GetName()) ;
1810    sdigitsBranch->SetAddress(SDigitsRef(fSDigitsTitle,folder->GetName())) ;
1811    sdigitsBranch->GetEntry(0) ;
1812    
1813    TString sdname(fSDigitsTitle) ;
1814    sdname+=":" ;
1815    sdname+=folder->GetName() ;
1816    if(!SDigitizer(sdname) ) 
1817      PostSDigitizer(fSDigitsTitle,folder->GetName()) ;
1818    
1819    sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
1820    sdigitizerBranch->GetEntry(0) ;
1821    
1822   }
1823   
1824   // After SDigits have been read from all files, return to the first one
1825   
1826   next.Reset();
1827   folder = static_cast<TFolder*>(next());
1828   if(folder){
1829     TString fileName(folder->GetName()) ; 
1830     fileName.ReplaceAll("_","/") ; 
1831     file   = static_cast<TFile*>(gROOT->GetFile(fileName)); 
1832     file   ->cd() ;
1833   }
1834   
1835 }
1836
1837 //____________________________________________________________________________ 
1838 void AliEMCALGetter::ReadTreeS(TTree * treeS, Int_t input)
1839 {  // Read the summable digits fron treeS()  
1840
1841
1842   TString filename("mergefile") ;
1843   filename+= input ;
1844
1845   TFolder * emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ; 
1846   if ( !emcalFolder ) { 
1847    emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; 
1848   } 
1849   TFolder * folder=(TFolder*)emcalFolder->FindObject(filename) ;
1850   //set address of the SDigits and SDigitizer
1851   TBranch   * sdigitsBranch    = 0;
1852   TBranch   * sdigitizerBranch = 0;
1853   TBranch   * branch           = 0 ;  
1854   TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
1855   TIter next(lob) ; 
1856   Bool_t emcalfound = kFALSE, sdigitizerfound = kFALSE ; 
1857   
1858   while ( (branch = (TBranch*)next()) && (!emcalfound || !sdigitizerfound) ) {
1859     if ( strcmp(branch->GetName(), "EMCAL")==0) {
1860       emcalfound = kTRUE ;
1861       sdigitsBranch = branch ; 
1862     }
1863     
1864     else if ( strcmp(branch->GetName(), "AliEMCALSDigitizer")==0) {
1865       sdigitizerfound = kTRUE ; 
1866       sdigitizerBranch = branch ;
1867     }
1868   }
1869   if ( !emcalfound || !sdigitizerfound ) {
1870     if (fDebug)
1871       cout << "WARNING: AliEMCALGetter::ReadTreeS -> Digits and/or Digitizer branch not found" << endl ;
1872     return ; 
1873   }   
1874   
1875   if (!folder || !(folder->FindObject(sdigitsBranch->GetTitle()) ) )
1876     PostSDigits(sdigitsBranch->GetTitle(),filename) ;
1877
1878   sdigitsBranch->SetAddress(SDigitsRef(sdigitsBranch->GetTitle(),filename)) ;
1879   sdigitsBranch->GetEntry(0) ;
1880   
1881   TString sdname(sdigitsBranch->GetTitle()) ;
1882   sdname+=":" ;
1883   sdname+=filename ;
1884   if(!SDigitizer(sdigitsBranch->GetTitle()) )
1885     PostSDigitizer(sdigitsBranch->GetTitle(),filename) ;
1886
1887   sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
1888   sdigitizerBranch->GetEntry(0) ;
1889   
1890 }    
1891
1892
1893 //____________________________________________________________________________ 
1894 void AliEMCALGetter::ReadPrimaries()
1895 {
1896   // Reads specific branches of primaries
1897   
1898   TClonesArray * ar = 0  ; 
1899   if(! (ar = Primaries()) ) { 
1900     PostPrimaries() ;
1901     ar = Primaries() ; 
1902   }
1903   ar->Delete() ; 
1904   
1905   if (TreeK(fHeaderFile)) { // treeK found in header file
1906     if (fDebug) 
1907       cout << "INFO: AliEMCALGetter::ReadPrimaries -> TreeK found in " << fHeaderFile.Data() << endl ; 
1908     fNPrimaries = gAlice->GetNtrack() ; 
1909   
1910   } else { // treeK not found in header file
1911
1912     TString searchFileName("") ; 
1913
1914     if (SDigitizer())  // SDigitizer found in header file
1915       searchFileName = SDigitizer()->GetTitle() ;
1916
1917     else if (Digitizer())  // Digitizer found in header file
1918       searchFileName = Digitizer()->GetHitsFileName() ; 
1919
1920     else if (Clusterizer())  // Clusterizer found in header file
1921       searchFileName = Clusterizer()->GetHitsFileName() ; 
1922     
1923     if (TreeK(searchFileName)) { //found TreeK in the file which contains the hits
1924       if (fDebug) 
1925         cout << "INFO: AliEMCALGetter::ReadPrimaries -> TreeK found in " << searchFileName.Data() << endl ; 
1926       fAlice->GetEvent(EventNumber()) ; 
1927       fNPrimaries = fAlice->GetNtrack() ; 
1928       
1929     } else {
1930       cerr << "ERROR: AliEMCALGetter::ReadPrimaries -> TreeK not  found " << endl ; 
1931       return ;
1932     }
1933     
1934   }
1935   Int_t index = 0 ; 
1936   for (index = 0 ; index < fNPrimaries; index++) { 
1937     new ((*ar)[index]) TParticle(*(Primary(index)));
1938   }
1939 }
1940
1941 //____________________________________________________________________________ 
1942 void AliEMCALGetter::Event(const Int_t event, const char* opt)
1943 {
1944   // Reads the content of all Tree's S, D and R
1945   
1946   if (event >= gAlice->TreeE()->GetEntries() ) {
1947     cerr << "ERROR: AliEMCALGetter::Event -> " << event << " not found in TreeE!" << endl ; 
1948     return ; 
1949   }
1950   gAlice->GetEvent(event) ;
1951
1952   // Carefull the order of reading is important 
1953   
1954   if( strstr(opt,"R") )
1955     ReadTreeR() ;
1956
1957   if( strstr(opt,"D") )
1958     ReadTreeD() ;
1959
1960   if(strstr(opt,"S") )
1961     ReadTreeS(event) ;
1962
1963   if(strstr(opt,"H") )
1964     ReadTreeH() ;
1965
1966  // if( strstr(opt,"Q") )
1967   //  ReadTreeQA() ;
1968
1969   if( strstr(opt,"P") || (strcmp(opt,"")==0) )
1970     ReadPrimaries() ;
1971   
1972 }
1973
1974 //____________________________________________________________________________ 
1975 TObject * AliEMCALGetter::ReturnO(TString what, TString name, TString file) const 
1976 {
1977   // get the object named "what" from the folder
1978   // folders are named like //Folders
1979
1980   if ( file.IsNull() ) 
1981     file = fHeaderFile ; 
1982
1983   TFolder * folder = 0 ;
1984   TObject * emcalO  = 0 ; 
1985
1986   //  if ( name.IsNull() ) {
1987   if ( what.CompareTo("Hits") == 0 ) {
1988     folder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("EMCAL")) ; 
1989     if (folder) 
1990       emcalO  = dynamic_cast<TObject *>(folder->FindObject("Hits")) ;  
1991   }
1992   else if ( what.CompareTo("SDigits") == 0 ) { 
1993     file.ReplaceAll("/","_") ; 
1994     TString path = "EMCAL/" + file  ; 
1995     folder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject(path.Data())) ; 
1996     if (folder) { 
1997       if (name.IsNull())
1998         name = fSDigitsTitle ; 
1999       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2000     }
2001   }
2002   else if ( what.CompareTo("Digits") == 0 ){
2003     folder = dynamic_cast<TFolder *>(fDigitsFolder->FindObject("EMCAL")) ; 
2004     if (folder) { 
2005       if (name.IsNull())
2006         name = fDigitsTitle ; 
2007       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2008     } 
2009   }
2010   else if ( what.CompareTo("TowerRecPoints") == 0 ) {
2011     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("EMCAL/TowerRecPoints")) ; 
2012     if (folder) { 
2013       if (name.IsNull())
2014         name = fRecPointsTitle ; 
2015       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2016     } 
2017   }
2018   else if ( what.CompareTo("PreShoRecPoints") == 0 ) {
2019     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("EMCAL/PreShoRecPoints")) ; 
2020     if (folder) { 
2021       if (name.IsNull())
2022         name = fRecPointsTitle ; 
2023       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2024     }   
2025   }
2026   /*
2027   else if ( what.CompareTo("TrackSegments") == 0 ) {
2028     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("EMCAL/TrackSegments")) ; 
2029     if (folder) { 
2030       if (name.IsNull())
2031         name = fTrackSegmentsTitle ; 
2032       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2033     }   
2034   }
2035   else if ( what.CompareTo("RecParticles") == 0 ) {
2036     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("EMCAL/RecParticles")) ; 
2037    if (folder) { 
2038       if (name.IsNull())
2039         name = fRecParticlesTitle ; 
2040       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2041     }   
2042  }
2043   else if ( what.CompareTo("Alarms") == 0 ){ 
2044     if (name.IsNull() ) 
2045       emcalO = dynamic_cast<TObject *>(fQAFolder->FindObject("EMCAL")) ;  
2046     else {
2047       folder = dynamic_cast<TFolder *>(fQAFolder->FindObject("EMCAL")) ; 
2048       if (!folder) 
2049         emcalO = 0 ; 
2050       else 
2051         emcalO = dynamic_cast<TObject *>(folder->FindObject(name)) ;  
2052     }
2053   }
2054 */
2055   if (!emcalO) {
2056     if(fDebug)
2057       cout << "WARNING : AliEMCALGetter::ReturnO -> Object " << what << " not found in " << folder->GetName() << endl ; 
2058     return 0 ;
2059   }
2060   return emcalO ;
2061 }
2062   
2063 //____________________________________________________________________________ 
2064 const TTask * AliEMCALGetter::ReturnT(TString what, TString name) const 
2065 {
2066   // get the TTask named "what" from the folder
2067   // folders are named like //Folders/Tasks/what/EMCAL/name
2068
2069   TString search(what) ; 
2070   if ( what.CompareTo("Clusterizer") == 0 ) 
2071     search = "Reconstructioner" ; 
2072   else if ( what.CompareTo("TrackSegmentMaker") == 0 ) 
2073     search = "Reconstructioner" ; 
2074   else if ( what.CompareTo("PID") == 0 ) 
2075     search = "Reconstructioner" ; 
2076   else if ( what.CompareTo("QATasks") == 0 ) 
2077     search = "QA" ; 
2078   
2079   TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject(search)) ; 
2080
2081   if (!tasks) {
2082     cerr << "ERROR: AliEMCALGetter::ReturnT -> Task " << what << " not found!" << endl ;  
2083     return 0 ; 
2084   }
2085
2086   TTask * emcalT = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2087   if (!emcalT) { 
2088     cerr << "ERROR: AliEMCALGetter::ReturnT -> Task " << what << "/EMCAL not found!" << endl ;  
2089     return 0 ; 
2090   }
2091   
2092   TList * list = emcalT->GetListOfTasks() ; 
2093  
2094   if (what.CompareTo("SDigitizer") == 0) {  
2095     if ( name.IsNull() )
2096       name =  fSDigitsTitle ; 
2097   } else  if (what.CompareTo("Digitizer") == 0){ 
2098     if ( name.IsNull() )
2099       name =  fDigitsTitle ;
2100   } else  if (what.CompareTo("Clusterizer") == 0){ 
2101     if ( name.IsNull() )
2102       name =  fRecPointsTitle ;
2103     name.Append(":clu") ;
2104   }
2105  //  else  if (what.CompareTo("TrackSegmentMaker") == 0){ 
2106 //     if ( name.IsNull() )
2107 //       name =  fTrackSegmentsTitle ;
2108 //     name.Append(":tsm") ;
2109 //   }
2110 //   else  if (what.CompareTo("PID") == 0){ 
2111 //     if ( name.IsNull() )
2112 //       name =  fRecParticlesTitle ;
2113 //     name.Append(":pid") ;
2114 //   }
2115 //   else  if (what.CompareTo("QATasks") == 0){ 
2116 //     if ( name.IsNull() )
2117 //       return emcalT ;
2118 //   }
2119   
2120   TIter it(list) ;
2121   TTask * task = 0 ; 
2122   while((task = static_cast<TTask *>(it.Next()) )){
2123     TString taskname(task->GetName()) ;
2124     if(taskname.BeginsWith(name)){
2125     return task ;}
2126   }
2127   
2128   if(fDebug)
2129     cout << "WARNING: AliEMCALGetter::ReturnT -> Task " << search << "/" << name << " not found!" << endl ; 
2130   return 0 ;
2131 }
2132
2133
2134 //____________________________________________________________________________ 
2135 void AliEMCALGetter::RemoveTask(TString opt, TString name) const 
2136 {
2137   // remove a task from the folder
2138   // path is fTasksFolder/SDigitizer/EMCAL/name
2139
2140   TTask * task  = 0 ; 
2141   TTask * emcal = 0 ; 
2142   TList * lofTasks = 0 ; 
2143
2144   if (opt == "S") { // SDigitizer
2145     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
2146     if (!task) 
2147       return ; 
2148   }
2149   
2150   else if (opt == "D") { // Digitizer
2151     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
2152     if (!task) 
2153       return ; 
2154   }
2155   else if (opt == "C") { // Clusterizer
2156     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
2157     if (!task) 
2158       return ; 
2159   }
2160   else {
2161     cerr << "WARNING: AliEMCALGetter::RemoveTask -> Unknown option " << opt.Data() << endl ; 
2162     return ; 
2163   }
2164     
2165   emcal =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("EMCAL")) ;
2166   if (!emcal)
2167     return ; 
2168   lofTasks = emcal->GetListOfTasks() ;
2169   if (!lofTasks) 
2170     return ; 
2171   TObject * obj = lofTasks->FindObject(name) ; 
2172   if (obj) 
2173     lofTasks->Remove(obj) ;
2174 }
2175   
2176 //____________________________________________________________________________ 
2177 void AliEMCALGetter::RemoveObjects(TString opt, TString name) const 
2178 {
2179   // remove SDigits from the folder
2180   // path is fSDigitsFolder/fHeaderFileName/name
2181
2182   TFolder * emcal     = 0 ; 
2183   TFolder * emcalmain = 0 ; 
2184
2185   if (opt == "H") { // Hits
2186     emcal = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ;
2187     if (!emcal) 
2188       return ;
2189     name = "Hits" ; 
2190   }
2191   
2192   else if ( opt == "S") { // SDigits
2193     emcalmain = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
2194     if (!emcalmain) 
2195       return ;
2196     emcal = dynamic_cast<TFolder*>(emcalmain->FindObject(fHeaderFile)) ;
2197     if (!emcal) 
2198       return ;
2199   }
2200
2201   else if (opt == "D") { // Digits
2202     emcal = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
2203     if (!emcal) 
2204       return ;
2205   }
2206
2207   else if (opt == "RT") { // Tower RecPoints
2208     emcal = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TowerRecPoints")) ;
2209     if (!emcal) 
2210       return ;
2211   }
2212
2213   else if (opt == "RP") { // Preshower RecPoints
2214     emcal = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/PreShoRecPoints")) ;
2215     if (!emcal) 
2216       return ;
2217   }
2218
2219   else {
2220     cerr << "WARNING: AliEMCALGetter::RemoveObjects -> Unknown option " << opt.Data() << endl ; 
2221     return ; 
2222   }
2223   
2224   TObjArray * ar  = dynamic_cast<TObjArray*>(emcal->FindObject(name)) ; 
2225   if (ar) { 
2226     emcal->Remove(ar) ;
2227     ar->Delete() ; 
2228     delete ar ; 
2229   }
2230
2231   if (opt == "S") 
2232     emcalmain->Remove(emcal) ; 
2233   
2234 }
2235
2236 //____________________________________________________________________________ 
2237 void AliEMCALGetter::RemoveSDigits() const 
2238 {
2239   TFolder * emcal= dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
2240   if (!emcal) 
2241     return ;
2242   
2243   emcal->SetOwner() ; 
2244   emcal->Clear() ; 
2245 }