Making Track arguments const
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALGetter.cxx
1 /**************************************************************************
2
3  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4
5  *                                                                        *
6
7  * Author: The ALICE Off-line Project.                                    *
8
9  * Contributors are mentioned in the code where appropriate.              *
10
11  *                                                                        *
12
13  * Permission to use, copy, modify and distribute this software and its   *
14
15  * documentation strictly for non-commercial purposes is hereby granted   *
16
17  * without fee, provided that the above copyright notice appears in all   *
18
19  * copies and that both the copyright notice and this permission notice   *
20
21  * appear in the supporting documentation. The authors make no claims     *
22
23  * about the suitability of this software for any purpose. It is          *
24
25  * provided "as is" without express or implied warranty.                  *
26
27  **************************************************************************/
28
29
30
31 /* $Id:  */
32
33
34
35 /* $Log:
36
37    29.05.2001 Yuri Kharlov:
38
39               Everywhere reading the treese TTree->GetEvent(i)
40
41               is replaced by reading the branches TBranch->GetEntry(0)
42
43 */
44
45 /* $Log:
46
47    08.2002 Dmitri Peressounko:
48
49
50
51 */
52
53
54
55 //_________________________________________________________________________
56
57 //  A singleton. This class should be used in the analysis stage to get 
58
59 //  reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
60
61 //  instead of directly reading them from galice.root file. This container 
62
63 //  ensures, that one reads Digits, made of these particular digits, RecPoints, 
64
65 //  made of these particular RecPoints, TrackSegments and RecParticles. 
66
67 //  This becomes non trivial if there are several identical branches, produced with
68
69 //  different set of parameters. 
70
71 //
72
73 //  An example of how to use (see also class AliEMCALAnalyser):
74
75 //  AliEMCALGetter * gime = AliEMCALGetter::GetInstance("galice.root","test") ;
76
77 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
78
79 //     AliEMCALRecParticle * part = gime->RecParticle(1) ;
80
81 //     ................
82
83 //  please->GetEvent(event) ;    // reads new event from galice.root
84
85 //                  
86
87 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
88
89 //*--         Completely redesigned by Dmitri Peressounko March 2001  
90
91 //
92
93 //*-- YS June 2001 : renamed the original AliEMCALIndexToObject and make
94
95 //*--         systematic usage of TFolders without changing the interface     
96
97 //*-- YS August 2002 : clone PHOS as closely as possible and intoduction
98
99 //                     of new  IO (à la PHOS)
100
101 //////////////////////////////////////////////////////////////////////////////
102
103
104
105 // --- ROOT system ---
106
107 #include "TFile.h"
108
109 #include "TTree.h"
110
111 #include "TROOT.h"
112
113 #include "TObjString.h"
114
115 #include "TFolder.h"
116
117 #include "TParticle.h"
118
119
120
121 // --- Standard library ---
122
123 #include <iostream.h>
124
125
126
127 // --- AliRoot header files ---
128
129 #include "AliRun.h"
130
131 #include "AliConfig.h"
132
133 #include "AliEMCALGetter.h"
134
135 #include "AliEMCAL.h"
136
137 #include "AliEMCALDigitizer.h"
138
139 #include "AliEMCALSDigitizer.h"
140
141 #include "AliEMCALClusterizerv1.h"
142
143 //#include "AliEMCALTrackSegmentMakerv1.h"
144
145 //#include "AliEMCALTrackSegment.h"
146
147 //#include "AliEMCALPIDv1.h" 
148
149 #include "AliEMCALGeometry.h"
150
151
152
153 ClassImp(AliEMCALGetter)
154
155   
156
157   AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ; 
158
159   TFile * AliEMCALGetter::fFile = 0 ; 
160
161
162
163 //____________________________________________________________________________ 
164
165 AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* branchTitle, const Bool_t toSplit)
166
167 {
168
169   // This is the ctor called by GetInstance and the only one that can be used 
170
171   
172
173   if ( fHeaderFile.Contains("_") ) {
174
175     cerr << "AliEMCALGetter::AliEMCALGetter -> Invalid file name (_ not allowed) " << fHeaderFile.Data() << endl ;
176
177     abort() ; 
178
179   }
180
181   
182
183   //Initialize  all data
184
185
186
187   fFailed = kFALSE ;   
188
189   fDebug  = 0 ; 
190
191   fAlice  = 0 ; 
192
193
194
195   fToSplit    = toSplit ;
196
197   fHeaderFile = headerFile ; 
198
199
200
201   fPrimaries = new TObjArray(1) ;
202
203
204
205   fModuleFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Configuration/Modules")); 
206
207   fPrimariesFolder = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data")); 
208
209   fHitsFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/Hits")); 
210
211   fSDigitsFolder   = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/SDigits")); 
212
213   fDigitsFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/Data")); 
214
215   fRecoFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/RecData")); 
216
217   //fQAFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Conditions/QA")); 
218
219   fTasksFolder     = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Tasks")) ; 
220
221
222
223   //Set titles to branches and create PHOS specific folders
224
225   SetTitle(branchTitle) ;
226
227   
228
229   if ( fHeaderFile != "aliroot"  ) { // to call the getter without a file
230
231     //open headers file
232
233     fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
234
235   
236
237     if(!fFile){    //if file was not opened yet, read gAlice
238
239       fFile = TFile::Open(fHeaderFile.Data(), "update") ;   
240
241       if (!fFile->IsOpen()) {
242
243         cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot open " << fHeaderFile.Data() << endl ; 
244
245         fFailed = kTRUE ;
246
247         return ;  
248
249       }
250
251       gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
252
253     }
254
255   }
256
257   
258
259   if (!gAlice) {
260
261     cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ; 
262
263     fFailed = kTRUE ;
264
265     return ; 
266
267   }
268
269   if (!EMCAL()) {
270
271     if (fDebug)
272
273       cout << "INFO: AliEMCALGetter -> Posting EMCAL to Folders" << endl ; 
274
275     if (gAlice->GetDetector("EMCAL")) {
276
277       AliConfig * conf = AliConfig::Instance() ;
278
279       conf->Add(static_cast<AliDetector*>(gAlice->GetDetector("EMCAL"))) ; 
280
281       conf->Add(static_cast<AliModule*>(gAlice->GetDetector("EMCAL"))) ;
282
283     }
284
285     else 
286
287       cerr << "ERROR: AliEMCALGetter -> detector EMCAL not found" << endl ;
288
289   }
290
291   
292
293   fDebug=0;
294
295 }
296
297
298
299 //____________________________________________________________________________ 
300
301 AliEMCALGetter::~AliEMCALGetter()
302
303 {
304
305   if (fPrimaries) {
306
307     fPrimaries->Delete() ; 
308
309     delete fPrimaries ; 
310
311   }
312
313
314
315   TFolder * emcalF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
316
317   TCollection * folderslist = emcalF->GetListOfFolders() ; 
318
319   TIter next(folderslist) ; 
320
321   TFolder * folder = 0 ; 
322
323   while ( (folder = static_cast<TFolder*>(next())) ) 
324
325     emcalF->Remove(folder) ; 
326
327
328
329   if (fFile) { 
330
331     fFile->Close() ;  
332
333     delete fFile ; 
334
335     fFile = 0 ;
336
337   }
338
339   fgObjGetter = 0 ; 
340
341
342
343 }
344
345
346
347 //____________________________________________________________________________ 
348
349 void AliEMCALGetter::CloseFile()
350
351 {
352
353   delete gAlice ;  
354
355   gAlice = 0 ; 
356
357   delete fAlice ; 
358
359   fAlice = 0 ; 
360
361 }
362
363
364
365 //____________________________________________________________________________ 
366
367 const TFolder * AliEMCALGetter::Folder(const TString what) const {
368
369
370
371   // returns the EMCAL folder required by what
372
373   // what = hits, sdigits, digits
374
375
376
377   if ( what == "hits" ) 
378
379     return dynamic_cast<const TFolder *>(fHitsFolder->FindObject("EMCAL")) ; 
380
381   else if ( what == "sdigits" ) 
382
383     return  dynamic_cast<const TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ; 
384
385   else if ( what == "digits" ) 
386
387     return  dynamic_cast<const TFolder *>(fDigitsFolder->FindObject("EMCAL")) ; 
388
389   else {
390
391     cerr << "ERROR: AliEMCALGetter::GetFolder -> " << what.Data() << " illegal option (hits, sdigits, digits) " << endl ; 
392
393     return 0 ; 
394
395   }
396
397 }
398
399
400
401 //____________________________________________________________________________ 
402
403 AliEMCALGetter * AliEMCALGetter::GetInstance()
404
405 {
406
407   // Returns the pointer of the unique instance already defined
408
409   
410
411   if ( fgObjGetter ) {
412
413     return fgObjGetter ;
414
415   }
416
417   else {
418
419     // cout << "AliEMCALGetter::GetInstance ERROR: not yet initialized" << endl ;
420
421     return 0 ;
422
423   }
424
425 }
426
427
428
429 //____________________________________________________________________________ 
430
431 AliEMCALGetter * AliEMCALGetter::GetInstance(const char* headerFile,
432
433                                              const char* branchTitle,
434
435                                              const Bool_t toSplit)
436
437 {
438
439   // Creates and returns the pointer of the unique instance
440
441   // Must be called only when the environment has changed 
442
443
444
445   if(!fgObjGetter){
446
447     fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
448
449     if(fgObjGetter->fFailed)
450
451       return 0;
452
453     else
454
455       return fgObjGetter ;
456
457   }
458
459
460
461   //First checks, if header file already opened
462
463   if(!fgObjGetter->fFile){
464
465      fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
466
467     if(fgObjGetter->fFailed)
468
469       return 0;
470
471     else
472
473       return fgObjGetter ;
474
475   }
476
477  
478
479   if(fgObjGetter->fHeaderFile.CompareTo(headerFile)==0){ //Opened the same header file   
480
481     if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0)&&   //Open the same branch title
482
483        (toSplit==fgObjGetter->fToSplit)){                          //Nothing should be cleaned
484
485       return fgObjGetter ;
486
487     }
488
489     else{ //Clean all data and AliEMCAL...zers
490
491       if(fgObjGetter->fToSplit)
492
493         fgObjGetter->CloseSplitFiles() ;          
494
495       fgObjGetter->CleanWhiteBoard() ;
496
497       fgObjGetter->fToSplit = toSplit ;
498
499       fgObjGetter->SetTitle(branchTitle) ;
500
501       return fgObjGetter ;
502
503     }
504
505   }
506
507   else{  //Close already opened files, clean memory and open new header file
508
509     if(gAlice)
510
511       delete gAlice ;
512
513     gAlice= 0;
514
515     if(fgObjGetter->fFile){
516
517       fgObjGetter->fFile->Close() ;
518
519       fgObjGetter->fFile=0;
520
521     }
522
523     if(fgObjGetter->fToSplit)
524
525       fgObjGetter->CloseSplitFiles() ;
526
527     fgObjGetter->CleanWhiteBoard() ;    
528
529     fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
530
531     return fgObjGetter ; 
532
533   }
534
535   return fgObjGetter ; 
536
537   
538
539 }
540
541
542
543 //____________________________________________________________________________ 
544
545 const Bool_t AliEMCALGetter::BranchExists(const TString recName) const
546
547 {
548
549   //Looks in the tree Tree"name" if branch with current name olready exists
550
551   
552
553   TString filename("") ;
554
555   TString name, dataname, zername;
556
557   if(recName == "SDigits"){
558
559     filename=fSDigitsFileName ;
560
561     name = "TreeS0" ;
562
563     dataname = "PHOS" ;
564
565     zername = "AliPHOSSDigitizer" ;
566
567   }
568
569   else
570
571     if(recName == "Digits"){
572
573       filename=fDigitsFileName ;
574
575       name = "TreeD0" ;
576
577       dataname = "PHOS" ;
578
579       zername = "AliPHOSDigitizer" ;
580
581     }
582
583     else
584
585       if(recName =="RecPoints"){
586
587         filename=fRecPointsFileName ;
588
589         name = "TreeR0" ;
590
591         dataname = "PHOSEmcRP" ;
592
593         zername = "AliPHOSClusterizer" ;
594
595       }
596
597       else
598
599         if(recName == "TrackSegments"){
600
601           filename=fTrackSegmentsFileName ;
602
603           name = "TreeR0" ;
604
605           dataname = "PHOSTS" ;
606
607           zername = "AliPHOSTrackSegmentMaker" ;
608
609         }        
610
611         else
612
613           if(recName == "RecParticles"){
614
615             filename= fRecParticlesFileName ;
616
617             name = "TreeR0" ;
618
619             dataname = "PHOSRP" ;
620
621             zername = "AliPHOSPID" ;
622
623           }
624
625           else
626
627             return kFALSE ;
628
629   
630
631   TFile * file ;
632
633   TTree * tree ;
634
635   if(fToSplit){
636
637     file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
638
639     if(!file)
640
641       file = TFile::Open(fSDigitsFileName.Data(),"update");
642
643   }
644
645   else
646
647     file = fFile ;
648
649   
650
651   tree = (TTree *)file->Get(name.Data()) ;
652
653   
654
655   if(!tree ) 
656
657     return kFALSE ;
658
659
660
661   TObjArray * lob = static_cast<TObjArray*>(tree->GetListOfBranches()) ;
662
663   TIter next(lob) ; 
664
665   TBranch * branch = 0 ;  
666
667   TString titleName(fBranchTitle);
668
669   titleName+=":";
670
671   while ((branch = (static_cast<TBranch*>(next())))) {
672
673     TString branchName(branch->GetName() ) ; 
674
675     TString branchTitle(branch->GetTitle() ) ;  
676
677     if ( branchName.BeginsWith(dataname) && branchTitle.BeginsWith(fBranchTitle) ){  
678
679       cerr << "WARNING: AliEMCALGetter::BranchExists -> branch " << dataname.Data() << " with title " << fBranchTitle << " already exits in "
680
681            << name.Data() << endl;
682
683       return kTRUE ;
684
685     }
686
687     if ( branchName.BeginsWith(zername) &&  branchTitle.BeginsWith(titleName) ){
688
689       cerr << "WARNING: AliEMCALGetter::BranchExists -> branch AliEMCAL... with title " << branch->GetTitle() << " already exits in "
690
691            << name.Data() << endl;     
692
693       return kTRUE ; 
694
695     }
696
697   }
698
699     //We can't delete three if gAlice points to it... To be redisigned somehow???!!!
700
701   if(!fToSplit){
702
703     if(name.Contains("TreeS"))
704
705       if(tree!=gAlice->TreeS())
706
707         tree->Delete();
708
709     if(name.Contains("TreeD"))
710
711       if(tree!=gAlice->TreeD())
712
713         tree->Delete();
714
715     if(name.Contains("TreeR"))
716
717       if(tree!=gAlice->TreeR())
718
719         tree->Delete();    
720
721   }
722
723   return kFALSE ;
724
725   
726
727 }
728
729
730
731 //____________________________________________________________________________ 
732
733 void AliEMCALGetter::ListBranches(Int_t event) const  
734
735 {
736
737   
738
739   TBranch * branch = 0 ; 
740
741   if (gAlice->GetEvent(event) == -1)
742
743     return ; 
744
745
746
747   TTree * t =  gAlice->TreeH() ; 
748
749   if(t){
750
751     cout << "INFO: AliEMCALGetter::ListBranches -> ****** Hits    : " << endl ; 
752
753     TObjArray * lob = t->GetListOfBranches() ;
754
755     TIter next(lob) ; 
756
757     while ( (branch = static_cast<TBranch*>(next())) )
758
759       cout << "             " << branch->GetName() << endl ; 
760
761   } else 
762
763     cerr << "WARNING::AliEMCALGetter::ListBranches -> TreeH not found for event " << event << endl ;  
764
765   
766
767   
768
769   t = gAlice->TreeS() ;
770
771   if(t){
772
773     cout << "INFO: AliEMCALGetter::ListBranches -> ****** SDigits : " << endl ; 
774
775     TObjArray * lob = t->GetListOfBranches() ;
776
777     TIter next(lob) ; 
778
779     while ( (branch = static_cast<TBranch*>(next())) )
780
781       cout << "             " << branch->GetName() << " " << branch->GetTitle() << endl ; 
782
783   } else 
784
785     cerr << "WARNING::AliEMCALGetter::ListBranches -> TreeS not found for event " << event << endl ;  
786
787     
788
789   t = gAlice->TreeD() ;
790
791   if(t){
792
793     cout << "INFO: AliEMCALGetter::ListBranches -> ****** Digits  : " << endl ; 
794
795     TObjArray * lob = t->GetListOfBranches() ;
796
797     TIter next(lob) ; 
798
799     while ( (branch = static_cast<TBranch*>(next())) )
800
801       cout << "             " << branch->GetName() << " " << branch->GetTitle() << endl ; 
802
803   } else 
804
805     cerr << "WARNING::AliEMCALGetter::ListBranches -> TreeD not found for event " << event << endl ;  
806
807   
808
809
810
811   t = gAlice->TreeR() ;
812
813   if(t){
814
815     cout << "INFO: AliEMCALGetter::ListBranches -> ****** Recon   : " << endl ; 
816
817     TObjArray * lob = t->GetListOfBranches() ;
818
819     TIter next(lob) ; 
820
821     while ( (branch = static_cast<TBranch*>(next())) )
822
823       cout << "             " << branch->GetName() << " " << branch->GetTitle() << endl ; 
824
825   } else 
826
827     cerr << "WARNING::AliEMCALGetter::ListBranches -> TreeR not found for event " << event << endl ;  
828
829   
830
831 }
832
833
834
835 //____________________________________________________________________________ 
836
837 void AliEMCALGetter::NewBranch(TString name, Int_t event)  
838
839 {
840
841   fBranchTitle = fSDigitsTitle = fDigitsTitle = fRecPointsTitle = fTrackSegmentsTitle = fRecParticlesTitle =  name ; 
842
843   Event(event) ; 
844
845 }
846
847
848
849 //____________________________________________________________________________ 
850
851 Bool_t AliEMCALGetter::NewFile(TString name)  
852
853 {
854
855   fHeaderFile = name ; 
856
857   fFile->Close() ; 
858
859   fFailed = kFALSE; 
860
861
862
863   fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
864
865   if(!fFile) {    //if file was not opened yet, read gAlice
866
867     fFile = TFile::Open(fHeaderFile.Data(),"update") ;
868
869     if (!fFile->IsOpen()) {
870
871       cerr << "ERROR : AliEMCALGetter::NewFile -> Cannot open " << fHeaderFile.Data() << endl ; 
872
873       fFailed = kTRUE ;
874
875       return fFailed ;  
876
877     }
878
879     gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
880
881   } 
882
883   
884
885   if (!gAlice) {
886
887     cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ; 
888
889     fFailed = kTRUE ;
890
891     return fFailed ; 
892
893   }
894
895   return fFailed ; 
896
897 }
898
899
900
901 //____________________________________________________________________________ 
902
903 const AliEMCAL * AliEMCALGetter::EMCAL() 
904
905 {
906
907   // returns the EMCAL object 
908
909   AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(fModuleFolder->FindObject("EMCAL")) ;  
910
911   if (!emcal) 
912
913     if (fDebug)
914
915       cout << "WARNING: AliEMCALGetter::EMCAL -> EMCAL module not found in Folders" << endl ; 
916
917   return emcal ; 
918
919 }  
920
921
922
923 //____________________________________________________________________________ 
924
925 AliEMCALGeometry * AliEMCALGetter::EMCALGeometry() 
926
927 {
928
929   AliEMCALGeometry * rv = 0 ; 
930
931   if (EMCAL() )
932
933     rv =  EMCAL()->GetGeometry() ;
934
935   return rv ; 
936
937
938
939
940
941 //____________________________________________________________________________ 
942
943 const Bool_t AliEMCALGetter::PostPrimaries(void) const 
944
945 {  //------- Primaries ----------------------
946
947
948
949   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
950
951   
952
953   TFolder * primariesFolder = dynamic_cast<TFolder*>(fPrimariesFolder->FindObject("Primaries")) ; 
954
955   if ( !primariesFolder ) {
956
957     if (fDebug) {
958
959       cout << "WARNING: AliEMCALGetter::Post Primaries -> Folder //" << fPrimariesFolder->GetName() << "/Primaries/ not found!" << endl;
960
961       cout << "INFO:    AliEMCALGetter::Post Primaries -> Adding Folder //" << fPrimariesFolder->GetName() << "/Primaries/"  << endl;
962
963     }
964
965     primariesFolder = fPrimariesFolder->AddFolder("Primaries", "Primaries particles from TreeK") ; 
966
967   }    
968
969   TClonesArray *primaries=  new TClonesArray("TParticle",1000) ;
970
971   primaries->SetName("Primaries") ;
972
973   primariesFolder->Add(primaries) ; 
974
975   
976
977   return kTRUE;
978
979
980
981
982
983 //____________________________________________________________________________ 
984
985 TObject** AliEMCALGetter::PrimariesRef(void) const 
986
987 {  //------- Primaries ----------------------
988
989
990
991   
992
993   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
994
995   if ( !fPrimariesFolder ) {
996
997     cerr << "ERROR: AliEMCALGetter::PrimariesRef -> Folder //" << fPrimariesFolder << " not found!" << endl;
998
999     abort() ;
1000
1001   }    
1002
1003  
1004
1005   TFolder * primariesFolder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ;
1006
1007   if ( !primariesFolder ) {
1008
1009     cerr << "ERROR: AliEMCALGetter::PrimariesRef -> Folder //" << fPrimariesFolder << "/Primaries/ not found!" << endl;  
1010
1011     abort() ;
1012
1013   }
1014
1015  
1016
1017   TObject * p = primariesFolder->FindObject("Primaries") ;
1018
1019   if(!p) {
1020
1021     cerr << "ERROR: AliEMCALGetter::PrimariesRef -> " << primariesFolder->GetName() << "/Primaries not found !" << endl ; 
1022
1023     abort() ;
1024
1025   }
1026
1027   else
1028
1029     return primariesFolder->GetListOfFolders()->GetObjectRef(p) ;
1030
1031 }
1032
1033
1034
1035 //____________________________________________________________________________ 
1036
1037 const Bool_t AliEMCALGetter::PostHits(void) const 
1038
1039 {  //------- Hits ----------------------
1040
1041
1042
1043   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
1044
1045   
1046
1047   TFolder * emcalFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ; 
1048
1049   if ( !emcalFolder ) {
1050
1051     if (fDebug) {
1052
1053       cout << "WARNING: AliEMCALGetter::Post H -> Folder //" << fHitsFolder << "/EMCAL/ not found!" << endl;
1054
1055       cout << "INFO:    AliEMCALGetter::Post H -> Adding Folder //" << fHitsFolder << "/EMCAL/"  << endl;
1056
1057     }
1058
1059     emcalFolder = fHitsFolder->AddFolder("EMCAL", "Hits from EMCAL") ; 
1060
1061   }    
1062
1063   TClonesArray *hits=  new TClonesArray("AliEMCALHit",1000) ;
1064
1065   hits->SetName("Hits") ;
1066
1067   emcalFolder->Add(hits) ; 
1068
1069   
1070
1071   return kTRUE;
1072
1073
1074
1075
1076
1077 //____________________________________________________________________________ 
1078
1079 TObject ** AliEMCALGetter::HitsRef(void) const 
1080
1081 {  //------- Hits ----------------------
1082
1083
1084
1085   
1086
1087   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
1088
1089   if ( !fHitsFolder ) {
1090
1091     cerr << "ERROR: AliEMCALGetter::Post H -> Folder //" << fHitsFolder << " not found!" << endl;
1092
1093     return 0;
1094
1095   }    
1096
1097  
1098
1099   TFolder * emcalFolder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("EMCAL")) ;
1100
1101   if ( !emcalFolder ) {
1102
1103     cerr << "ERROR: AliEMCALGetter::Post HRef -> Folder //" << fHitsFolder << "/EMCAL/ not found!" << endl;  
1104
1105     return 0;
1106
1107   }
1108
1109  
1110
1111   TObject * h = emcalFolder->FindObject("Hits") ;
1112
1113   if(!h) {
1114
1115     cerr << "ERROR: AliEMCALGetter::HRef -> " << emcalFolder->GetName() << "/Hits not found !" << endl ; 
1116
1117     return 0 ;
1118
1119   }
1120
1121   else
1122
1123     return emcalFolder->GetListOfFolders()->GetObjectRef(h) ;
1124
1125 }
1126
1127
1128
1129 //____________________________________________________________________________ 
1130
1131 const Bool_t AliEMCALGetter::PostSDigits(const char * name, const char * headerFile) const 
1132
1133 {  //---------- SDigits -------------------------
1134
1135
1136
1137   
1138
1139   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/headerFile/sdigitsname
1140
1141   // because you can have sdigits from several hit files for mixing
1142
1143   
1144
1145   TFolder * emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
1146
1147   if ( !emcalFolder ) {
1148
1149     if (fDebug) {
1150
1151       cout << "WARNING: AliEMCALGetter::Post S -> Folder //" << fSDigitsFolder << "/EMCAL/ not found!" << endl;
1152
1153       cout << "INFO:    AliEMCALGetter::Post S -> Adding Folder //" << fHitsFolder << "/EMCAL/" << endl;
1154
1155     }
1156
1157     emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; 
1158
1159   }    
1160
1161
1162
1163   TString subdir(headerFile) ;
1164
1165   subdir.ReplaceAll("/", "_") ; 
1166
1167   TFolder * emcalSubFolder = dynamic_cast<TFolder*>(emcalFolder->FindObject(subdir)) ; 
1168
1169   if ( !emcalSubFolder ) 
1170
1171     emcalSubFolder = emcalFolder->AddFolder(subdir, ""); 
1172
1173
1174
1175   
1176
1177   TObject * sd  = emcalSubFolder->FindObject(name); 
1178
1179   if ( !sd ) {
1180
1181     TClonesArray * sdigits = new TClonesArray("AliEMCALDigit",1) ;
1182
1183     sdigits->SetName(name) ;
1184
1185     emcalSubFolder->Add(sdigits) ;
1186
1187   }
1188
1189   
1190
1191   return kTRUE;
1192
1193
1194
1195 //____________________________________________________________________________ 
1196
1197 TObject ** AliEMCALGetter::SDigitsRef(const char * name, const char * file) const 
1198
1199 {  //------- SDigits ----------------------
1200
1201   
1202
1203   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/filename/SDigits
1204
1205
1206
1207   if ( !fSDigitsFolder ) {
1208
1209     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //" << fSDigitsFolder << " not found!" << endl;
1210
1211     abort() ;
1212
1213   }    
1214
1215  
1216
1217   TFolder * emcalFolder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
1218
1219   if ( !emcalFolder ) {
1220
1221     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //" << fSDigitsFolder << "/EMCAL/ not found!" << endl;
1222
1223     abort() ;
1224
1225   }
1226
1227
1228
1229   TFolder * emcalSubFolder = 0 ;
1230
1231   if(file)
1232
1233     emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(file)) ;
1234
1235   else
1236
1237     emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(fHeaderFile)) ;
1238
1239   
1240
1241   if(!emcalSubFolder) {
1242
1243     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //Folders/RunMC/Event/Data/EMCAL/" << file << "not found!" << endl;
1244
1245     abort() ;
1246
1247   }
1248
1249
1250
1251   TObject * dis = emcalSubFolder->FindObject(name) ;
1252
1253   if(!dis) {
1254
1255     cerr << "ERROR: AliEMCALGetter::DigitesSRef -> object " << name << " not found! " << endl ; 
1256
1257     abort() ;
1258
1259   }
1260
1261   else
1262
1263     return emcalSubFolder->GetListOfFolders()->GetObjectRef(dis) ;
1264
1265
1266
1267 }
1268
1269
1270
1271 //____________________________________________________________________________ 
1272
1273 const Bool_t AliEMCALGetter::PostSDigitizer(AliEMCALSDigitizer * sdigitizer) const 
1274
1275 {  //---------- SDigitizer -------------------------
1276
1277     
1278
1279   // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
1280
1281
1282
1283
1284
1285   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
1286
1287
1288
1289   if ( !sd ) {
1290
1291     cerr << "ERROR: AliEMCALGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
1292
1293     return kFALSE ;
1294
1295   }        
1296
1297   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
1298
1299   if ( !emcal )  {
1300
1301     if (fDebug) {
1302
1303       cout <<"WARNING: AliEMCALGetter::Post Ser ->//" << fTasksFolder << "/SDigitizer/EMCAL/ not found!" << endl;  
1304
1305       cout <<"INFO: AliEMCALGetter::Post Ser -> Adding //" << fTasksFolder << "/SDigitizer/EMCAL/" << endl;
1306
1307     }
1308
1309     emcal = new TTask("EMCAL", "") ; 
1310
1311     sd->Add(emcal) ; 
1312
1313   } 
1314
1315   AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdigitizer->GetName() )); 
1316
1317   if (emcalsd) { 
1318
1319     if (fDebug)
1320
1321       cout << "INFO: AliEMCALGetter::Post Ser -> Task " << sdigitizer->GetName() << " already exists" << endl ; 
1322
1323     emcal->GetListOfTasks()->Remove(emcalsd) ;
1324
1325   }
1326
1327   emcal->Add(sdigitizer) ;      
1328
1329   return kTRUE; 
1330
1331   
1332
1333 }
1334
1335
1336
1337 //____________________________________________________________________________ 
1338
1339 TObject ** AliEMCALGetter::SDigitizerRef(const char * name) const 
1340
1341 {  
1342
1343
1344
1345   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
1346
1347   if ( !sd ) {
1348
1349     cerr << "ERROR: AliEMCALGetter::Post SerRef -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
1350
1351     abort();
1352
1353   }        
1354
1355
1356
1357   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
1358
1359   if ( !emcal )  {
1360
1361     cerr <<"ERROR: AliEMCALGetter::Post SerRef ->  //" << fTasksFolder << "/SDigitizer/EMCAL not found!" << endl;
1362
1363     abort();
1364
1365   }        
1366
1367
1368
1369   TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ; 
1370
1371
1372
1373   return emcal->GetListOfTasks()->GetObjectRef(task) ;
1374
1375
1376
1377 }
1378
1379
1380
1381 //____________________________________________________________________________ 
1382
1383 const Bool_t AliEMCALGetter::PostSDigitizer(const char * name, const char * file) const 
1384
1385 {  //---------- SDigitizer -------------------------
1386
1387   
1388
1389  // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
1390
1391
1392
1393   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
1394
1395   if ( !sd ) {
1396
1397     cerr << "ERROR: AliEMCALGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
1398
1399     return kFALSE ;
1400
1401   }        
1402
1403
1404
1405   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
1406
1407   if ( !emcal )  {
1408
1409     if (fDebug) {
1410
1411       cout <<"WARNING: AliEMCALGetter::Post Ser ->  //" << fTasksFolder << "/SDigitizer/EMCAL/ not found!" << endl;
1412
1413       cout <<"INFO: AliEMCALGetter::Post Ser -> Adding  //" << fTasksFolder << "/SDigitizer/EMCAL" << endl;
1414
1415     }
1416
1417     emcal = new TTask("EMCAL", "") ; 
1418
1419     sd->Add(emcal) ; 
1420
1421   } 
1422
1423
1424
1425   TString sdname(name) ;
1426
1427   sdname.Append(":") ;
1428
1429   sdname.Append(file);
1430
1431   sdname.ReplaceAll("/","_") ; 
1432
1433   AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdname )); 
1434
1435   if (!emcalsd) {
1436
1437     emcalsd = new AliEMCALSDigitizer() ;  
1438
1439     //Note, we can not call constructor with parameters: it will call Getter and screw up everething
1440
1441     emcalsd->SetName(sdname) ;
1442
1443     emcalsd->SetTitle(file) ;
1444
1445     emcal->Add(emcalsd) ;       
1446
1447   }
1448
1449   return kTRUE; 
1450
1451   
1452
1453 }
1454
1455
1456
1457 //____________________________________________________________________________ 
1458
1459 const Bool_t AliEMCALGetter::PostDigits(const char * name) const 
1460
1461 {  //---------- Digits -------------------------
1462
1463
1464
1465   // the hierarchy is //Folders/Run/Event/Data/EMCAL/SDigits/name
1466
1467
1468
1469   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
1470
1471
1472
1473   if ( !emcalFolder ) {
1474
1475     if (fDebug) {
1476
1477       cout << "WARNING: AliEMCALGetter::Post D -> Folder //" << fDigitsFolder << "/EMCAL/ not found!" << endl;
1478
1479       cout << "INFO:    AliEMCALGetter::Post D -> Adding Folder //" << fDigitsFolder << "/EMCAL/" << endl;
1480
1481     }
1482
1483     emcalFolder = fDigitsFolder->AddFolder("EMCAL", "Digits from EMCAL") ;  
1484
1485   }    
1486
1487  
1488
1489   TObject*  dig = emcalFolder->FindObject( name ) ;
1490
1491   if ( !dig ) {
1492
1493     TClonesArray * digits = new TClonesArray("AliEMCALDigit",1000) ;
1494
1495     digits->SetName(name) ;
1496
1497     emcalFolder->Add(digits) ;  
1498
1499   }
1500
1501   return kTRUE; 
1502
1503 }
1504
1505
1506
1507 //____________________________________________________________________________ 
1508
1509 TObject ** AliEMCALGetter::DigitsRef(const char * name) const 
1510
1511 { //------- Digits ----------------------
1512
1513   
1514
1515   // the hierarchy is //Folders/Run/Event/Data/EMCAL/Digits/name
1516
1517
1518
1519   if ( !fDigitsFolder ) {
1520
1521     cerr << "ERROR: AliEMCALGetter::Post DRef -> Folder //" << fDigitsFolder << " not found!" << endl;
1522
1523     abort() ;
1524
1525   }    
1526
1527   
1528
1529   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ; 
1530
1531   if ( !emcalFolder ) {
1532
1533     cerr << "ERROR: AliEMCALGetter::DRef -> Folder //" << fDigitsFolder << "/EMCAL/ not found!" << endl;
1534
1535     abort() ;
1536
1537   }    
1538
1539
1540
1541   TObject * d = emcalFolder->FindObject(name) ;
1542
1543   if(!d) {
1544
1545     cerr << "ERROR: AliEMCALGetter::DigitsRef -> object " << name << " not found! " << endl ; 
1546
1547     abort() ;
1548
1549   }   
1550
1551   else
1552
1553     return emcalFolder->GetListOfFolders()->GetObjectRef(d) ;
1554
1555
1556
1557 }
1558
1559
1560
1561 //____________________________________________________________________________ 
1562
1563 const Bool_t AliEMCALGetter::PostDigitizer(AliEMCALDigitizer * digitizer) const 
1564
1565 {  //---------- Digitizer -------------------------
1566
1567   
1568
1569   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
1570
1571
1572
1573   if ( !sd ) {
1574
1575     cerr << "ERROR: AliEMCALGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
1576
1577     return kFALSE ;
1578
1579   }        
1580
1581   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
1582
1583   if ( !emcal )  {
1584
1585     if (fDebug) {
1586
1587       cout <<"WARNING: AliEMCALGetter::Post Der ->  //" << fTasksFolder << "/Digitizer/EMCAL not found!" << endl;
1588
1589       cout <<"INFO: AliEMCALGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/EMCAL" << endl; 
1590
1591     }
1592
1593     emcal = new TTask("EMCAL", "") ; 
1594
1595     sd->Add(emcal) ; 
1596
1597   } 
1598
1599
1600
1601     AliEMCALDigitizer * emcald = dynamic_cast<AliEMCALDigitizer*>(emcal->GetListOfTasks()->FindObject(digitizer->GetName())) ; 
1602
1603     if (emcald) { 
1604
1605       emcald->Delete() ;
1606
1607       emcal->GetListOfTasks()->Remove(emcald) ;
1608
1609     }
1610
1611     emcal->Add(digitizer) ; 
1612
1613     return kTRUE; 
1614
1615 }  
1616
1617
1618
1619 //____________________________________________________________________________ 
1620
1621 const Bool_t AliEMCALGetter::PostDigitizer(const char * name) const 
1622
1623 {  //---------- Digitizer -------------------------
1624
1625   
1626
1627  // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
1628
1629
1630
1631   TTask * d  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
1632
1633   if ( !d ) {
1634
1635     cerr << "ERROR: AliEMCALGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
1636
1637     return kFALSE ;
1638
1639   }        
1640
1641
1642
1643   TTask * emcal = dynamic_cast<TTask*>(d->GetListOfTasks()->FindObject("EMCAL")) ; 
1644
1645   if ( !emcal )  {
1646
1647     if (fDebug) {
1648
1649       cout <<"WARNING: AliEMCALGetter::Post Der -> //" << fTasksFolder << "/Digitizer/EMCAL not found!" << endl; 
1650
1651       cout <<"INFO: AliEMCALGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/EMCAL" << endl;
1652
1653     }
1654
1655     emcal = new TTask("EMCAL", "") ; 
1656
1657     d->Add(emcal) ; 
1658
1659
1660
1661
1662
1663   AliEMCALDigitizer * emcald = dynamic_cast<AliEMCALDigitizer*>(emcal->GetListOfTasks()->FindObject(name)) ; 
1664
1665   if (!emcald) { 
1666
1667     emcald = new AliEMCALDigitizer() ;
1668
1669     emcald->SetName(fDigitsTitle) ;
1670
1671     emcald->SetTitle(fHeaderFile) ;
1672
1673     emcal->Add(emcald) ;
1674
1675   }
1676
1677   return kTRUE;  
1678
1679 }
1680
1681
1682
1683 //____________________________________________________________________________ 
1684
1685 TObject ** AliEMCALGetter::DigitizerRef(const char * name) const 
1686
1687 {  
1688
1689   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
1690
1691   if ( !sd ) {
1692
1693     cerr << "ERROR: AliEMCALGetter::Post DerRef -> Task //" << fTasksFolder->GetName() << "/Digitizer not found!" << endl;
1694
1695     abort();
1696
1697   }        
1698
1699
1700
1701   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
1702
1703   if ( !emcal )  {
1704
1705     cerr <<"ERROR: AliEMCALGetter::Post DerRef ->  //" << fTasksFolder->GetName() << "/Digitizer/EMCAL" << endl;
1706
1707     abort();
1708
1709   }        
1710
1711
1712
1713   TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ; 
1714
1715
1716
1717   return emcal->GetListOfTasks()->GetObjectRef(task) ;
1718
1719
1720
1721 }
1722
1723  
1724
1725 //____________________________________________________________________________ 
1726
1727 const Bool_t AliEMCALGetter::PostRecPoints(const char * name) const 
1728
1729 { // -------------- RecPoints -------------------------------------------
1730
1731   
1732
1733   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TowerRecPoints/name
1734
1735   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/PreShowerRecPoints/name
1736
1737
1738
1739   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ; 
1740
1741   
1742
1743   if ( !emcalFolder ) {
1744
1745     if (fDebug) {
1746
1747       cout << "WARNING: AliEMCALGetter::Post RPo -> Folder //" << fRecoFolder << "/EMCAL/ not found!" << endl;
1748
1749       cout << "INFO:    AliEMCALGetter::Post Rpo -> Adding Folder //" << fRecoFolder << "/EMCAL/" << endl;
1750
1751     }
1752
1753     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;  
1754
1755   }    
1756
1757   
1758
1759   // Tower RecPoints 
1760
1761   TFolder * emcalRPoTowerFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("TowerRecPoints")) ;
1762
1763   if ( !emcalRPoTowerFolder ) {
1764
1765     if (fDebug) {
1766
1767       cout << "WARNING: AliEMCALGetter::Post RPo -> Folder //" << fRecoFolder << "/EMCAL/TowerRecPoints/ not found!" << endl;
1768
1769       cout << "INFO:    AliEMCALGetter::Post Rpo -> Adding Folder //" << fRecoFolder << "/EMCAL/TowerRecPoints not found!" << endl;
1770
1771     }
1772
1773     emcalRPoTowerFolder = emcalFolder->AddFolder("TowerRecPoints", "Tower RecPoints from EMCAL") ;  
1774
1775   }    
1776
1777   
1778
1779   TObject * erp = emcalFolder->FindObject( name ) ;
1780
1781   if ( !erp )   {
1782
1783     TObjArray * towerrp = new TObjArray(100) ;
1784
1785     towerrp->SetName(name) ;
1786
1787     emcalRPoTowerFolder->Add(towerrp) ;  
1788
1789   }
1790
1791
1792
1793   // Pre Shower RecPoints 
1794
1795   TFolder * emcalRPoPreShoFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("PreShowerRecPoints")) ;
1796
1797   if ( !emcalRPoPreShoFolder ) {
1798
1799     if (fDebug) {
1800
1801       cout << "WARNING: AliEMCALGetter::Post RPo -> Folder //" << fRecoFolder << "/EMCAL/PreShowerRecPoints/ not found!" << endl;
1802
1803       cout << "INFO:    AliEMCALGetter::Post Rpo -> Adding Folder //" << fRecoFolder << "/EMCAL/PreShowerRecPoints/" << endl;
1804
1805     }
1806
1807     emcalRPoPreShoFolder = emcalFolder->AddFolder("PreShowerRecPoints", "PreSho RecPoints from EMCAL") ;  
1808
1809   }    
1810
1811   
1812
1813   TObject * crp =  emcalRPoPreShoFolder->FindObject( name ) ;
1814
1815   if ( !crp )   {
1816
1817     TObjArray * preshorp = new TObjArray(100) ;
1818
1819     preshorp->SetName(name) ;
1820
1821     emcalRPoPreShoFolder->Add(preshorp) ;  
1822
1823   }
1824
1825   return kTRUE; 
1826
1827 }
1828
1829
1830
1831 //____________________________________________________________________________ 
1832
1833 TObject ** AliEMCALGetter::TowerRecPointsRef(const char * name) const 
1834
1835 { // -------------- RecPoints -------------------------------------------
1836
1837   
1838
1839   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TowerRecPoints/name
1840
1841    
1842
1843   if ( !fRecoFolder ) {
1844
1845     cerr << "ERROR: AliEMCALGetter::TowerRecPointsRef -> Folder //" << fRecoFolder << " not found!" << endl;
1846
1847     abort() ; 
1848
1849   }    
1850
1851
1852
1853   TFolder * towerFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TowerRecPoints")) ; 
1854
1855   if ( !towerFolder ) {
1856
1857     cerr << "ERROR: AliEMCALGetter::TowerRecPointsRef -> Folder //" << fRecoFolder << "/EMCAL/TowerRecPoints/ not found!" << endl;
1858
1859     abort() ;
1860
1861   }    
1862
1863
1864
1865
1866
1867   TObject * trp = towerFolder->FindObject(name ) ;
1868
1869   if ( !trp )   {
1870
1871     cerr << "ERROR: AliEMCALGetter::TowerRecPointsRef -> Object " << name << " not found!" << endl  ;
1872
1873     abort() ; 
1874
1875   }
1876
1877   return towerFolder->GetListOfFolders()->GetObjectRef(trp) ;
1878
1879
1880
1881
1882
1883
1884
1885 //____________________________________________________________________________ 
1886
1887 TObject ** AliEMCALGetter::PreShowerRecPointsRef(const char * name) const 
1888
1889 { // -------------- RecPoints -------------------------------------------
1890
1891   
1892
1893   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/PreShowerRecPoints/name
1894
1895    
1896
1897   if ( !fRecoFolder ) {
1898
1899     cerr << "ERROR: AliEMCALGetter::PreShowerRecPointsRef -> Folder //" << fRecoFolder << " not found!" << endl;
1900
1901     abort() ; 
1902
1903   }    
1904
1905
1906
1907   TFolder * preshoFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/PreShowerRecPoints")) ; 
1908
1909   if ( !preshoFolder ) {
1910
1911     cerr << "ERROR: AliEMCALGetter::PreShowerRecPointsRef -> Folder //" << fRecoFolder << "/EMCAL/PreShowerRecPoints/" << endl;
1912
1913     abort() ;
1914
1915   }    
1916
1917
1918
1919   TObject * prp = preshoFolder->FindObject(name ) ;
1920
1921   if ( !prp )   {
1922
1923     cerr << "ERROR: AliEMCALGetter::PreShowerRecPointsRef -> Object " << name << " not found! " << endl ; 
1924
1925     abort() ;
1926
1927   }
1928
1929   return preshoFolder->GetListOfFolders()->GetObjectRef(prp) ;
1930
1931
1932
1933
1934
1935
1936
1937 //____________________________________________________________________________ 
1938
1939 const Bool_t AliEMCALGetter::PostClusterizer(AliEMCALClusterizer * clu) const 
1940
1941 { // ------------------ AliEMCALClusterizer ------------------------
1942
1943   
1944
1945   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
1946
1947
1948
1949   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1950
1951
1952
1953   if ( !tasks ) {
1954
1955     cerr << "ERROR: AliEMCALGetter::Post Rer -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
1956
1957     return kFALSE ;
1958
1959   }        
1960
1961         
1962
1963   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
1964
1965   if ( !emcal )  {
1966
1967     if (fDebug) {
1968
1969       cout <<"WARNING: AliEMCALGetter::Post Rer -> //" << fTasksFolder << "/ReconstructionerEMCAL not found!" << endl; 
1970
1971       cout <<"INFO: AliEMCALGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/EMCAL" << endl; 
1972
1973     }
1974
1975     emcal = new TTask("EMCAL", "") ; 
1976
1977     tasks->Add(emcal) ; 
1978
1979   } 
1980
1981
1982
1983   AliEMCALClusterizerv1 * emcalcl = dynamic_cast<AliEMCALClusterizerv1*>(emcal->GetListOfTasks()->FindObject(clu->GetName())) ; 
1984
1985   if (emcalcl) { 
1986
1987     if (fDebug)
1988
1989       cout << "INFO: AliEMCALGetter::Post Rer -> Task " << clu->GetName() << " already exists" << endl ; 
1990
1991     emcalcl->Delete() ; 
1992
1993     emcal->GetListOfTasks()->Remove(emcalcl) ;
1994
1995   }
1996
1997   emcal->Add(clu) ;      
1998
1999   return kTRUE; 
2000
2001
2002
2003
2004
2005 //____________________________________________________________________________ 
2006
2007 TObject ** AliEMCALGetter::ClusterizerRef(const char * name) const 
2008
2009 { // ------------------ AliEMCALClusterizer ------------------------
2010
2011   
2012
2013   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2014
2015
2016
2017   if ( !tasks ) {
2018
2019     cerr << "ERROR: AliEMCALGetter::Post RerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2020
2021     abort() ;
2022
2023   }        
2024
2025         
2026
2027   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2028
2029   if ( !emcal )  {
2030
2031     cerr <<"WARNING: AliEMCALGetter::Post RerRef -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl; 
2032
2033     abort() ; 
2034
2035   }   
2036
2037
2038
2039   TList * l = emcal->GetListOfTasks() ; 
2040
2041   TIter it(l) ;
2042
2043   TTask * task ;
2044
2045   TTask * clu = 0 ;
2046
2047   TString cluname(name) ;
2048
2049   cluname+=":clu-" ;
2050
2051   while((task = static_cast<TTask *>(it.Next()) )){
2052
2053     TString taskname(task->GetName()) ;
2054
2055     if(taskname.BeginsWith(cluname)){
2056
2057       clu = task ;
2058
2059       break ;
2060
2061     }
2062
2063   }
2064
2065
2066
2067   if(clu) 
2068
2069     return l->GetObjectRef(clu) ;
2070
2071   else {
2072
2073     cerr << "ERROR: AliEMCALGetter::Post RerRef -> task " << task->GetName() << " not found! " << endl ; 
2074
2075     abort() ;
2076
2077   }
2078
2079 }
2080
2081
2082
2083 //____________________________________________________________________________ 
2084
2085 const Bool_t AliEMCALGetter::PostClusterizer(const char * name) const 
2086
2087 { // ------------------ AliEMCALClusterizer ------------------------
2088
2089
2090
2091   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
2092
2093   
2094
2095   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2096
2097
2098
2099   if ( !tasks ) {
2100
2101     cerr << "ERROR: AliEMCALGetter::Post Rer -> Task//" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl; 
2102
2103     return kFALSE ;
2104
2105   }        
2106
2107   
2108
2109   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2110
2111   if ( !emcal )  {
2112
2113     if (fDebug) {
2114
2115       cout <<"WARNING: AliEMCALGetter::Post Rer -> //" << fTasksFolder << "/Reconstructioner/EMCAL not found!" << endl;
2116
2117       cout <<"INFO: AliEMCALGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/EMCAL" << endl;
2118
2119     }
2120
2121     emcal = new TTask("EMCAL", "") ; 
2122
2123     tasks->Add(emcal) ; 
2124
2125   } 
2126
2127
2128
2129   TList * l = emcal->GetListOfTasks() ;   
2130
2131   TIter it(l) ;
2132
2133   TString clun(name) ;
2134
2135   clun+=":clu" ; 
2136
2137   TTask * task ;
2138
2139   while((task = static_cast<TTask *>(it.Next()) )){
2140
2141     TString taskname(task->GetName()) ;
2142
2143     if(taskname.BeginsWith(clun))
2144
2145       return kTRUE ;
2146
2147   }
2148
2149
2150
2151   AliEMCALClusterizerv1 * emcalcl = new AliEMCALClusterizerv1() ;
2152
2153   clun+="-v1" ; 
2154
2155   emcalcl->SetName(clun) ;
2156
2157   emcalcl->SetTitle(fHeaderFile) ; 
2158
2159   emcal->Add(emcalcl) ;
2160
2161   return kTRUE; 
2162
2163   
2164
2165 }
2166
2167
2168
2169 //____________________________________________________________________________ 
2170
2171 /*const Bool_t AliEMCALGetter::PostTrackSegments(const char * name) const 
2172
2173 { // ---------------TrackSegments -----------------------------------
2174
2175   
2176
2177   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
2178
2179
2180
2181   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ; 
2182
2183   
2184
2185   if ( !emcalFolder ) {
2186
2187     if (fDebug) {
2188
2189       cout << "WARNING: AliEMCALGetter::Post TS -> Folder //" << fRecoFolder << "/EMCAL/ not found!" << endl;
2190
2191       cout << "INFO:    AliEMCALGetter::Post TS -> Adding Folder //" << fRecoFolder << "/EMCAL" << endl;
2192
2193     }
2194
2195     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;  
2196
2197   }    
2198
2199
2200
2201   TFolder * emcalTSFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("TrackSegments")) ;
2202
2203   if ( !emcalTSFolder ) {
2204
2205     if (fDebug) {
2206
2207       cout << "WARNING: AliEMCALGetter::Post TS -> Folder//" << fRecoFolder << "/EMCAL/TrackSegments/ not found!" << endl; 
2208
2209       cout << "INFO:    AliEMCALGetter::Post TS -> Adding Folder //" << fRecoFolder << "/EMCAL/TrackSegments/" << endl; 
2210
2211     }
2212
2213     emcalTSFolder = emcalFolder->AddFolder("TrackSegments", "TrackSegments from EMCAL") ;  
2214
2215   }    
2216
2217   
2218
2219   TObject * tss =  emcalTSFolder->FindObject( name ) ;
2220
2221   if (!tss) {
2222
2223     TClonesArray * ts = new TClonesArray("AliEMCALTrackSegment",100) ;
2224
2225     ts->SetName(name) ;
2226
2227     emcalTSFolder->Add(ts) ;  
2228
2229   }
2230
2231   return kTRUE; 
2232
2233
2234
2235
2236
2237 //____________________________________________________________________________ 
2238
2239 TObject ** AliEMCALGetter::TrackSegmentsRef(const char * name) const 
2240
2241 { // ---------------TrackSegments -----------------------------------
2242
2243   
2244
2245   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
2246
2247
2248
2249  if ( !fRecoFolder ) {
2250
2251     cerr << "ERROR: AliEMCALGetter::TrackSegmentsRef -> Folder //" << fRecoFolder << "not found!" << endl;
2252
2253     abort() ; 
2254
2255   }    
2256
2257
2258
2259   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TrackSegments")) ; 
2260
2261   if ( !emcalFolder ) {
2262
2263     cerr << "ERROR: AliEMCALGetter::TrackSegmentsRef -> Folder //" << fRecoFolder << "/EMCAL/TrackSegments/ not found!" << endl;
2264
2265     abort();
2266
2267   }    
2268
2269   
2270
2271   TObject * tss =  emcalFolder->FindObject(name) ;
2272
2273   if (!tss) {
2274
2275     cerr << "ERROR: AliEMCALGetter::TrackSegmentsRef -> object " << name << " not found! " << endl ;  
2276
2277     abort() ;  
2278
2279   }
2280
2281   return emcalFolder->GetListOfFolders()->GetObjectRef(tss) ;
2282
2283
2284
2285
2286
2287 //____________________________________________________________________________ 
2288
2289 const Bool_t AliEMCALGetter::PostTrackSegmentMaker(AliEMCALTrackSegmentMaker * tsmaker) const 
2290
2291 { //------------Track Segment Maker ------------------------------
2292
2293   
2294
2295   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
2296
2297
2298
2299   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2300
2301
2302
2303   if ( !tasks ) {
2304
2305     cerr << "ERROR: AliEMCALGetter::Post Ter -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
2306
2307     return kFALSE ;
2308
2309   }        
2310
2311         
2312
2313   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2314
2315   if ( !emcal )  {
2316
2317     if (fDebug) {
2318
2319       cout <<"WARNING: AliEMCALGetter::Post Rer -> //" << fTasksFolder << "/Reconstructioner/EMCAL not found!" << endl; 
2320
2321       cout <<"INFO: AliEMCALGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/EMCAL" << endl;
2322
2323     }
2324
2325     emcal = new TTask("EMCAL", "") ; 
2326
2327     tasks->Add(emcal) ; 
2328
2329   } 
2330
2331
2332
2333   AliEMCALTrackSegmentMaker * emcalts = 
2334
2335     dynamic_cast<AliEMCALTrackSegmentMaker*>(emcal->GetListOfTasks()->FindObject(tsmaker->GetName())) ; 
2336
2337   if (emcalts) { 
2338
2339     emcalts->Delete() ;
2340
2341     emcal->GetListOfTasks()->Remove(emcalts) ;
2342
2343   }
2344
2345   emcal->Add(tsmaker) ;      
2346
2347   return kTRUE; 
2348
2349   
2350
2351
2352
2353 //____________________________________________________________________________ 
2354
2355 const Bool_t AliEMCALGetter::PostTrackSegmentMaker(const char * name) const 
2356
2357 { //------------Track Segment Maker ------------------------------
2358
2359   
2360
2361   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
2362
2363
2364
2365   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2366
2367   
2368
2369   if ( !tasks ) {
2370
2371     cerr << "ERROR: AliEMCALGetter::Post Ter -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2372
2373     return kFALSE ;
2374
2375   }        
2376
2377   
2378
2379   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2380
2381   if ( !emcal )  {
2382
2383     if (fDebug) {
2384
2385       cout <<"WARNING: AliEMCALGetter::Post Ter -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
2386
2387       cout <<"INFO: AliEMCALGetter::Post Ter -> Adding //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl;
2388
2389     }
2390
2391     emcal = new TTask("EMCAL", "") ; 
2392
2393     tasks->Add(emcal) ; 
2394
2395   } 
2396
2397
2398
2399   TList * l = emcal->GetListOfTasks() ;   
2400
2401   TIter it(l) ;
2402
2403   TString tsn(name);
2404
2405   tsn+=":tsm" ; 
2406
2407   TTask * task ;
2408
2409   while((task = static_cast<TTask *>(it.Next()) )){
2410
2411     TString taskname(task->GetName()) ;
2412
2413     if(taskname.BeginsWith(tsn))
2414
2415       return kTRUE ;
2416
2417   }
2418
2419   
2420
2421   AliEMCALTrackSegmentMakerv1 * emcalts = new AliEMCALTrackSegmentMakerv1() ;
2422
2423   tsn+="-v1" ;
2424
2425   emcalts->SetName(tsn) ;
2426
2427   emcalts->SetTitle(fHeaderFile) ;
2428
2429   emcal->Add(emcalts) ;      
2430
2431   return kTRUE; 
2432
2433   
2434
2435
2436
2437   
2438
2439   
2440
2441
2442
2443
2444
2445 //____________________________________________________________________________ 
2446
2447 TObject ** AliEMCALGetter::TSMakerRef(const char * name) const 
2448
2449 { //------------Track Segment Maker ------------------------------
2450
2451   
2452
2453   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2454
2455
2456
2457   if ( !tasks ) {
2458
2459     cerr << "ERROR: AliEMCALGetter::TSLakerRef TerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2460
2461     abort() ;
2462
2463   }        
2464
2465         
2466
2467   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2468
2469   if ( !emcal )  {
2470
2471     cerr <<"WARNING: AliEMCALGetter::TSMakerRef TerRef -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
2472
2473     abort() ; 
2474
2475   }   
2476
2477
2478
2479   TList * l = emcal->GetListOfTasks() ; 
2480
2481   TIter it(l) ;
2482
2483   TTask * task ;
2484
2485   TTask * tsm = 0 ;
2486
2487   TString tsmname(name) ;
2488
2489   tsmname+=":tsm-" ;
2490
2491   while((task = static_cast<TTask *>(it.Next()) )){
2492
2493     TString taskname(task->GetName()) ;
2494
2495     if(taskname.BeginsWith(tsmname)){
2496
2497       tsm = task ;
2498
2499       break ;
2500
2501     }
2502
2503   }
2504
2505   
2506
2507   if(tsm) 
2508
2509     return l->GetObjectRef(tsm) ;
2510
2511   else {
2512
2513     cerr << "ERROR: AliEMCALGetter::TSLakerRef -> task " << task->GetName() << " not found! " << endl ; 
2514
2515     abort() ;
2516
2517   }
2518
2519
2520
2521
2522
2523 //____________________________________________________________________________ 
2524
2525 const Bool_t AliEMCALGetter::PostRecParticles(const char * name) const 
2526
2527 {  // -------------------- RecParticles ------------------------
2528
2529   
2530
2531   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
2532
2533
2534
2535   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ; 
2536
2537   
2538
2539   if ( !emcalFolder ) {
2540
2541     if (fDebug) {
2542
2543       cout << "WARNING: AliEMCALGetter::Post RPa -> Folder //" << fRecoFolder << "/EMCAL/ not found!" << endl;
2544
2545       cout << "INFO:    AliEMCALGetter::Post Rpa -> Adding Folder //" << fRecoFolder << "/EMCAL/" << endl;
2546
2547     }
2548
2549     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;  
2550
2551   }    
2552
2553
2554
2555  TFolder * emcalRPaFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("RecParticles")) ;
2556
2557   if ( !emcalRPaFolder ) {
2558
2559     if (fDebug) {
2560
2561       cout << "WARNING: AliEMCALGetter::Post RPa -> Folder //" << fRecoFolder << "/EMCAL/RecParticles/ not found!" << endl;
2562
2563       cout << "INFO:    AliEMCALGetter::Post RPa -> Adding Folder //" << fRecoFolder << "/EMCAL/RecParticles/" << endl;
2564
2565     }
2566
2567     emcalRPaFolder = emcalFolder->AddFolder("RecParticles", "RecParticles from EMCAL") ;  
2568
2569   } 
2570
2571
2572
2573   TObject * rps = emcalRPaFolder->FindObject( name )  ;
2574
2575   if ( !rps ) {
2576
2577     TClonesArray * rp = new TClonesArray("AliEMCALRecParticle",100) ;
2578
2579     rp->SetName(name) ;    
2580
2581     emcalRPaFolder->Add(rp) ;  
2582
2583   }
2584
2585   return kTRUE; 
2586
2587
2588
2589
2590
2591 //____________________________________________________________________________ 
2592
2593 TObject ** AliEMCALGetter::RecParticlesRef(const char * name) const 
2594
2595 { // ---------------RecParticles -----------------------------------
2596
2597   
2598
2599   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
2600
2601
2602
2603  if ( !fRecoFolder ) {
2604
2605     cerr << "ERROR: AliEMCALGetter::RecParticlesRef -> Folder//" << fRecoFolder << " not found!" << endl; 
2606
2607     abort() ; 
2608
2609   }    
2610
2611
2612
2613   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/RecParticles")) ; 
2614
2615   if ( !emcalFolder ) {
2616
2617     cerr << "ERROR: AliEMCALGetter::RecParticlesRef -> Folder //" << fRecoFolder << "/EMCAL/RecParticles/ not found!" << endl;
2618
2619     abort() ;
2620
2621   }    
2622
2623
2624
2625   TObject * tss =  emcalFolder->FindObject(name) ;
2626
2627   if (!tss) {
2628
2629     cerr << "ERROR: AliEMCALGetter::RecParticlesRef -> object " << name << " not found! " << endl ; 
2630
2631     abort() ;  
2632
2633   }
2634
2635   return emcalFolder->GetListOfFolders()->GetObjectRef(tss) ;
2636
2637 }
2638
2639
2640
2641 //____________________________________________________________________________ 
2642
2643 const Bool_t AliEMCALGetter::PostPID(AliEMCALPID * pid) const 
2644
2645 {      // ------------AliEMCAL PID -----------------------------
2646
2647
2648
2649   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2650
2651
2652
2653   if ( !tasks ) {
2654
2655     cerr << "ERROR: AliEMCALGetter::Post Per -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2656
2657     return kFALSE ;
2658
2659   }        
2660
2661   
2662
2663   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2664
2665   if ( !emcal )  {
2666
2667     if (fDebug) {
2668
2669       cout <<"WARNING: AliEMCALGetter::Post Per -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
2670
2671       cout <<"INFO: AliEMCALGetter::Post Per -> Adding //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl;
2672
2673     }
2674
2675     emcal = new TTask("EMCAL", "") ; 
2676
2677     tasks->Add(emcal) ; 
2678
2679   } 
2680
2681
2682
2683   AliEMCALPID * emcalpid = dynamic_cast<AliEMCALPID*>(emcal->GetListOfTasks()->FindObject(pid->GetName())) ; 
2684
2685   if (emcalpid) { 
2686
2687     if (fDebug)
2688
2689       cout << "INFO: AliEMCALGetter::Post Per -> Task " << pid->GetName()
2690
2691            << " already exists" << endl ; 
2692
2693     emcal->GetListOfTasks()->Remove(emcalpid) ;
2694
2695   }
2696
2697   
2698
2699   emcal->Add(pid) ;      
2700
2701   return kTRUE; 
2702
2703
2704
2705
2706
2707 //____________________________________________________________________________ 
2708
2709 const Bool_t AliEMCALGetter::PostPID(const char * name) const 
2710
2711 {     
2712
2713   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
2714
2715   
2716
2717   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2718
2719
2720
2721   if ( !tasks ) {
2722
2723     cerr << "ERROR: AliEMCALGetter::Post Per -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2724
2725     return kFALSE ;
2726
2727   }        
2728
2729   
2730
2731   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2732
2733   if ( !emcal )  {
2734
2735     if (fDebug) {
2736
2737       cout <<"WARNING: AliEMCALGetter::Post Per -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
2738
2739       cout <<"INFO: AliEMCALGetter::Post Per -> Adding //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl;
2740
2741     }
2742
2743     emcal = new TTask("EMCAL", "") ; 
2744
2745     tasks->Add(emcal) ; 
2746
2747   } 
2748
2749
2750
2751   TList * l = emcal->GetListOfTasks() ;   
2752
2753   TIter it(l) ;
2754
2755   TString pidname(name) ;
2756
2757   pidname+=":pid" ; 
2758
2759   TTask * task ;
2760
2761   while((task = static_cast<TTask *>(it.Next()) )){
2762
2763     TString taskname(task->GetName()) ;
2764
2765     if(taskname.BeginsWith(pidname))
2766
2767       return kTRUE ;
2768
2769   }
2770
2771  
2772
2773   AliEMCALPIDv1 * emcalpid = new AliEMCALPIDv1() ;
2774
2775   pidname+="-v1" ;
2776
2777   emcalpid->SetName(pidname) ;
2778
2779   emcalpid->SetTitle(fHeaderFile) ;
2780
2781   emcal->Add(emcalpid) ;      
2782
2783   
2784
2785   return kTRUE; 
2786
2787
2788
2789
2790
2791 //____________________________________________________________________________ 
2792
2793 TObject ** AliEMCALGetter::PIDRef(const char * name) const 
2794
2795 { //------------PID ------------------------------
2796
2797
2798
2799   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2800
2801
2802
2803   if ( !tasks ) {
2804
2805     cerr << "ERROR: AliEMCALGetter::PIDRef PerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2806
2807     abort() ;
2808
2809   }        
2810
2811         
2812
2813   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2814
2815   if ( !emcal )  {
2816
2817     cerr <<"WARNING: AliEMCALGetter::PIDRef PerRef -> //" << fTasksFolder->GetName() << "/ReconstructionerEMCAL not found!" << endl; 
2818
2819     abort() ; 
2820
2821   }   
2822
2823   
2824
2825   TList * l = emcal->GetListOfTasks() ; 
2826
2827   TIter it(l) ;
2828
2829   TTask * task ;
2830
2831   TTask * pid = 0 ;
2832
2833   TString pidname(name) ;
2834
2835   pidname+=":pid-" ;
2836
2837   while((task = static_cast<TTask *>(it.Next()) )){
2838
2839     TString taskname(task->GetName()) ;
2840
2841     if(taskname.BeginsWith(pidname)){
2842
2843       pid = task ;
2844
2845       break ;
2846
2847     }
2848
2849   }
2850
2851   
2852
2853   if(pid) 
2854
2855     return l->GetObjectRef(pid) ;
2856
2857   else {
2858
2859     cerr << "ERROR: AliEMCALGetter::PIDRef -> task " << task->GetName() << " not found! " << endl ;  
2860
2861     abort() ;
2862
2863   }
2864
2865
2866
2867
2868
2869
2870
2871 //____________________________________________________________________________ 
2872
2873 const Bool_t AliEMCALGetter::PostQA(void) const 
2874
2875 { // ------------------ QA ---------------------------------
2876
2877
2878
2879   // the hierarchy is //Folders/Run/Conditions/QA/EMCAL/alarmsName
2880
2881
2882
2883   TFolder * emcalFolder = dynamic_cast<TFolder*>(fQAFolder->FindObject("EMCAL")) ; 
2884
2885   if ( !emcalFolder ) {
2886
2887     if (fDebug) {
2888
2889       cout << "WARNING: AliEMCALGetter::Post Q -> Folder //" << fQAFolder << "/EMCAL/ not found!" << endl;
2890
2891       cout << "INFO:    AliEMCALGetter::Post Q -> Adding Folder //" << fQAFolder << "/EMCAL/" << endl;
2892
2893     }
2894
2895     emcalFolder = fQAFolder->AddFolder("EMCAL", "QA from EMCAL") ; 
2896
2897   }      
2898
2899
2900
2901   return kTRUE;
2902
2903 }
2904
2905
2906
2907 //____________________________________________________________________________ 
2908
2909 TObject ** AliEMCALGetter::AlarmsRef(void) const 
2910
2911 {  //------- Alarms ----------------------
2912
2913
2914
2915   
2916
2917   // the hierarchy is //Folders/Run/Conditions/QA/EMCAL
2918
2919   if ( !fQAFolder ) {
2920
2921     cerr << "ERROR: AliEMCALGetter::AlarmsRef QRef -> Folder //" << fQAFolder << " not found!" << endl;
2922
2923     abort() ;
2924
2925   }    
2926
2927  
2928
2929   TFolder * emcalFolder = dynamic_cast<TFolder *>(fQAFolder->FindObject("EMCAL")) ;
2930
2931   if ( !emcalFolder ) {
2932
2933     cerr << "ERROR: AliEMCALGetter::AlarmsRef QRef -> Folder //" << fQAFolder << "/EMCAL/ not found!" << endl;
2934
2935     abort() ;
2936
2937   }
2938
2939    
2940
2941   return fQAFolder->GetListOfFolders()->GetObjectRef(emcalFolder) ;
2942
2943 }
2944
2945 */
2946
2947
2948
2949 //____________________________________________________________________________ 
2950
2951 TTree * AliEMCALGetter::TreeK(TString filename)  
2952
2953 {
2954
2955
2956
2957   // returns TreeK from file filename
2958
2959   // usefull in case of split file
2960
2961
2962
2963   if ( filename.IsNull() ) 
2964
2965     filename = fHeaderFile ; 
2966
2967
2968
2969   TFile * file = 0 ; 
2970
2971   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
2972
2973   if (file && (filename != fHeaderFile) ) {  // file already open 
2974
2975     file->Close() ; 
2976
2977     delete fAlice ; 
2978
2979   }    
2980
2981   file = TFile::Open(filename.Data(), "read") ; 
2982
2983   fAlice = static_cast<AliRun *>(file->Get("gAlice")) ; 
2984
2985   TString treeName("TreeK") ; 
2986
2987   treeName += EventNumber()  ; 
2988
2989   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
2990
2991   if (!tree && fDebug)  
2992
2993     cout << "WARNING: AliEMCALGetter::TreeK -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
2994
2995   
2996
2997   return tree ;                       
2998
2999 }
3000
3001
3002
3003 //____________________________________________________________________________ 
3004
3005 TTree * AliEMCALGetter::TreeH(TString filename)  
3006
3007 {
3008
3009
3010
3011   // returns TreeH from file filename
3012
3013   // usefull in case of split file
3014
3015
3016
3017   if ( filename.IsNull() ) 
3018
3019     filename = fHeaderFile ; 
3020
3021
3022
3023   TFile * file = 0 ; 
3024
3025   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
3026
3027   if (!file) { // file not open yet
3028
3029     file = TFile::Open(filename.Data(), "read") ; 
3030
3031   }
3032
3033   TString treeName("TreeH") ; 
3034
3035   treeName += EventNumber()  ; 
3036
3037   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
3038
3039   if (!tree && fDebug)  
3040
3041     cout << "WARNING: AliEMCALGetter::TreeH -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
3042
3043   
3044
3045   return tree ;                       
3046
3047 }
3048
3049
3050
3051 //____________________________________________________________________________ 
3052
3053 TTree * AliEMCALGetter::TreeS(TString filename)  
3054
3055 {
3056
3057
3058
3059   // returns TreeS from file filename
3060
3061   // usefull in case of split file
3062
3063
3064
3065   if ( filename.IsNull() ) 
3066
3067     filename = fHeaderFile ; 
3068
3069
3070
3071   TFile * file = 0 ; 
3072
3073   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
3074
3075   if (!file) { // file not open yet
3076
3077     file = TFile::Open(filename.Data(), "read") ; 
3078
3079   }
3080
3081   TString treeName("TreeS") ; 
3082
3083   treeName += EventNumber()  ; 
3084
3085   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
3086
3087   if (!tree && fDebug)  
3088
3089     cout << "WARNING: AliEMCALGetter::TreeS -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
3090
3091   
3092
3093   return tree ;                       
3094
3095 }
3096
3097
3098
3099 //____________________________________________________________________________ 
3100
3101 TTree * AliEMCALGetter::TreeD(TString filename)  
3102
3103 {
3104
3105
3106
3107   // returns TreeD from file filename
3108
3109   // usefull in case of split file
3110
3111
3112
3113   if ( filename.IsNull() ) 
3114
3115     filename = fHeaderFile ; 
3116
3117
3118
3119   TFile * file = 0 ; 
3120
3121   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
3122
3123   if (!file) { // file not open yet
3124
3125     file = TFile::Open(filename.Data(), "read") ; 
3126
3127   }
3128
3129   TString treeName("TreeD") ; 
3130
3131   treeName += EventNumber()  ; 
3132
3133   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
3134
3135   if (!tree && fDebug)  
3136
3137     cout << "WARNING: AliEMCALGetter::TreeD -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
3138
3139   
3140
3141   return tree ;                       
3142
3143 }
3144
3145
3146
3147 //____________________________________________________________________________ 
3148
3149 const TParticle * AliEMCALGetter::Primary(Int_t index) const
3150
3151 {
3152
3153   // Return primary particle numbered by <index>
3154
3155   
3156
3157   if(index < 0) 
3158
3159     return 0 ;
3160
3161   TParticle *  p = 0 ;
3162
3163   if (fAlice) 
3164
3165     p = fAlice->Particle(index) ; 
3166
3167   else 
3168
3169     p = gAlice->Particle(index) ; 
3170
3171   
3172
3173   return p ; 
3174
3175       
3176
3177 }
3178
3179
3180
3181 //____________________________________________________________________________ 
3182
3183 const TParticle * AliEMCALGetter::Secondary(TParticle* p, Int_t index) const
3184
3185 {
3186
3187   // Return first (index=1) or second (index=2) secondary particle of primary particle p 
3188
3189
3190
3191   if(index <= 0) 
3192
3193     return 0 ;
3194
3195   if(index > 2)
3196
3197     return 0 ;
3198
3199
3200
3201   if(p) {
3202
3203   Int_t daughterIndex = p->GetDaughter(index-1) ; 
3204
3205   return  gAlice->Particle(daughterIndex) ; 
3206
3207   }
3208
3209   else
3210
3211     return 0 ;
3212
3213 }
3214
3215
3216
3217 //____________________________________________________________________________ 
3218
3219 Int_t AliEMCALGetter::ReadTreeD(const Int_t event)
3220
3221 {
3222
3223   // Read the digit tree gAlice->TreeD()  
3224
3225   
3226
3227   TTree * treeD ;
3228
3229   if(fToSplit){
3230
3231     TFile * file = static_cast<TFile*>(gROOT->GetFile(fDigitsFileName)); 
3232
3233     if(!file) 
3234
3235       file = TFile::Open(fDigitsFileName) ;      
3236
3237     // Get Digits Tree header from file
3238
3239     TString treeName("TreeD") ;
3240
3241     treeName += event ; 
3242
3243     treeD = dynamic_cast<TTree*>(file->Get(treeName.Data()));
3244
3245     if(!treeD){ // TreeD not found in header file
3246
3247       if (fDebug)
3248
3249         cout << "WARNING: AliEMCALGetter::ReadTreeD -> Cannot find TreeD in " << fDigitsFileName.Data() << endl;
3250
3251       return 1;
3252
3253     }
3254
3255   }
3256
3257   else
3258
3259     treeD = gAlice->TreeD() ;
3260
3261   
3262
3263   TObjArray * lob = static_cast<TObjArray*>(treeD->GetListOfBranches()) ;
3264
3265   TIter next(lob) ; 
3266
3267   TBranch * branch = 0 ; 
3268
3269   TBranch * digitsbranch = 0 ; 
3270
3271   TBranch * digitizerbranch = 0 ; 
3272
3273   Bool_t emcalfound = kFALSE, digitizerfound = kFALSE ; 
3274
3275   
3276
3277   while ( (branch = static_cast<TBranch*>(next())) && (!emcalfound || !digitizerfound) ) {
3278
3279     if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
3280
3281       digitsbranch = branch ; 
3282
3283       emcalfound = kTRUE ;
3284
3285     }
3286
3287     else if ( (strcmp(branch->GetName(), "AliEMCALDigitizer")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
3288
3289       digitizerbranch = branch ; 
3290
3291       digitizerfound = kTRUE ; 
3292
3293     }
3294
3295   }
3296
3297
3298
3299   if ( !emcalfound || !digitizerfound ) {
3300
3301     if (fDebug)
3302
3303       cout << "WARNING: AliEMCALGetter::ReadTreeD -> Cannot find Digits and/or Digitizer with name " 
3304
3305            << fDigitsTitle << endl ;
3306
3307     return 2; 
3308
3309   }   
3310
3311  
3312
3313   //read digits
3314
3315   if(!Digits(fDigitsTitle) ) 
3316
3317     PostDigits(fDigitsTitle);
3318
3319   digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ;
3320
3321   digitsbranch->GetEntry(0) ;
3322
3323   
3324
3325   
3326
3327   // read  the Digitizer
3328
3329   RemoveTask("D", fDigitsTitle) ; // I do not understand why I need that 
3330
3331   if(!Digitizer(fDigitsTitle))
3332
3333     PostDigitizer(fDigitsTitle) ;
3334
3335   digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ;
3336
3337   digitizerbranch->GetEntry(0) ;
3338
3339  
3340
3341   lob  ->Delete();
3342
3343   if(gAlice->TreeD()!=treeD)
3344
3345     treeD->Delete();
3346
3347   return 0 ; 
3348
3349 }
3350
3351
3352
3353 //____________________________________________________________________________ 
3354
3355 Int_t AliEMCALGetter::ReadTreeH()
3356
3357 {
3358
3359   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
3360
3361
3362
3363   TTree * treeH = gAlice->TreeH() ;
3364
3365   
3366
3367   if(!treeH) {// TreeH not found in header file
3368
3369     
3370
3371     if (fDebug) 
3372
3373       cout <<   "WARNING: AliEMCALGetter::ReadTreeH -> Cannot find TreeH in " << fHeaderFile << endl ;
3374
3375     
3376
3377     TString searchFileName("EMCAL.HITS") ; 
3378
3379     if((strcmp(fBranchTitle.Data(),"Default")!=0)&&(strcmp(fBranchTitle.Data(),"")!=0)){
3380
3381       searchFileName+="." ;
3382
3383       searchFileName += fBranchTitle ;
3384
3385     }
3386
3387     searchFileName+=".root" ;
3388
3389     
3390
3391     if ( (treeH = TreeH(searchFileName)) ) { //found TreeH in the file which contains the hits
3392
3393       if (fDebug) 
3394
3395         cout << "INFO: AliEMCALGetter::ReadTreeH -> TreeH found in " << searchFileName.Data() << endl ; 
3396
3397       
3398
3399     } else {
3400
3401       cerr << "ERROR: AliEMCALGetter::ReadTreeH -> TreeH not found " << endl ; 
3402
3403       return 1;
3404
3405     }  
3406
3407   }
3408
3409   
3410
3411   TBranch * hitsbranch = static_cast<TBranch*>(gAlice->TreeH()->GetBranch("EMCAL")) ;
3412
3413   if ( !hitsbranch ) {
3414
3415     if (fDebug)
3416
3417       cout << "WARNING:  AliEMCALGetter::ReadTreeH -> Cannot find branch EMCAL" << endl ; 
3418
3419     return 2;
3420
3421   }
3422
3423   if(!Hits())
3424
3425     PostHits() ;
3426
3427  
3428
3429   if (hitsbranch->GetEntries() > 1 ) {
3430
3431     (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
3432
3433     TClonesArray * tempo =  new TClonesArray("AliEMCALHit",1000) ;
3434
3435     TClonesArray * hits = dynamic_cast<TClonesArray*>(*HitsRef()) ; 
3436
3437     hitsbranch->SetAddress(&tempo) ;
3438
3439     Int_t index = 0 ; 
3440
3441     Int_t i = 0 ;
3442
3443     for (i = 0 ; i < hitsbranch->GetEntries() ; i++) {
3444
3445       hitsbranch->GetEntry(i) ;
3446
3447       Int_t j = 0 ; 
3448
3449       for ( j = 0 ; j < tempo->GetEntries() ; j++) { 
3450
3451         const AliEMCALHit * hit = static_cast<const AliEMCALHit *>(tempo->At(j)) ; 
3452
3453         new((*hits)[index]) AliEMCALHit( *hit ) ;
3454
3455         index++ ; 
3456
3457       }
3458
3459     }
3460
3461     delete tempo ; 
3462
3463   }
3464
3465   else {
3466
3467   (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
3468
3469   hitsbranch->SetAddress(HitsRef()) ;
3470
3471   hitsbranch->GetEntry(0) ;
3472
3473   }
3474
3475   return 0 ; 
3476
3477 }
3478
3479
3480
3481 //____________________________________________________________________________ 
3482
3483 void AliEMCALGetter::Track(const Int_t itrack)
3484
3485 {
3486
3487   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
3488
3489
3490
3491   if(gAlice->TreeH()== 0){
3492
3493     cerr <<   "ERROR: AliEMCALGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
3494
3495     return ;
3496
3497   }
3498
3499   
3500
3501   TBranch * hitsbranch = dynamic_cast<TBranch*>(gAlice->TreeH()->GetListOfBranches()->FindObject("EMCAL")) ;
3502
3503   if ( !hitsbranch ) {
3504
3505     if (fDebug)
3506
3507       cout << "WARNING:  AliEMCALGetter::ReadTreeH -> Cannot find branch EMCAL" << endl ; 
3508
3509     return ;
3510
3511   }  
3512
3513   if(!Hits())
3514
3515     PostHits() ;
3516
3517
3518
3519   (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
3520
3521   hitsbranch->SetAddress(HitsRef()) ;
3522
3523   hitsbranch->GetEntry(itrack) ;
3524
3525   
3526
3527 }
3528
3529
3530
3531 //____________________________________________________________________________ 
3532
3533 void AliEMCALGetter::ReadTreeQA()
3534
3535 {
3536
3537   if (fDebug)
3538
3539     cout << "WARNING : " << ClassName() << "::ReadTreeQA -> not implemented" << endl ; 
3540
3541   // Read the digit tree gAlice->TreeQA()
3542
3543   // so far only EMCAL knows about this Tree  
3544
3545
3546
3547 //   if(EMCAL()->TreeQA()== 0){
3548
3549 //     cerr <<   "ERROR: AliEMCALGetter::ReadTreeQA: can not read TreeQA " << endl ;
3550
3551 //     return ;
3552
3553 //   }
3554
3555   
3556
3557 //   TBranch * qabranch = EMCAL()->TreeQA()->GetBranch("EMCAL") ; 
3558
3559 //   if (!qabranch) { 
3560
3561 //     if (fDebug)
3562
3563 //       cout << "WARNING: AliEMCALGetter::ReadTreeQA -> Cannot find QA Alarms for EMCAL" << endl ;
3564
3565 //     return ; 
3566
3567 //   }   
3568
3569   
3570
3571 //   if(!Alarms())
3572
3573 //     PostQA() ; 
3574
3575
3576
3577 //   qabranch->SetAddress(AlarmsRef()) ;
3578
3579
3580
3581 //   qabranch->GetEntry(0) ;
3582
3583  
3584
3585 //   PostQA("EMCAL") ; 
3586
3587 //   TFolder * alarmsF = Alarms() ; 
3588
3589 //   alarmsF->Clear() ; 
3590
3591 //   qabranch->SetAddress(&alarmsF) ;
3592
3593 //   qabranch->GetEntry(0) ;
3594
3595   
3596
3597 }
3598
3599   
3600
3601 //____________________________________________________________________________ 
3602
3603 Int_t AliEMCALGetter::ReadTreeR(const Int_t event)
3604
3605 {
3606
3607   // Read the reconstrunction tree gAlice->TreeR()
3608
3609   // A particularity has been introduced here :
3610
3611   //  if gime->Event(ievent,"R") is called branches with the current title are read, the current title
3612
3613   //   being for example give in AliPHOSPID(fileName, title)
3614
3615   //  if gime(Event(ievent, "RA") is called the title of the branches is not checked anymore, "A" stands for any
3616
3617   // This is a feature needed by PID to be able to reconstruct several times particles (each time a ther title is given)
3618
3619   // from a given set of TrackSegments (with a given name)
3620
3621   // This is why any is NOT used to read the branch of RecParticles
3622
3623   // any migh have become obsolete : to be checked
3624
3625   // See AliEMCALPIDv1    
3626
3627
3628
3629  TTree * treeR ;
3630
3631   if(fToSplit){
3632
3633     TFile * file = static_cast<TFile*>(gROOT->GetFile(fRecPointsFileName)); 
3634
3635     if(!file) 
3636
3637       file = TFile::Open(fRecPointsFileName) ;      
3638
3639     // Get Digits Tree header from file
3640
3641     TString treeName("TreeR") ;
3642
3643     treeName += event ; 
3644
3645     treeR = dynamic_cast<TTree*>(file->Get(treeName.Data()));
3646
3647     if(!treeR){ // TreeR not found in header file
3648
3649       if (fDebug)
3650
3651         cout << "WARNING: AliEMCALGetter::ReadTreeD -> Cannot find TreeR in " << fRecPointsFileName.Data() << endl;
3652
3653       return 1;
3654
3655     }
3656
3657   }
3658
3659   else
3660
3661     treeR = gAlice->TreeR() ;
3662
3663   
3664
3665   // RecPoints 
3666
3667   TObjArray * lob = static_cast<TObjArray*>(treeR->GetListOfBranches()) ;
3668
3669   TIter next(lob) ; 
3670
3671   TBranch * branch = 0 ; 
3672
3673   TBranch * towerbranch = 0 ; 
3674
3675   TBranch * preshowerbranch = 0 ; 
3676
3677   TBranch * clusterizerbranch = 0 ; 
3678
3679   Bool_t emcalTowerRPfound = kFALSE, emcalPreShoRPfound = kFALSE, clusterizerfound = kFALSE ; 
3680
3681
3682
3683   
3684
3685   while ( (branch = static_cast<TBranch*>(next())) && (!emcalTowerRPfound || !emcalPreShoRPfound || !clusterizerfound) ) {
3686
3687     if(strcmp(branch->GetTitle(), fRecPointsTitle)==0 ) {
3688
3689       if ( strcmp(branch->GetName(), "EMCALTowerRP")==0) {
3690
3691         towerbranch = branch ; 
3692
3693         emcalTowerRPfound = kTRUE ;
3694
3695       }
3696
3697       else if ( strcmp(branch->GetName(), "EMCALPreShoRP")==0) {
3698
3699         preshowerbranch = branch ; 
3700
3701         emcalPreShoRPfound = kTRUE ;
3702
3703       }
3704
3705       else if(strcmp(branch->GetName(), "AliEMCALClusterizer")==0){
3706
3707         clusterizerbranch = branch ; 
3708
3709         clusterizerfound = kTRUE ; 
3710
3711       }
3712
3713     }
3714
3715   }
3716
3717
3718
3719   if ( !emcalTowerRPfound || !emcalPreShoRPfound || !clusterizerfound) {
3720
3721     if (fDebug)
3722
3723       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Cannot find RecPoints and/or Clusterizer with name " 
3724
3725            << fRecPointsTitle << endl ;
3726
3727  
3728
3729   } else { 
3730
3731     if(!TowerRecPoints(fRecPointsTitle) ) 
3732
3733       PostRecPoints(fRecPointsTitle) ;
3734
3735     
3736
3737     towerbranch->SetAddress(TowerRecPointsRef(fRecPointsTitle)) ;
3738
3739     towerbranch->GetEntry(0) ;
3740
3741
3742
3743     preshowerbranch->SetAddress(PreShowerRecPointsRef(fRecPointsTitle)) ; 
3744
3745     preshowerbranch->GetEntry(0) ;  
3746
3747     
3748
3749     if(!Clusterizer(fRecPointsTitle) )
3750
3751       PostClusterizer(fRecPointsTitle) ;
3752
3753     
3754
3755     clusterizerbranch->SetAddress(ClusterizerRef(fRecPointsTitle)) ;
3756
3757     clusterizerbranch->GetEntry(0) ;
3758
3759   }
3760
3761   
3762
3763 //   //------------------- TrackSegments ---------------------
3764
3765 //   next.Reset() ; 
3766
3767 //   TBranch * tsbranch = 0 ; 
3768
3769 //   TBranch * tsmakerbranch = 0 ; 
3770
3771 //   Bool_t emcaltsfound = kFALSE, tsmakerfound = kFALSE ; 
3772
3773 //   while ( (branch = static_cast<TBranch*>(next())) && (!emcaltsfound || !tsmakerfound) ) {
3774
3775 //     if(strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0 )  {
3776
3777 //       if ( strcmp(branch->GetName(), "EMCALTS")==0){
3778
3779 //      tsbranch = branch ; 
3780
3781 //      emcaltsfound = kTRUE ;
3782
3783 //       }
3784
3785 //       else if(strcmp(branch->GetName(), "AliEMCALTrackSegmentMaker")==0) {
3786
3787 //      tsmakerbranch = branch ; 
3788
3789 //      tsmakerfound  = kTRUE ; 
3790
3791 //       }
3792
3793 //     }
3794
3795 //   }
3796
3797
3798
3799 //   if ( !emcaltsfound || !tsmakerfound ) {
3800
3801 //     if (fDebug)
3802
3803 //       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Cannot find TrackSegments and/or TrackSegmentMaker with name "
3804
3805 //         << fTrackSegmentsTitle << endl ;
3806
3807 //   } else { 
3808
3809 //     // Read and Post the TrackSegments
3810
3811 //     if(!TrackSegments(fTrackSegmentsTitle))
3812
3813 //       PostTrackSegments(fTrackSegmentsTitle) ;
3814
3815 //     tsbranch->SetAddress(TrackSegmentsRef(fTrackSegmentsTitle)) ;
3816
3817 //     tsbranch->GetEntry(0) ;
3818
3819
3820
3821 //     // Read and Post the TrackSegment Maker
3822
3823 //     if(!TrackSegmentMaker(fTrackSegmentsTitle))
3824
3825 //       PostTrackSegmentMaker(fTrackSegmentsTitle) ;
3826
3827 //     tsmakerbranch->SetAddress(TSMakerRef(fTrackSegmentsTitle)) ;
3828
3829 //     tsmakerbranch->GetEntry(0) ;
3830
3831 //  }
3832
3833   
3834
3835   
3836
3837 //   //------------ RecParticles ----------------------------
3838
3839 //   next.Reset() ; 
3840
3841 //   TBranch * rpabranch = 0 ; 
3842
3843 //   TBranch * pidbranch = 0 ; 
3844
3845 //   Bool_t emcalrpafound = kFALSE, pidfound = kFALSE ; 
3846
3847   
3848
3849 //   while ( (branch = static_cast<TBranch*>(next())) && (!emcalrpafound || !pidfound) ) 
3850
3851 //     if(strcmp(branch->GetTitle(), fRecParticlesTitle)==0) {   
3852
3853 //       if ( strcmp(branch->GetName(), "EMCALRP")==0) {   
3854
3855 //      rpabranch = branch ; 
3856
3857 //      emcalrpafound = kTRUE ;
3858
3859 //       }
3860
3861 //       else if (strcmp(branch->GetName(), "AliEMCALPID")==0) {
3862
3863 //      pidbranch = branch ; 
3864
3865 //      pidfound  = kTRUE ; 
3866
3867 //       }
3868
3869 //     }
3870
3871   
3872
3873 //   if ( !emcalrpafound || !pidfound ) {
3874
3875 //     if (fDebug)
3876
3877 //       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Cannot find RecParticles and/or PID with name " 
3878
3879 //         << fRecParticlesTitle << endl ; 
3880
3881 //   } else { 
3882
3883 //     // Read and Post the RecParticles
3884
3885 //     if(!RecParticles(fRecParticlesTitle)) 
3886
3887 //       PostRecParticles(fRecParticlesTitle) ;
3888
3889 //     rpabranch->SetAddress(RecParticlesRef(fRecParticlesTitle)) ;
3890
3891 //     rpabranch->GetEntry(0) ;
3892
3893 //     // Read and Post the PID
3894
3895 //     if(!PID(fRecParticlesTitle))
3896
3897 //       PostPID(fRecParticlesTitle) ;
3898
3899 //     pidbranch->SetAddress(PIDRef(fRecParticlesTitle)) ;
3900
3901 //     pidbranch->GetEntry(0) ;
3902
3903 //   }
3904
3905
3906
3907   if(gAlice->TreeR()!=treeR)
3908
3909     treeR->Delete();
3910
3911   return 0 ; 
3912
3913 }
3914
3915
3916
3917 //____________________________________________________________________________ 
3918
3919 Int_t AliEMCALGetter::ReadTreeS(Int_t event)
3920
3921 {
3922
3923   // Reads the SDigits treeS from all files  
3924
3925   // Files, which should be opened are listed in emcalF
3926
3927   // So, first get list of files
3928
3929   TFolder * emcalF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
3930
3931   if (!emcalF) 
3932
3933     emcalF = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; 
3934
3935   TCollection * folderslist = emcalF->GetListOfFolders() ; 
3936
3937   
3938
3939   // Now iterate over the list of files and read TreeS into Whiteboard
3940
3941   TIter next(folderslist) ; 
3942
3943   TFolder * folder = 0 ; 
3944
3945   TFile * file; 
3946
3947   TTree * treeS = 0;
3948
3949   while ( (folder = static_cast<TFolder*>(next())) ) {
3950
3951     TString fileName("") ;
3952
3953     if(fToSplit)
3954
3955       fileName = folder->GetTitle() ;
3956
3957     else
3958
3959       fileName = folder->GetName() ; 
3960
3961     fileName.ReplaceAll("_","/") ; 
3962
3963     file = static_cast<TFile*>(gROOT->GetFile(fileName)); 
3964
3965     if(!file) 
3966
3967       file = TFile::Open(fileName) ;      
3968
3969     // Get SDigits Tree header from file
3970
3971     TString treeName("TreeS") ;
3972
3973     treeName += event ; 
3974
3975     treeS = dynamic_cast<TTree*>(file->Get(treeName.Data()));
3976
3977
3978
3979     if(!treeS){ // TreeS not found in header file
3980
3981       if (fDebug)
3982
3983         cout << "WARNING: AliEMCALGetter::ReadTreeS -> Cannot find TreeS in " << fileName.Data() << endl;
3984
3985       return 1;
3986
3987     }
3988
3989     
3990
3991     //set address of the SDigits and SDigitizer
3992
3993     TBranch   * sdigitsBranch    = 0;
3994
3995     TBranch   * sdigitizerBranch = 0;
3996
3997     TBranch   * branch           = 0 ;  
3998
3999     TObjArray * lob = static_cast<TObjArray*>(treeS->GetListOfBranches()) ;
4000
4001     TIter next(lob) ; 
4002
4003     Bool_t emcalfound = kFALSE, sdigitizerfound = kFALSE ; 
4004
4005
4006
4007     while ( (branch = static_cast<TBranch*>(next())) && (!emcalfound || !sdigitizerfound) ) {
4008
4009       if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
4010
4011         emcalfound = kTRUE ;
4012
4013         sdigitsBranch = branch ; 
4014
4015       }
4016
4017       
4018
4019       else if ( (strcmp(branch->GetName(), "AliEMCALSDigitizer")==0) && 
4020
4021                 (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
4022
4023         sdigitizerfound = kTRUE ; 
4024
4025         sdigitizerBranch = branch ;
4026
4027       }
4028
4029     }
4030
4031     if ( !emcalfound || !sdigitizerfound ) {
4032
4033       if (fDebug)
4034
4035         cout << "WARNING: AliEMCALDigitizer::ReadSDigits -> Digits and/or Digitizer branch with name " << GetName() 
4036
4037              << " not found" << endl ;
4038
4039       return 2; 
4040
4041     }   
4042
4043     
4044
4045     if ( !folder->FindObject(fSDigitsTitle) )  
4046
4047       PostSDigits(fSDigitsTitle,folder->GetName()) ;
4048
4049
4050
4051     ((TClonesArray*) (*SDigitsRef(fSDigitsTitle,folder->GetName())))->Clear() ;
4052
4053     sdigitsBranch->SetAddress(SDigitsRef(fSDigitsTitle,folder->GetName())) ;
4054
4055     sdigitsBranch->GetEntry(0) ;
4056
4057     
4058
4059     TString sdname(fSDigitsTitle) ;
4060
4061     sdname+=":" ;
4062
4063     sdname+=folder->GetName() ;
4064
4065     if(!SDigitizer(sdname) ) 
4066
4067       PostSDigitizer(fSDigitsTitle,folder->GetName()) ;
4068
4069     sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
4070
4071     sdigitizerBranch->GetEntry(0) ; 
4072
4073     if(gAlice->TreeS()!=treeS)
4074
4075       treeS->Delete();
4076
4077   }    
4078
4079    return 0 ;  
4080
4081 }
4082
4083
4084
4085 //____________________________________________________________________________ 
4086
4087 void AliEMCALGetter::ReadTreeS(TTree * treeS, Int_t input)
4088
4089 {  // Read the summable digits fron treeS()  
4090
4091
4092
4093
4094
4095   TString filename("mergefile") ;
4096
4097   filename+= input ;
4098
4099
4100
4101   TFolder * emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ; 
4102
4103   if ( !emcalFolder ) { 
4104
4105    emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; 
4106
4107   } 
4108
4109   TFolder * folder=(TFolder*)emcalFolder->FindObject(filename) ;
4110
4111   //set address of the SDigits and SDigitizer
4112
4113   TBranch   * sdigitsBranch    = 0;
4114
4115   TBranch   * sdigitizerBranch = 0;
4116
4117   TBranch   * branch           = 0 ;  
4118
4119   TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
4120
4121   TIter next(lob) ; 
4122
4123   Bool_t emcalfound = kFALSE, sdigitizerfound = kFALSE ; 
4124
4125   
4126
4127   while ( (branch = (TBranch*)next()) && (!emcalfound || !sdigitizerfound) ) {
4128
4129     if ( strcmp(branch->GetName(), "EMCAL")==0) {
4130
4131       emcalfound = kTRUE ;
4132
4133       sdigitsBranch = branch ; 
4134
4135     }
4136
4137     
4138
4139     else if ( strcmp(branch->GetName(), "AliEMCALSDigitizer")==0) {
4140
4141       sdigitizerfound = kTRUE ; 
4142
4143       sdigitizerBranch = branch ;
4144
4145     }
4146
4147   }
4148
4149   if ( !emcalfound || !sdigitizerfound ) {
4150
4151     if (fDebug)
4152
4153       cout << "WARNING: AliEMCALGetter::ReadTreeS -> Digits and/or Digitizer branch not found" << endl ;
4154
4155     return ; 
4156
4157   }   
4158
4159   
4160
4161   if (!folder || !(folder->FindObject(sdigitsBranch->GetTitle()) ) )
4162
4163     PostSDigits(sdigitsBranch->GetTitle(),filename) ;
4164
4165
4166
4167   sdigitsBranch->SetAddress(SDigitsRef(sdigitsBranch->GetTitle(),filename)) ;
4168
4169   sdigitsBranch->GetEntry(0) ;
4170
4171   
4172
4173   TString sdname(sdigitsBranch->GetTitle()) ;
4174
4175   sdname+=":" ;
4176
4177   sdname+=filename ;
4178
4179
4180
4181   if(!SDigitizer(sdigitsBranch->GetTitle()) )
4182
4183     PostSDigitizer(sdigitsBranch->GetTitle(),filename) ;
4184
4185   sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
4186
4187   sdigitizerBranch->GetEntry(0) ;
4188
4189   if(gAlice->TreeS()!=treeS)
4190
4191     treeS->Delete();
4192
4193 }    
4194
4195
4196
4197
4198
4199 //____________________________________________________________________________ 
4200
4201 void AliEMCALGetter::ReadPrimaries()
4202
4203 {
4204
4205   // Reads specific branches of primaries
4206
4207   
4208
4209   TClonesArray * ar = 0  ; 
4210
4211   if(! (ar = Primaries()) ) { 
4212
4213     PostPrimaries() ;
4214
4215     ar = Primaries() ; 
4216
4217   }
4218
4219   ar->Delete() ; 
4220
4221   
4222
4223   if (TreeK(fHeaderFile)) { // treeK found in header file
4224
4225     if (fDebug) 
4226
4227       cout << "INFO: AliEMCALGetter::ReadPrimaries -> TreeK found in " << fHeaderFile.Data() << endl ; 
4228
4229     fNPrimaries = gAlice->GetNtrack() ; 
4230
4231     fAlice = 0 ; 
4232
4233
4234
4235   } else { // treeK not found in header file
4236
4237
4238
4239     cerr << "ERROR: AliEMCALGetter::ReadPrimaries -> TreeK not  found " << endl ; 
4240
4241     return ;
4242
4243     
4244
4245   }
4246
4247   Int_t index = 0 ; 
4248
4249   for (index = 0 ; index < fNPrimaries; index++) { 
4250
4251     new ((*ar)[index]) TParticle(*(Primary(index)));
4252
4253   }
4254
4255 }
4256
4257
4258
4259 //____________________________________________________________________________ 
4260
4261 void AliEMCALGetter::Event(const Int_t event, const char* opt)
4262
4263 {
4264
4265   // Reads the content of all Tree's S, D and R
4266
4267   
4268
4269   if (event >= gAlice->TreeE()->GetEntries() ) {
4270
4271     cerr << "ERROR: AliEMCALGetter::Event -> " << event << " not found in TreeE!" << endl ; 
4272
4273     return ; 
4274
4275   }
4276
4277
4278
4279   Bool_t any = kFALSE ; 
4280
4281   if (strstr(opt,"A") ) // do not check the title of the branches
4282
4283     any = kTRUE; 
4284
4285
4286
4287   gAlice->GetEvent(event) ; 
4288
4289
4290
4291   if( strstr(opt,"R") )
4292
4293     ReadTreeR(event) ;
4294
4295
4296
4297   if( strstr(opt,"D") )
4298
4299     ReadTreeD(event) ;
4300
4301
4302
4303   if(strstr(opt,"S") )
4304
4305     ReadTreeS(event) ;
4306
4307
4308
4309   if(strstr(opt,"H") )
4310
4311     ReadTreeH() ;
4312
4313    
4314
4315   if( strstr(opt,"Q") )
4316
4317     ReadTreeQA() ;
4318
4319  
4320
4321   if( strstr(opt,"P") || (strcmp(opt,"")==0) )
4322
4323     ReadPrimaries() ;
4324
4325   
4326
4327 }
4328
4329
4330
4331 //____________________________________________________________________________ 
4332
4333 TObject * AliEMCALGetter::ReturnO(TString what, TString name, TString file) const 
4334
4335 {
4336
4337   // get the object named "what" from the folder
4338
4339   // folders are named like //Folders
4340
4341
4342
4343   if ( file.IsNull() ) 
4344
4345     file = fHeaderFile ; 
4346
4347
4348
4349   TFolder * folder = 0 ;
4350
4351   TObject * emcalO  = 0 ; 
4352
4353
4354
4355   if ( what.CompareTo("Primaries") == 0 ) {
4356
4357     folder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ; 
4358
4359     if (folder) 
4360
4361       emcalO  = dynamic_cast<TObject *>(folder->FindObject("Primaries")) ;  
4362
4363     else 
4364
4365       return 0 ; 
4366
4367   }
4368
4369   else if ( what.CompareTo("Hits") == 0 ) {
4370
4371     folder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("EMCAL")) ; 
4372
4373     if (folder) 
4374
4375       emcalO  = dynamic_cast<TObject *>(folder->FindObject("Hits")) ;  
4376
4377   }
4378
4379   else if ( what.CompareTo("SDigits") == 0 ) { 
4380
4381     file.ReplaceAll("/","_") ; 
4382
4383     TString path = "EMCAL/" + file  ; 
4384
4385     folder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject(path.Data())) ; 
4386
4387     if (folder) { 
4388
4389       if (name.IsNull())
4390
4391         name = fSDigitsTitle ; 
4392
4393       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
4394
4395     }
4396
4397   }
4398
4399   else if ( what.CompareTo("Digits") == 0 ){
4400
4401     folder = dynamic_cast<TFolder *>(fDigitsFolder->FindObject("EMCAL")) ; 
4402
4403     if (folder) { 
4404
4405       if (name.IsNull())
4406
4407         name = fDigitsTitle ; 
4408
4409       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
4410
4411     } 
4412
4413   }
4414
4415   else if ( what.CompareTo("TowerRecPoints") == 0 ) {
4416
4417     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("EMCAL/TowerRecPoints")) ; 
4418
4419     if (folder) { 
4420
4421       if (name.IsNull())
4422
4423         name = fRecPointsTitle ; 
4424
4425       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
4426
4427     } 
4428
4429   }
4430
4431   else if ( what.CompareTo("PreShowerRecPoints") == 0 ) {
4432
4433     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("EMCAL/PreShowerRecPoints")) ; 
4434
4435     if (folder) { 
4436
4437       if (name.IsNull())
4438
4439         name = fRecPointsTitle ; 
4440
4441       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
4442
4443     }   
4444
4445   }
4446
4447   /*
4448
4449   else if ( what.CompareTo("TrackSegments") == 0 ) {
4450
4451     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("EMCAL/TrackSegments")) ; 
4452
4453     if (folder) { 
4454
4455       if (name.IsNull())
4456
4457         name = fTrackSegmentsTitle ; 
4458
4459       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
4460
4461     }   
4462
4463   }
4464
4465   else if ( what.CompareTo("RecParticles") == 0 ) {
4466
4467     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("EMCAL/RecParticles")) ; 
4468
4469    if (folder) { 
4470
4471       if (name.IsNull())
4472
4473         name = fRecParticlesTitle ; 
4474
4475       emcalO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
4476
4477     }   
4478
4479  }
4480
4481   else if ( what.CompareTo("Alarms") == 0 ){ 
4482
4483     if (name.IsNull() ) 
4484
4485       emcalO = dynamic_cast<TObject *>(fQAFolder->FindObject("EMCAL")) ;  
4486
4487     else {
4488
4489       folder = dynamic_cast<TFolder *>(fQAFolder->FindObject("EMCAL")) ; 
4490
4491       if (!folder) 
4492
4493         emcalO = 0 ; 
4494
4495       else 
4496
4497         emcalO = dynamic_cast<TObject *>(folder->FindObject(name)) ;  
4498
4499     }
4500
4501   }
4502
4503 */
4504
4505   if (!emcalO) {
4506
4507     if(fDebug)
4508
4509       cout << "WARNING : AliEMCALGetter::ReturnO -> Object " << what << " not found in " << folder->GetName() << endl ; 
4510
4511     return 0 ;
4512
4513   }
4514
4515
4516
4517   return emcalO ;
4518
4519 }
4520
4521   
4522
4523 //____________________________________________________________________________ 
4524
4525 const TTask * AliEMCALGetter::ReturnT(TString what, TString name) const 
4526
4527 {
4528
4529   // get the TTask named "what" from the folder
4530
4531   // folders are named like //Folders/Tasks/what/EMCAL/name
4532
4533
4534
4535   TString search(what) ; 
4536
4537   if ( what.CompareTo("Clusterizer") == 0 ) 
4538
4539     search = "Reconstructioner" ; 
4540
4541   else if ( what.CompareTo("TrackSegmentMaker") == 0 ) 
4542
4543     search = "Reconstructioner" ; 
4544
4545   else if ( what.CompareTo("PID") == 0 ) 
4546
4547     search = "Reconstructioner" ; 
4548
4549   else if ( what.CompareTo("QATasks") == 0 ) 
4550
4551     search = "QA" ; 
4552
4553   
4554
4555   TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject(search)) ; 
4556
4557
4558
4559   if (!tasks) {
4560
4561     cerr << "ERROR: AliEMCALGetter::ReturnT -> Task " << what << " not found!" << endl ;  
4562
4563     return 0 ; 
4564
4565   }
4566
4567
4568
4569   TTask * emcalT = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
4570
4571   if (!emcalT) { 
4572
4573     cerr << "ERROR: AliEMCALGetter::ReturnT -> Task " << what << "/EMCAL not found!" << endl ;  
4574
4575     return 0 ; 
4576
4577   }
4578
4579   
4580
4581   TList * list = emcalT->GetListOfTasks() ; 
4582
4583  
4584
4585   if (what.CompareTo("SDigitizer") == 0) {  
4586
4587     if ( name.IsNull() )
4588
4589       name =  fSDigitsTitle ; 
4590
4591   } else  if (what.CompareTo("Digitizer") == 0){ 
4592
4593     if ( name.IsNull() )
4594
4595       name =  fDigitsTitle ;
4596
4597   } else  if (what.CompareTo("Clusterizer") == 0){ 
4598
4599     if ( name.IsNull() )
4600
4601       name =  fRecPointsTitle ;
4602
4603     name.Append(":clu") ;
4604
4605   }
4606
4607  //  else  if (what.CompareTo("TrackSegmentMaker") == 0){ 
4608
4609 //     if ( name.IsNull() )
4610
4611 //       name =  fTrackSegmentsTitle ;
4612
4613 //     name.Append(":tsm") ;
4614
4615 //   }
4616
4617 //   else  if (what.CompareTo("PID") == 0){ 
4618
4619 //     if ( name.IsNull() )
4620
4621 //       name =  fRecParticlesTitle ;
4622
4623 //     name.Append(":pid") ;
4624
4625 //   }
4626
4627 //   else  if (what.CompareTo("QATasks") == 0){ 
4628
4629 //     if ( name.IsNull() )
4630
4631 //       return emcalT ;
4632
4633 //   }
4634
4635   
4636
4637   TIter it(list) ;
4638
4639   TTask * task = 0 ; 
4640
4641   while((task = static_cast<TTask *>(it.Next()) )){
4642
4643     TString taskname(task->GetName()) ;
4644
4645     if(taskname.BeginsWith(name)){
4646
4647     return task ;}
4648
4649   }
4650
4651   
4652
4653   if(fDebug)
4654
4655     cout << "WARNING: AliEMCALGetter::ReturnT -> Task " << search << "/" << name << " not found!" << endl ; 
4656
4657   return 0 ;
4658
4659 }
4660
4661
4662
4663 //____________________________________________________________________________ 
4664
4665 void AliEMCALGetter::RemoveTask(TString opt, TString name) const 
4666
4667 {
4668
4669   // remove a task from the folder
4670
4671   // path is fTasksFolder/SDigitizer/EMCAL/name
4672
4673
4674
4675   TTask * task  = 0 ; 
4676
4677   TTask * emcal = 0 ; 
4678
4679   TList * lofTasks = 0 ; 
4680
4681
4682
4683   if (opt == "S") { // SDigitizer
4684
4685     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
4686
4687     if (!task) 
4688
4689       return ; 
4690
4691   } 
4692
4693   else if (opt == "D") { // Digitizer
4694
4695     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
4696
4697     if (!task) 
4698
4699       return ; 
4700
4701   }
4702
4703   else if (opt == "C") { // Clusterizer
4704
4705     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
4706
4707     if (!task) 
4708
4709       return ; 
4710
4711   }
4712
4713   else {
4714
4715     cerr << "WARNING: AliEMCALGetter::RemoveTask -> Unknown option " << opt.Data() << endl ; 
4716
4717     return ; 
4718
4719   }    
4720
4721   emcal =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("EMCAL")) ;
4722
4723   if (!emcal)
4724
4725     return ; 
4726
4727   lofTasks = emcal->GetListOfTasks() ;
4728
4729   if (!lofTasks) 
4730
4731     return ; 
4732
4733   TObject * obj = lofTasks->FindObject(name) ; 
4734
4735   if (obj) 
4736
4737     lofTasks->Remove(obj) ;
4738
4739
4740
4741 }
4742
4743   
4744
4745 //____________________________________________________________________________ 
4746
4747 void AliEMCALGetter::RemoveObjects(TString opt, TString name) const 
4748
4749 {
4750
4751   // remove SDigits from the folder
4752
4753   // path is fSDigitsFolder/fHeaderFileName/name
4754
4755
4756
4757   TFolder * emcal     = 0 ; 
4758
4759   TFolder * emcalmain = 0 ; 
4760
4761
4762
4763   if (opt == "H") { // Hits
4764
4765     emcal = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ;
4766
4767     if (!emcal) 
4768