Removed fAlice and changed ReadTreeK to make it look as the others. Event now require...
[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   fToSplit    = toSplit ;
192
193   fHeaderFile = headerFile ; 
194
195
196
197   fPrimaries = new TObjArray(1) ;
198
199
200
201   fModuleFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Configuration/Modules")); 
202
203   fPrimariesFolder = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data")); 
204
205   fHitsFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/Hits")); 
206
207   fSDigitsFolder   = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/SDigits")); 
208
209   fDigitsFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/Data")); 
210
211   fRecoFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/RecData")); 
212
213   //fQAFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Conditions/QA")); 
214
215   fTasksFolder     = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Tasks")) ; 
216
217
218
219   //Set titles to branches and create PHOS specific folders
220
221   SetTitle(branchTitle) ;
222
223   
224
225   if ( fHeaderFile != "aliroot"  ) { // to call the getter without a file
226
227     //open headers file
228
229     fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
230
231   
232
233     if(!fFile){    //if file was not opened yet, read gAlice
234
235       fFile = TFile::Open(fHeaderFile.Data(), "update") ;   
236
237       if (!fFile->IsOpen()) {
238
239         cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot open " << fHeaderFile.Data() << endl ; 
240
241         fFailed = kTRUE ;
242
243         return ;  
244
245       }
246
247       gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
248
249     }
250
251   }
252
253   
254
255   if (!gAlice) {
256
257     cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ; 
258
259     fFailed = kTRUE ;
260
261     return ; 
262
263   }
264
265   if (!EMCAL()) {
266
267     if (fDebug)
268
269       cout << "INFO: AliEMCALGetter -> Posting EMCAL to Folders" << endl ; 
270
271     if (gAlice->GetDetector("EMCAL")) {
272
273       AliConfig * conf = AliConfig::Instance() ;
274
275       conf->Add(static_cast<AliDetector*>(gAlice->GetDetector("EMCAL"))) ; 
276
277       conf->Add(static_cast<AliModule*>(gAlice->GetDetector("EMCAL"))) ;
278
279     }
280
281     else 
282
283       cerr << "ERROR: AliEMCALGetter -> detector EMCAL not found" << endl ;
284
285   }
286
287   
288
289   fDebug=0;
290
291 }
292
293
294
295 //____________________________________________________________________________ 
296
297 AliEMCALGetter::~AliEMCALGetter()
298
299 {
300
301   if (fPrimaries) {
302
303     fPrimaries->Delete() ; 
304
305     delete fPrimaries ; 
306
307   }
308
309
310
311   TFolder * emcalF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
312
313   TCollection * folderslist = emcalF->GetListOfFolders() ; 
314
315   TIter next(folderslist) ; 
316
317   TFolder * folder = 0 ; 
318
319   while ( (folder = static_cast<TFolder*>(next())) ) 
320
321     emcalF->Remove(folder) ; 
322
323
324
325   if (fFile) { 
326
327     fFile->Close() ;  
328
329     delete fFile ; 
330
331     fFile = 0 ;
332
333   }
334
335   fgObjGetter = 0 ; 
336
337
338
339 }
340
341
342
343 //____________________________________________________________________________ 
344
345 void AliEMCALGetter::CloseFile()
346
347 {
348
349   delete gAlice ;  
350
351   gAlice = 0 ; 
352
353 }
354
355
356
357 //____________________________________________________________________________ 
358
359 const TFolder * AliEMCALGetter::Folder(const TString what) const {
360
361
362
363   // returns the EMCAL folder required by what
364
365   // what = hits, sdigits, digits
366
367
368
369   if ( what == "hits" ) 
370
371     return dynamic_cast<const TFolder *>(fHitsFolder->FindObject("EMCAL")) ; 
372
373   else if ( what == "sdigits" ) 
374
375     return  dynamic_cast<const TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ; 
376
377   else if ( what == "digits" ) 
378
379     return  dynamic_cast<const TFolder *>(fDigitsFolder->FindObject("EMCAL")) ; 
380
381   else {
382
383     cerr << "ERROR: AliEMCALGetter::GetFolder -> " << what.Data() << " illegal option (hits, sdigits, digits) " << endl ; 
384
385     return 0 ; 
386
387   }
388
389 }
390
391
392
393 //____________________________________________________________________________ 
394
395 AliEMCALGetter * AliEMCALGetter::GetInstance()
396
397 {
398
399   // Returns the pointer of the unique instance already defined
400
401   
402
403   if ( fgObjGetter ) {
404
405     return fgObjGetter ;
406
407   }
408
409   else {
410
411     // cout << "AliEMCALGetter::GetInstance ERROR: not yet initialized" << endl ;
412
413     return 0 ;
414
415   }
416
417 }
418
419
420
421 //____________________________________________________________________________ 
422
423 AliEMCALGetter * AliEMCALGetter::GetInstance(const char* headerFile,
424
425                                              const char* branchTitle,
426
427                                              const Bool_t toSplit)
428
429 {
430
431   // Creates and returns the pointer of the unique instance
432
433   // Must be called only when the environment has changed 
434
435
436
437   if(!fgObjGetter){
438
439     fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
440
441     if(fgObjGetter->fFailed)
442
443       return 0;
444
445     else
446
447       return fgObjGetter ;
448
449   }
450
451
452
453   //First checks, if header file already opened
454
455   if(!fgObjGetter->fFile){
456
457      fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
458
459     if(fgObjGetter->fFailed)
460
461       return 0;
462
463     else
464
465       return fgObjGetter ;
466
467   }
468
469  
470
471   if(fgObjGetter->fHeaderFile.CompareTo(headerFile)==0){ //Opened the same header file   
472
473     if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0)&&   //Open the same branch title
474
475        (toSplit==fgObjGetter->fToSplit)){                          //Nothing should be cleaned
476
477       return fgObjGetter ;
478
479     }
480
481     else{ //Clean all data and AliEMCAL...zers
482
483       if(fgObjGetter->fToSplit)
484
485         fgObjGetter->CloseSplitFiles() ;          
486
487       fgObjGetter->CleanWhiteBoard() ;
488
489       fgObjGetter->fToSplit = toSplit ;
490
491       fgObjGetter->SetTitle(branchTitle) ;
492
493       return fgObjGetter ;
494
495     }
496
497   }
498
499   else{  //Close already opened files, clean memory and open new header file
500
501     if(gAlice)
502
503       delete gAlice ;
504
505     gAlice= 0;
506
507     if(fgObjGetter->fFile){
508
509       fgObjGetter->fFile->Close() ;
510
511       fgObjGetter->fFile=0;
512
513     }
514
515     if(fgObjGetter->fToSplit)
516
517       fgObjGetter->CloseSplitFiles() ;
518
519     fgObjGetter->CleanWhiteBoard() ;    
520
521     fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
522
523     return fgObjGetter ; 
524
525   }
526
527   return fgObjGetter ; 
528
529   
530
531 }
532
533
534
535 //____________________________________________________________________________ 
536
537 const Bool_t AliEMCALGetter::BranchExists(const TString recName) const
538
539 {
540
541   //Looks in the tree Tree"name" if branch with current name olready exists
542
543   
544
545   TString filename("") ;
546
547   TString name, dataname, zername;
548
549   if(recName == "SDigits"){
550
551     filename=fSDigitsFileName ;
552
553     name = "TreeS0" ;
554
555     dataname = "PHOS" ;
556
557     zername = "AliPHOSSDigitizer" ;
558
559   }
560
561   else
562
563     if(recName == "Digits"){
564
565       filename=fDigitsFileName ;
566
567       name = "TreeD0" ;
568
569       dataname = "PHOS" ;
570
571       zername = "AliPHOSDigitizer" ;
572
573     }
574
575     else
576
577       if(recName =="RecPoints"){
578
579         filename=fRecPointsFileName ;
580
581         name = "TreeR0" ;
582
583         dataname = "PHOSEmcRP" ;
584
585         zername = "AliPHOSClusterizer" ;
586
587       }
588
589       else
590
591         if(recName == "TrackSegments"){
592
593           filename=fTrackSegmentsFileName ;
594
595           name = "TreeR0" ;
596
597           dataname = "PHOSTS" ;
598
599           zername = "AliPHOSTrackSegmentMaker" ;
600
601         }        
602
603         else
604
605           if(recName == "RecParticles"){
606
607             filename= fRecParticlesFileName ;
608
609             name = "TreeR0" ;
610
611             dataname = "PHOSRP" ;
612
613             zername = "AliPHOSPID" ;
614
615           }
616
617           else
618
619             return kFALSE ;
620
621   
622
623   TFile * file ;
624
625   TTree * tree ;
626
627   if(fToSplit){
628
629     file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
630
631     if(!file)
632
633       file = TFile::Open(fSDigitsFileName.Data(),"update");
634
635   }
636
637   else
638
639     file = fFile ;
640
641   
642
643   tree = (TTree *)file->Get(name.Data()) ;
644
645   
646
647   if(!tree ) 
648
649     return kFALSE ;
650
651
652
653   TObjArray * lob = static_cast<TObjArray*>(tree->GetListOfBranches()) ;
654
655   TIter next(lob) ; 
656
657   TBranch * branch = 0 ;  
658
659   TString titleName(fBranchTitle);
660
661   titleName+=":";
662
663   while ((branch = (static_cast<TBranch*>(next())))) {
664
665     TString branchName(branch->GetName() ) ; 
666
667     TString branchTitle(branch->GetTitle() ) ;  
668
669     if ( branchName.BeginsWith(dataname) && branchTitle.BeginsWith(fBranchTitle) ){  
670
671       cerr << "WARNING: AliEMCALGetter::BranchExists -> branch " << dataname.Data() << " with title " << fBranchTitle << " already exits in "
672
673            << name.Data() << endl;
674
675       return kTRUE ;
676
677     }
678
679     if ( branchName.BeginsWith(zername) &&  branchTitle.BeginsWith(titleName) ){
680
681       cerr << "WARNING: AliEMCALGetter::BranchExists -> branch AliEMCAL... with title " << branch->GetTitle() << " already exits in "
682
683            << name.Data() << endl;     
684
685       return kTRUE ; 
686
687     }
688
689   }
690
691     //We can't delete three if gAlice points to it... To be redisigned somehow???!!!
692
693   if(!fToSplit){
694
695     if(name.Contains("TreeS"))
696
697       if(tree!=gAlice->TreeS())
698
699         tree->Delete();
700
701     if(name.Contains("TreeD"))
702
703       if(tree!=gAlice->TreeD())
704
705         tree->Delete();
706
707     if(name.Contains("TreeR"))
708
709       if(tree!=gAlice->TreeR())
710
711         tree->Delete();    
712
713   }
714
715   return kFALSE ;
716
717   
718
719 }
720
721
722
723 //____________________________________________________________________________ 
724
725 void AliEMCALGetter::ListBranches(Int_t event) const  
726
727 {
728
729   
730
731   TBranch * branch = 0 ; 
732
733   if (gAlice->GetEvent(event) == -1)
734
735     return ; 
736
737
738
739   TTree * t =  gAlice->TreeH() ; 
740
741   if(t){
742
743     cout << "INFO: AliEMCALGetter::ListBranches -> ****** Hits    : " << endl ; 
744
745     TObjArray * lob = t->GetListOfBranches() ;
746
747     TIter next(lob) ; 
748
749     while ( (branch = static_cast<TBranch*>(next())) )
750
751       cout << "             " << branch->GetName() << endl ; 
752
753   } else 
754
755     cerr << "WARNING::AliEMCALGetter::ListBranches -> TreeH not found for event " << event << endl ;  
756
757   
758
759   
760
761   t = gAlice->TreeS() ;
762
763   if(t){
764
765     cout << "INFO: AliEMCALGetter::ListBranches -> ****** SDigits : " << endl ; 
766
767     TObjArray * lob = t->GetListOfBranches() ;
768
769     TIter next(lob) ; 
770
771     while ( (branch = static_cast<TBranch*>(next())) )
772
773       cout << "             " << branch->GetName() << " " << branch->GetTitle() << endl ; 
774
775   } else 
776
777     cerr << "WARNING::AliEMCALGetter::ListBranches -> TreeS not found for event " << event << endl ;  
778
779     
780
781   t = gAlice->TreeD() ;
782
783   if(t){
784
785     cout << "INFO: AliEMCALGetter::ListBranches -> ****** Digits  : " << endl ; 
786
787     TObjArray * lob = t->GetListOfBranches() ;
788
789     TIter next(lob) ; 
790
791     while ( (branch = static_cast<TBranch*>(next())) )
792
793       cout << "             " << branch->GetName() << " " << branch->GetTitle() << endl ; 
794
795   } else 
796
797     cerr << "WARNING::AliEMCALGetter::ListBranches -> TreeD not found for event " << event << endl ;  
798
799   
800
801
802
803   t = gAlice->TreeR() ;
804
805   if(t){
806
807     cout << "INFO: AliEMCALGetter::ListBranches -> ****** Recon   : " << endl ; 
808
809     TObjArray * lob = t->GetListOfBranches() ;
810
811     TIter next(lob) ; 
812
813     while ( (branch = static_cast<TBranch*>(next())) )
814
815       cout << "             " << branch->GetName() << " " << branch->GetTitle() << endl ; 
816
817   } else 
818
819     cerr << "WARNING::AliEMCALGetter::ListBranches -> TreeR not found for event " << event << endl ;  
820
821   
822
823 }
824
825
826
827 //____________________________________________________________________________ 
828
829 void AliEMCALGetter::NewBranch(TString name, Int_t event)  
830
831 {
832
833   fBranchTitle = fSDigitsTitle = fDigitsTitle = fRecPointsTitle = fTrackSegmentsTitle = fRecParticlesTitle =  name ; 
834
835   Event(event) ; 
836
837 }
838
839
840
841 //____________________________________________________________________________ 
842
843 Bool_t AliEMCALGetter::NewFile(TString name)  
844
845 {
846
847   fHeaderFile = name ; 
848
849   fFile->Close() ; 
850
851   fFailed = kFALSE; 
852
853
854
855   fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
856
857   if(!fFile) {    //if file was not opened yet, read gAlice
858
859     fFile = TFile::Open(fHeaderFile.Data(),"update") ;
860
861     if (!fFile->IsOpen()) {
862
863       cerr << "ERROR : AliEMCALGetter::NewFile -> Cannot open " << fHeaderFile.Data() << endl ; 
864
865       fFailed = kTRUE ;
866
867       return fFailed ;  
868
869     }
870
871     gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
872
873   } 
874
875   
876
877   if (!gAlice) {
878
879     cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ; 
880
881     fFailed = kTRUE ;
882
883     return fFailed ; 
884
885   }
886
887   return fFailed ; 
888
889 }
890
891
892
893 //____________________________________________________________________________ 
894
895 const AliEMCAL * AliEMCALGetter::EMCAL() 
896
897 {
898
899   // returns the EMCAL object 
900
901   AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(fModuleFolder->FindObject("EMCAL")) ;  
902
903   if (!emcal) 
904
905     if (fDebug)
906
907       cout << "WARNING: AliEMCALGetter::EMCAL -> EMCAL module not found in Folders" << endl ; 
908
909   return emcal ; 
910
911 }  
912
913
914
915 //____________________________________________________________________________ 
916
917 AliEMCALGeometry * AliEMCALGetter::EMCALGeometry() 
918
919 {
920
921   AliEMCALGeometry * rv = 0 ; 
922
923   if (EMCAL() )
924
925     rv =  EMCAL()->GetGeometry() ;
926
927   return rv ; 
928
929
930
931
932
933 //____________________________________________________________________________ 
934
935 const Bool_t AliEMCALGetter::PostPrimaries(void) const 
936
937 {  //------- Primaries ----------------------
938
939
940
941   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
942
943   
944
945   TFolder * primariesFolder = dynamic_cast<TFolder*>(fPrimariesFolder->FindObject("Primaries")) ; 
946
947   if ( !primariesFolder ) {
948
949     if (fDebug) {
950
951       cout << "WARNING: AliEMCALGetter::Post Primaries -> Folder //" << fPrimariesFolder->GetName() << "/Primaries/ not found!" << endl;
952
953       cout << "INFO:    AliEMCALGetter::Post Primaries -> Adding Folder //" << fPrimariesFolder->GetName() << "/Primaries/"  << endl;
954
955     }
956
957     primariesFolder = fPrimariesFolder->AddFolder("Primaries", "Primaries particles from TreeK") ; 
958
959   }    
960
961   TClonesArray *primaries=  new TClonesArray("TParticle",1000) ;
962
963   primaries->SetName("Primaries") ;
964
965   primariesFolder->Add(primaries) ; 
966
967   
968
969   return kTRUE;
970
971
972
973
974
975 //____________________________________________________________________________ 
976
977 TObject** AliEMCALGetter::PrimariesRef(void) const 
978
979 {  //------- Primaries ----------------------
980
981
982
983   
984
985   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
986
987   if ( !fPrimariesFolder ) {
988
989     cerr << "ERROR: AliEMCALGetter::PrimariesRef -> Folder //" << fPrimariesFolder << " not found!" << endl;
990
991     abort() ;
992
993   }    
994
995  
996
997   TFolder * primariesFolder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ;
998
999   if ( !primariesFolder ) {
1000
1001     cerr << "ERROR: AliEMCALGetter::PrimariesRef -> Folder //" << fPrimariesFolder << "/Primaries/ not found!" << endl;  
1002
1003     abort() ;
1004
1005   }
1006
1007  
1008
1009   TObject * p = primariesFolder->FindObject("Primaries") ;
1010
1011   if(!p) {
1012
1013     cerr << "ERROR: AliEMCALGetter::PrimariesRef -> " << primariesFolder->GetName() << "/Primaries not found !" << endl ; 
1014
1015     abort() ;
1016
1017   }
1018
1019   else
1020
1021     return primariesFolder->GetListOfFolders()->GetObjectRef(p) ;
1022
1023 }
1024
1025
1026
1027 //____________________________________________________________________________ 
1028
1029 const Bool_t AliEMCALGetter::PostHits(void) const 
1030
1031 {  //------- Hits ----------------------
1032
1033
1034
1035   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
1036
1037   
1038
1039   TFolder * emcalFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ; 
1040
1041   if ( !emcalFolder ) {
1042
1043     if (fDebug) {
1044
1045       cout << "WARNING: AliEMCALGetter::Post H -> Folder //" << fHitsFolder << "/EMCAL/ not found!" << endl;
1046
1047       cout << "INFO:    AliEMCALGetter::Post H -> Adding Folder //" << fHitsFolder << "/EMCAL/"  << endl;
1048
1049     }
1050
1051     emcalFolder = fHitsFolder->AddFolder("EMCAL", "Hits from EMCAL") ; 
1052
1053   }    
1054
1055   TClonesArray *hits=  new TClonesArray("AliEMCALHit",1000) ;
1056
1057   hits->SetName("Hits") ;
1058
1059   emcalFolder->Add(hits) ; 
1060
1061   
1062
1063   return kTRUE;
1064
1065
1066
1067
1068
1069 //____________________________________________________________________________ 
1070
1071 TObject ** AliEMCALGetter::HitsRef(void) const 
1072
1073 {  //------- Hits ----------------------
1074
1075
1076
1077   
1078
1079   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
1080
1081   if ( !fHitsFolder ) {
1082
1083     cerr << "ERROR: AliEMCALGetter::Post H -> Folder //" << fHitsFolder << " not found!" << endl;
1084
1085     return 0;
1086
1087   }    
1088
1089  
1090
1091   TFolder * emcalFolder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("EMCAL")) ;
1092
1093   if ( !emcalFolder ) {
1094
1095     cerr << "ERROR: AliEMCALGetter::Post HRef -> Folder //" << fHitsFolder << "/EMCAL/ not found!" << endl;  
1096
1097     return 0;
1098
1099   }
1100
1101  
1102
1103   TObject * h = emcalFolder->FindObject("Hits") ;
1104
1105   if(!h) {
1106
1107     cerr << "ERROR: AliEMCALGetter::HRef -> " << emcalFolder->GetName() << "/Hits not found !" << endl ; 
1108
1109     return 0 ;
1110
1111   }
1112
1113   else
1114
1115     return emcalFolder->GetListOfFolders()->GetObjectRef(h) ;
1116
1117 }
1118
1119
1120
1121 //____________________________________________________________________________ 
1122
1123 const Bool_t AliEMCALGetter::PostSDigits(const char * name, const char * headerFile) const 
1124
1125 {  //---------- SDigits -------------------------
1126
1127
1128
1129   
1130
1131   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/headerFile/sdigitsname
1132
1133   // because you can have sdigits from several hit files for mixing
1134
1135   
1136
1137   TFolder * emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
1138
1139   if ( !emcalFolder ) {
1140
1141     if (fDebug) {
1142
1143       cout << "WARNING: AliEMCALGetter::Post S -> Folder //" << fSDigitsFolder << "/EMCAL/ not found!" << endl;
1144
1145       cout << "INFO:    AliEMCALGetter::Post S -> Adding Folder //" << fHitsFolder << "/EMCAL/" << endl;
1146
1147     }
1148
1149     emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; 
1150
1151   }    
1152
1153
1154
1155   TString subdir(headerFile) ;
1156
1157   subdir.ReplaceAll("/", "_") ; 
1158
1159   TFolder * emcalSubFolder = dynamic_cast<TFolder*>(emcalFolder->FindObject(subdir)) ; 
1160
1161   if ( !emcalSubFolder ) 
1162
1163     emcalSubFolder = emcalFolder->AddFolder(subdir, ""); 
1164
1165
1166
1167   
1168
1169   TObject * sd  = emcalSubFolder->FindObject(name); 
1170
1171   if ( !sd ) {
1172
1173     TClonesArray * sdigits = new TClonesArray("AliEMCALDigit",1) ;
1174
1175     sdigits->SetName(name) ;
1176
1177     emcalSubFolder->Add(sdigits) ;
1178
1179   }
1180
1181   
1182
1183   return kTRUE;
1184
1185
1186
1187 //____________________________________________________________________________ 
1188
1189 TObject ** AliEMCALGetter::SDigitsRef(const char * name, const char * file) const 
1190
1191 {  //------- SDigits ----------------------
1192
1193   
1194
1195   // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/filename/SDigits
1196
1197
1198
1199   if ( !fSDigitsFolder ) {
1200
1201     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //" << fSDigitsFolder << " not found!" << endl;
1202
1203     abort() ;
1204
1205   }    
1206
1207  
1208
1209   TFolder * emcalFolder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
1210
1211   if ( !emcalFolder ) {
1212
1213     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //" << fSDigitsFolder << "/EMCAL/ not found!" << endl;
1214
1215     abort() ;
1216
1217   }
1218
1219
1220
1221   TFolder * emcalSubFolder = 0 ;
1222
1223   if(file)
1224
1225     emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(file)) ;
1226
1227   else
1228
1229     emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(fHeaderFile)) ;
1230
1231   
1232
1233   if(!emcalSubFolder) {
1234
1235     cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //Folders/RunMC/Event/Data/EMCAL/" << file << "not found!" << endl;
1236
1237     abort() ;
1238
1239   }
1240
1241
1242
1243   TObject * dis = emcalSubFolder->FindObject(name) ;
1244
1245   if(!dis) {
1246
1247     cerr << "ERROR: AliEMCALGetter::DigitesSRef -> object " << name << " not found! " << endl ; 
1248
1249     abort() ;
1250
1251   }
1252
1253   else
1254
1255     return emcalSubFolder->GetListOfFolders()->GetObjectRef(dis) ;
1256
1257
1258
1259 }
1260
1261
1262
1263 //____________________________________________________________________________ 
1264
1265 const Bool_t AliEMCALGetter::PostSDigitizer(AliEMCALSDigitizer * sdigitizer) const 
1266
1267 {  //---------- SDigitizer -------------------------
1268
1269     
1270
1271   // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
1272
1273
1274
1275
1276
1277   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
1278
1279
1280
1281   if ( !sd ) {
1282
1283     cerr << "ERROR: AliEMCALGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
1284
1285     return kFALSE ;
1286
1287   }        
1288
1289   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
1290
1291   if ( !emcal )  {
1292
1293     if (fDebug) {
1294
1295       cout <<"WARNING: AliEMCALGetter::Post Ser ->//" << fTasksFolder << "/SDigitizer/EMCAL/ not found!" << endl;  
1296
1297       cout <<"INFO: AliEMCALGetter::Post Ser -> Adding //" << fTasksFolder << "/SDigitizer/EMCAL/" << endl;
1298
1299     }
1300
1301     emcal = new TTask("EMCAL", "") ; 
1302
1303     sd->Add(emcal) ; 
1304
1305   } 
1306
1307   AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdigitizer->GetName() )); 
1308
1309   if (emcalsd) { 
1310
1311     if (fDebug)
1312
1313       cout << "INFO: AliEMCALGetter::Post Ser -> Task " << sdigitizer->GetName() << " already exists" << endl ; 
1314
1315     emcal->GetListOfTasks()->Remove(emcalsd) ;
1316
1317   }
1318
1319   emcal->Add(sdigitizer) ;      
1320
1321   return kTRUE; 
1322
1323   
1324
1325 }
1326
1327
1328
1329 //____________________________________________________________________________ 
1330
1331 TObject ** AliEMCALGetter::SDigitizerRef(const char * name) const 
1332
1333 {  
1334
1335
1336
1337   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
1338
1339   if ( !sd ) {
1340
1341     cerr << "ERROR: AliEMCALGetter::Post SerRef -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
1342
1343     abort();
1344
1345   }        
1346
1347
1348
1349   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
1350
1351   if ( !emcal )  {
1352
1353     cerr <<"ERROR: AliEMCALGetter::Post SerRef ->  //" << fTasksFolder << "/SDigitizer/EMCAL not found!" << endl;
1354
1355     abort();
1356
1357   }        
1358
1359
1360
1361   TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ; 
1362
1363
1364
1365   return emcal->GetListOfTasks()->GetObjectRef(task) ;
1366
1367
1368
1369 }
1370
1371
1372
1373 //____________________________________________________________________________ 
1374
1375 const Bool_t AliEMCALGetter::PostSDigitizer(const char * name, const char * file) const 
1376
1377 {  //---------- SDigitizer -------------------------
1378
1379   
1380
1381  // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
1382
1383
1384
1385   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
1386
1387   if ( !sd ) {
1388
1389     cerr << "ERROR: AliEMCALGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl;
1390
1391     return kFALSE ;
1392
1393   }        
1394
1395
1396
1397   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
1398
1399   if ( !emcal )  {
1400
1401     if (fDebug) {
1402
1403       cout <<"WARNING: AliEMCALGetter::Post Ser ->  //" << fTasksFolder << "/SDigitizer/EMCAL/ not found!" << endl;
1404
1405       cout <<"INFO: AliEMCALGetter::Post Ser -> Adding  //" << fTasksFolder << "/SDigitizer/EMCAL" << endl;
1406
1407     }
1408
1409     emcal = new TTask("EMCAL", "") ; 
1410
1411     sd->Add(emcal) ; 
1412
1413   } 
1414
1415
1416
1417   TString sdname(name) ;
1418
1419   sdname.Append(":") ;
1420
1421   sdname.Append(file);
1422
1423   sdname.ReplaceAll("/","_") ; 
1424
1425   AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdname )); 
1426
1427   if (!emcalsd) {
1428
1429     emcalsd = new AliEMCALSDigitizer() ;  
1430
1431     //Note, we can not call constructor with parameters: it will call Getter and screw up everething
1432
1433     emcalsd->SetName(sdname) ;
1434
1435     emcalsd->SetTitle(file) ;
1436
1437     emcal->Add(emcalsd) ;       
1438
1439   }
1440
1441   return kTRUE; 
1442
1443   
1444
1445 }
1446
1447
1448
1449 //____________________________________________________________________________ 
1450
1451 const Bool_t AliEMCALGetter::PostDigits(const char * name) const 
1452
1453 {  //---------- Digits -------------------------
1454
1455
1456
1457   // the hierarchy is //Folders/Run/Event/Data/EMCAL/SDigits/name
1458
1459
1460
1461   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ;
1462
1463
1464
1465   if ( !emcalFolder ) {
1466
1467     if (fDebug) {
1468
1469       cout << "WARNING: AliEMCALGetter::Post D -> Folder //" << fDigitsFolder << "/EMCAL/ not found!" << endl;
1470
1471       cout << "INFO:    AliEMCALGetter::Post D -> Adding Folder //" << fDigitsFolder << "/EMCAL/" << endl;
1472
1473     }
1474
1475     emcalFolder = fDigitsFolder->AddFolder("EMCAL", "Digits from EMCAL") ;  
1476
1477   }    
1478
1479  
1480
1481   TObject*  dig = emcalFolder->FindObject( name ) ;
1482
1483   if ( !dig ) {
1484
1485     TClonesArray * digits = new TClonesArray("AliEMCALDigit",1000) ;
1486
1487     digits->SetName(name) ;
1488
1489     emcalFolder->Add(digits) ;  
1490
1491   }
1492
1493   return kTRUE; 
1494
1495 }
1496
1497
1498
1499 //____________________________________________________________________________ 
1500
1501 TObject ** AliEMCALGetter::DigitsRef(const char * name) const 
1502
1503 { //------- Digits ----------------------
1504
1505   
1506
1507   // the hierarchy is //Folders/Run/Event/Data/EMCAL/Digits/name
1508
1509
1510
1511   if ( !fDigitsFolder ) {
1512
1513     cerr << "ERROR: AliEMCALGetter::Post DRef -> Folder //" << fDigitsFolder << " not found!" << endl;
1514
1515     abort() ;
1516
1517   }    
1518
1519   
1520
1521   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("EMCAL")) ; 
1522
1523   if ( !emcalFolder ) {
1524
1525     cerr << "ERROR: AliEMCALGetter::DRef -> Folder //" << fDigitsFolder << "/EMCAL/ not found!" << endl;
1526
1527     abort() ;
1528
1529   }    
1530
1531
1532
1533   TObject * d = emcalFolder->FindObject(name) ;
1534
1535   if(!d) {
1536
1537     cerr << "ERROR: AliEMCALGetter::DigitsRef -> object " << name << " not found! " << endl ; 
1538
1539     abort() ;
1540
1541   }   
1542
1543   else
1544
1545     return emcalFolder->GetListOfFolders()->GetObjectRef(d) ;
1546
1547
1548
1549 }
1550
1551
1552
1553 //____________________________________________________________________________ 
1554
1555 const Bool_t AliEMCALGetter::PostDigitizer(AliEMCALDigitizer * digitizer) const 
1556
1557 {  //---------- Digitizer -------------------------
1558
1559   
1560
1561   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
1562
1563
1564
1565   if ( !sd ) {
1566
1567     cerr << "ERROR: AliEMCALGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
1568
1569     return kFALSE ;
1570
1571   }        
1572
1573   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
1574
1575   if ( !emcal )  {
1576
1577     if (fDebug) {
1578
1579       cout <<"WARNING: AliEMCALGetter::Post Der ->  //" << fTasksFolder << "/Digitizer/EMCAL not found!" << endl;
1580
1581       cout <<"INFO: AliEMCALGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/EMCAL" << endl; 
1582
1583     }
1584
1585     emcal = new TTask("EMCAL", "") ; 
1586
1587     sd->Add(emcal) ; 
1588
1589   } 
1590
1591
1592
1593     AliEMCALDigitizer * emcald = dynamic_cast<AliEMCALDigitizer*>(emcal->GetListOfTasks()->FindObject(digitizer->GetName())) ; 
1594
1595     if (emcald) { 
1596
1597       emcald->Delete() ;
1598
1599       emcal->GetListOfTasks()->Remove(emcald) ;
1600
1601     }
1602
1603     emcal->Add(digitizer) ; 
1604
1605     return kTRUE; 
1606
1607 }  
1608
1609
1610
1611 //____________________________________________________________________________ 
1612
1613 const Bool_t AliEMCALGetter::PostDigitizer(const char * name) const 
1614
1615 {  //---------- Digitizer -------------------------
1616
1617   
1618
1619  // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
1620
1621
1622
1623   TTask * d  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
1624
1625   if ( !d ) {
1626
1627     cerr << "ERROR: AliEMCALGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl;
1628
1629     return kFALSE ;
1630
1631   }        
1632
1633
1634
1635   TTask * emcal = dynamic_cast<TTask*>(d->GetListOfTasks()->FindObject("EMCAL")) ; 
1636
1637   if ( !emcal )  {
1638
1639     if (fDebug) {
1640
1641       cout <<"WARNING: AliEMCALGetter::Post Der -> //" << fTasksFolder << "/Digitizer/EMCAL not found!" << endl; 
1642
1643       cout <<"INFO: AliEMCALGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/EMCAL" << endl;
1644
1645     }
1646
1647     emcal = new TTask("EMCAL", "") ; 
1648
1649     d->Add(emcal) ; 
1650
1651
1652
1653
1654
1655   AliEMCALDigitizer * emcald = dynamic_cast<AliEMCALDigitizer*>(emcal->GetListOfTasks()->FindObject(name)) ; 
1656
1657   if (!emcald) { 
1658
1659     emcald = new AliEMCALDigitizer() ;
1660
1661     emcald->SetName(fDigitsTitle) ;
1662
1663     emcald->SetTitle(fHeaderFile) ;
1664
1665     emcal->Add(emcald) ;
1666
1667   }
1668
1669   return kTRUE;  
1670
1671 }
1672
1673
1674
1675 //____________________________________________________________________________ 
1676
1677 TObject ** AliEMCALGetter::DigitizerRef(const char * name) const 
1678
1679 {  
1680
1681   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
1682
1683   if ( !sd ) {
1684
1685     cerr << "ERROR: AliEMCALGetter::Post DerRef -> Task //" << fTasksFolder->GetName() << "/Digitizer not found!" << endl;
1686
1687     abort();
1688
1689   }        
1690
1691
1692
1693   TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
1694
1695   if ( !emcal )  {
1696
1697     cerr <<"ERROR: AliEMCALGetter::Post DerRef ->  //" << fTasksFolder->GetName() << "/Digitizer/EMCAL" << endl;
1698
1699     abort();
1700
1701   }        
1702
1703
1704
1705   TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ; 
1706
1707
1708
1709   return emcal->GetListOfTasks()->GetObjectRef(task) ;
1710
1711
1712
1713 }
1714
1715  
1716
1717 //____________________________________________________________________________ 
1718
1719 const Bool_t AliEMCALGetter::PostRecPoints(const char * name) const 
1720
1721 { // -------------- RecPoints -------------------------------------------
1722
1723   
1724
1725   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TowerRecPoints/name
1726
1727   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/PreShowerRecPoints/name
1728
1729
1730
1731   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ; 
1732
1733   
1734
1735   if ( !emcalFolder ) {
1736
1737     if (fDebug) {
1738
1739       cout << "WARNING: AliEMCALGetter::Post RPo -> Folder //" << fRecoFolder << "/EMCAL/ not found!" << endl;
1740
1741       cout << "INFO:    AliEMCALGetter::Post Rpo -> Adding Folder //" << fRecoFolder << "/EMCAL/" << endl;
1742
1743     }
1744
1745     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;  
1746
1747   }    
1748
1749   
1750
1751   // Tower RecPoints 
1752
1753   TFolder * emcalRPoTowerFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("TowerRecPoints")) ;
1754
1755   if ( !emcalRPoTowerFolder ) {
1756
1757     if (fDebug) {
1758
1759       cout << "WARNING: AliEMCALGetter::Post RPo -> Folder //" << fRecoFolder << "/EMCAL/TowerRecPoints/ not found!" << endl;
1760
1761       cout << "INFO:    AliEMCALGetter::Post Rpo -> Adding Folder //" << fRecoFolder << "/EMCAL/TowerRecPoints not found!" << endl;
1762
1763     }
1764
1765     emcalRPoTowerFolder = emcalFolder->AddFolder("TowerRecPoints", "Tower RecPoints from EMCAL") ;  
1766
1767   }    
1768
1769   
1770
1771   TObject * erp = emcalFolder->FindObject( name ) ;
1772
1773   if ( !erp )   {
1774
1775     TObjArray * towerrp = new TObjArray(100) ;
1776
1777     towerrp->SetName(name) ;
1778
1779     emcalRPoTowerFolder->Add(towerrp) ;  
1780
1781   }
1782
1783
1784
1785   // Pre Shower RecPoints 
1786
1787   TFolder * emcalRPoPreShoFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("PreShowerRecPoints")) ;
1788
1789   if ( !emcalRPoPreShoFolder ) {
1790
1791     if (fDebug) {
1792
1793       cout << "WARNING: AliEMCALGetter::Post RPo -> Folder //" << fRecoFolder << "/EMCAL/PreShowerRecPoints/ not found!" << endl;
1794
1795       cout << "INFO:    AliEMCALGetter::Post Rpo -> Adding Folder //" << fRecoFolder << "/EMCAL/PreShowerRecPoints/" << endl;
1796
1797     }
1798
1799     emcalRPoPreShoFolder = emcalFolder->AddFolder("PreShowerRecPoints", "PreSho RecPoints from EMCAL") ;  
1800
1801   }    
1802
1803   
1804
1805   TObject * crp =  emcalRPoPreShoFolder->FindObject( name ) ;
1806
1807   if ( !crp )   {
1808
1809     TObjArray * preshorp = new TObjArray(100) ;
1810
1811     preshorp->SetName(name) ;
1812
1813     emcalRPoPreShoFolder->Add(preshorp) ;  
1814
1815   }
1816
1817   return kTRUE; 
1818
1819 }
1820
1821
1822
1823 //____________________________________________________________________________ 
1824
1825 TObject ** AliEMCALGetter::TowerRecPointsRef(const char * name) const 
1826
1827 { // -------------- RecPoints -------------------------------------------
1828
1829   
1830
1831   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TowerRecPoints/name
1832
1833    
1834
1835   if ( !fRecoFolder ) {
1836
1837     cerr << "ERROR: AliEMCALGetter::TowerRecPointsRef -> Folder //" << fRecoFolder << " not found!" << endl;
1838
1839     abort() ; 
1840
1841   }    
1842
1843
1844
1845   TFolder * towerFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TowerRecPoints")) ; 
1846
1847   if ( !towerFolder ) {
1848
1849     cerr << "ERROR: AliEMCALGetter::TowerRecPointsRef -> Folder //" << fRecoFolder << "/EMCAL/TowerRecPoints/ not found!" << endl;
1850
1851     abort() ;
1852
1853   }    
1854
1855
1856
1857
1858
1859   TObject * trp = towerFolder->FindObject(name ) ;
1860
1861   if ( !trp )   {
1862
1863     cerr << "ERROR: AliEMCALGetter::TowerRecPointsRef -> Object " << name << " not found!" << endl  ;
1864
1865     abort() ; 
1866
1867   }
1868
1869   return towerFolder->GetListOfFolders()->GetObjectRef(trp) ;
1870
1871
1872
1873
1874
1875
1876
1877 //____________________________________________________________________________ 
1878
1879 TObject ** AliEMCALGetter::PreShowerRecPointsRef(const char * name) const 
1880
1881 { // -------------- RecPoints -------------------------------------------
1882
1883   
1884
1885   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/PreShowerRecPoints/name
1886
1887    
1888
1889   if ( !fRecoFolder ) {
1890
1891     cerr << "ERROR: AliEMCALGetter::PreShowerRecPointsRef -> Folder //" << fRecoFolder << " not found!" << endl;
1892
1893     abort() ; 
1894
1895   }    
1896
1897
1898
1899   TFolder * preshoFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/PreShowerRecPoints")) ; 
1900
1901   if ( !preshoFolder ) {
1902
1903     cerr << "ERROR: AliEMCALGetter::PreShowerRecPointsRef -> Folder //" << fRecoFolder << "/EMCAL/PreShowerRecPoints/" << endl;
1904
1905     abort() ;
1906
1907   }    
1908
1909
1910
1911   TObject * prp = preshoFolder->FindObject(name ) ;
1912
1913   if ( !prp )   {
1914
1915     cerr << "ERROR: AliEMCALGetter::PreShowerRecPointsRef -> Object " << name << " not found! " << endl ; 
1916
1917     abort() ;
1918
1919   }
1920
1921   return preshoFolder->GetListOfFolders()->GetObjectRef(prp) ;
1922
1923
1924
1925
1926
1927
1928
1929 //____________________________________________________________________________ 
1930
1931 const Bool_t AliEMCALGetter::PostClusterizer(AliEMCALClusterizer * clu) const 
1932
1933 { // ------------------ AliEMCALClusterizer ------------------------
1934
1935   
1936
1937   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
1938
1939
1940
1941   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1942
1943
1944
1945   if ( !tasks ) {
1946
1947     cerr << "ERROR: AliEMCALGetter::Post Rer -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
1948
1949     return kFALSE ;
1950
1951   }        
1952
1953         
1954
1955   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
1956
1957   if ( !emcal )  {
1958
1959     if (fDebug) {
1960
1961       cout <<"WARNING: AliEMCALGetter::Post Rer -> //" << fTasksFolder << "/ReconstructionerEMCAL not found!" << endl; 
1962
1963       cout <<"INFO: AliEMCALGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/EMCAL" << endl; 
1964
1965     }
1966
1967     emcal = new TTask("EMCAL", "") ; 
1968
1969     tasks->Add(emcal) ; 
1970
1971   } 
1972
1973
1974
1975   AliEMCALClusterizerv1 * emcalcl = dynamic_cast<AliEMCALClusterizerv1*>(emcal->GetListOfTasks()->FindObject(clu->GetName())) ; 
1976
1977   if (emcalcl) { 
1978
1979     if (fDebug)
1980
1981       cout << "INFO: AliEMCALGetter::Post Rer -> Task " << clu->GetName() << " already exists" << endl ; 
1982
1983     emcalcl->Delete() ; 
1984
1985     emcal->GetListOfTasks()->Remove(emcalcl) ;
1986
1987   }
1988
1989   emcal->Add(clu) ;      
1990
1991   return kTRUE; 
1992
1993
1994
1995
1996
1997 //____________________________________________________________________________ 
1998
1999 TObject ** AliEMCALGetter::ClusterizerRef(const char * name) const 
2000
2001 { // ------------------ AliEMCALClusterizer ------------------------
2002
2003   
2004
2005   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2006
2007
2008
2009   if ( !tasks ) {
2010
2011     cerr << "ERROR: AliEMCALGetter::Post RerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2012
2013     abort() ;
2014
2015   }        
2016
2017         
2018
2019   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2020
2021   if ( !emcal )  {
2022
2023     cerr <<"WARNING: AliEMCALGetter::Post RerRef -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl; 
2024
2025     abort() ; 
2026
2027   }   
2028
2029
2030
2031   TList * l = emcal->GetListOfTasks() ; 
2032
2033   TIter it(l) ;
2034
2035   TTask * task ;
2036
2037   TTask * clu = 0 ;
2038
2039   TString cluname(name) ;
2040
2041   cluname+=":clu-" ;
2042
2043   while((task = static_cast<TTask *>(it.Next()) )){
2044
2045     TString taskname(task->GetName()) ;
2046
2047     if(taskname.BeginsWith(cluname)){
2048
2049       clu = task ;
2050
2051       break ;
2052
2053     }
2054
2055   }
2056
2057
2058
2059   if(clu) 
2060
2061     return l->GetObjectRef(clu) ;
2062
2063   else {
2064
2065     cerr << "ERROR: AliEMCALGetter::Post RerRef -> task " << task->GetName() << " not found! " << endl ; 
2066
2067     abort() ;
2068
2069   }
2070
2071 }
2072
2073
2074
2075 //____________________________________________________________________________ 
2076
2077 const Bool_t AliEMCALGetter::PostClusterizer(const char * name) const 
2078
2079 { // ------------------ AliEMCALClusterizer ------------------------
2080
2081
2082
2083   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
2084
2085   
2086
2087   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2088
2089
2090
2091   if ( !tasks ) {
2092
2093     cerr << "ERROR: AliEMCALGetter::Post Rer -> Task//" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl; 
2094
2095     return kFALSE ;
2096
2097   }        
2098
2099   
2100
2101   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2102
2103   if ( !emcal )  {
2104
2105     if (fDebug) {
2106
2107       cout <<"WARNING: AliEMCALGetter::Post Rer -> //" << fTasksFolder << "/Reconstructioner/EMCAL not found!" << endl;
2108
2109       cout <<"INFO: AliEMCALGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/EMCAL" << endl;
2110
2111     }
2112
2113     emcal = new TTask("EMCAL", "") ; 
2114
2115     tasks->Add(emcal) ; 
2116
2117   } 
2118
2119
2120
2121   TList * l = emcal->GetListOfTasks() ;   
2122
2123   TIter it(l) ;
2124
2125   TString clun(name) ;
2126
2127   clun+=":clu" ; 
2128
2129   TTask * task ;
2130
2131   while((task = static_cast<TTask *>(it.Next()) )){
2132
2133     TString taskname(task->GetName()) ;
2134
2135     if(taskname.BeginsWith(clun))
2136
2137       return kTRUE ;
2138
2139   }
2140
2141
2142
2143   AliEMCALClusterizerv1 * emcalcl = new AliEMCALClusterizerv1() ;
2144
2145   clun+="-v1" ; 
2146
2147   emcalcl->SetName(clun) ;
2148
2149   emcalcl->SetTitle(fHeaderFile) ; 
2150
2151   emcal->Add(emcalcl) ;
2152
2153   return kTRUE; 
2154
2155   
2156
2157 }
2158
2159
2160
2161 //____________________________________________________________________________ 
2162
2163 /*const Bool_t AliEMCALGetter::PostTrackSegments(const char * name) const 
2164
2165 { // ---------------TrackSegments -----------------------------------
2166
2167   
2168
2169   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
2170
2171
2172
2173   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ; 
2174
2175   
2176
2177   if ( !emcalFolder ) {
2178
2179     if (fDebug) {
2180
2181       cout << "WARNING: AliEMCALGetter::Post TS -> Folder //" << fRecoFolder << "/EMCAL/ not found!" << endl;
2182
2183       cout << "INFO:    AliEMCALGetter::Post TS -> Adding Folder //" << fRecoFolder << "/EMCAL" << endl;
2184
2185     }
2186
2187     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;  
2188
2189   }    
2190
2191
2192
2193   TFolder * emcalTSFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("TrackSegments")) ;
2194
2195   if ( !emcalTSFolder ) {
2196
2197     if (fDebug) {
2198
2199       cout << "WARNING: AliEMCALGetter::Post TS -> Folder//" << fRecoFolder << "/EMCAL/TrackSegments/ not found!" << endl; 
2200
2201       cout << "INFO:    AliEMCALGetter::Post TS -> Adding Folder //" << fRecoFolder << "/EMCAL/TrackSegments/" << endl; 
2202
2203     }
2204
2205     emcalTSFolder = emcalFolder->AddFolder("TrackSegments", "TrackSegments from EMCAL") ;  
2206
2207   }    
2208
2209   
2210
2211   TObject * tss =  emcalTSFolder->FindObject( name ) ;
2212
2213   if (!tss) {
2214
2215     TClonesArray * ts = new TClonesArray("AliEMCALTrackSegment",100) ;
2216
2217     ts->SetName(name) ;
2218
2219     emcalTSFolder->Add(ts) ;  
2220
2221   }
2222
2223   return kTRUE; 
2224
2225
2226
2227
2228
2229 //____________________________________________________________________________ 
2230
2231 TObject ** AliEMCALGetter::TrackSegmentsRef(const char * name) const 
2232
2233 { // ---------------TrackSegments -----------------------------------
2234
2235   
2236
2237   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
2238
2239
2240
2241  if ( !fRecoFolder ) {
2242
2243     cerr << "ERROR: AliEMCALGetter::TrackSegmentsRef -> Folder //" << fRecoFolder << "not found!" << endl;
2244
2245     abort() ; 
2246
2247   }    
2248
2249
2250
2251   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/TrackSegments")) ; 
2252
2253   if ( !emcalFolder ) {
2254
2255     cerr << "ERROR: AliEMCALGetter::TrackSegmentsRef -> Folder //" << fRecoFolder << "/EMCAL/TrackSegments/ not found!" << endl;
2256
2257     abort();
2258
2259   }    
2260
2261   
2262
2263   TObject * tss =  emcalFolder->FindObject(name) ;
2264
2265   if (!tss) {
2266
2267     cerr << "ERROR: AliEMCALGetter::TrackSegmentsRef -> object " << name << " not found! " << endl ;  
2268
2269     abort() ;  
2270
2271   }
2272
2273   return emcalFolder->GetListOfFolders()->GetObjectRef(tss) ;
2274
2275
2276
2277
2278
2279 //____________________________________________________________________________ 
2280
2281 const Bool_t AliEMCALGetter::PostTrackSegmentMaker(AliEMCALTrackSegmentMaker * tsmaker) const 
2282
2283 { //------------Track Segment Maker ------------------------------
2284
2285   
2286
2287   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
2288
2289
2290
2291   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2292
2293
2294
2295   if ( !tasks ) {
2296
2297     cerr << "ERROR: AliEMCALGetter::Post Ter -> Task //" << fTasksFolder << "/Reconstructioner not found!" << endl;
2298
2299     return kFALSE ;
2300
2301   }        
2302
2303         
2304
2305   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2306
2307   if ( !emcal )  {
2308
2309     if (fDebug) {
2310
2311       cout <<"WARNING: AliEMCALGetter::Post Rer -> //" << fTasksFolder << "/Reconstructioner/EMCAL not found!" << endl; 
2312
2313       cout <<"INFO: AliEMCALGetter::Post Rer -> Adding //" << fTasksFolder << "/Reconstructioner/EMCAL" << endl;
2314
2315     }
2316
2317     emcal = new TTask("EMCAL", "") ; 
2318
2319     tasks->Add(emcal) ; 
2320
2321   } 
2322
2323
2324
2325   AliEMCALTrackSegmentMaker * emcalts = 
2326
2327     dynamic_cast<AliEMCALTrackSegmentMaker*>(emcal->GetListOfTasks()->FindObject(tsmaker->GetName())) ; 
2328
2329   if (emcalts) { 
2330
2331     emcalts->Delete() ;
2332
2333     emcal->GetListOfTasks()->Remove(emcalts) ;
2334
2335   }
2336
2337   emcal->Add(tsmaker) ;      
2338
2339   return kTRUE; 
2340
2341   
2342
2343
2344
2345 //____________________________________________________________________________ 
2346
2347 const Bool_t AliEMCALGetter::PostTrackSegmentMaker(const char * name) const 
2348
2349 { //------------Track Segment Maker ------------------------------
2350
2351   
2352
2353   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
2354
2355
2356
2357   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2358
2359   
2360
2361   if ( !tasks ) {
2362
2363     cerr << "ERROR: AliEMCALGetter::Post Ter -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2364
2365     return kFALSE ;
2366
2367   }        
2368
2369   
2370
2371   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2372
2373   if ( !emcal )  {
2374
2375     if (fDebug) {
2376
2377       cout <<"WARNING: AliEMCALGetter::Post Ter -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
2378
2379       cout <<"INFO: AliEMCALGetter::Post Ter -> Adding //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl;
2380
2381     }
2382
2383     emcal = new TTask("EMCAL", "") ; 
2384
2385     tasks->Add(emcal) ; 
2386
2387   } 
2388
2389
2390
2391   TList * l = emcal->GetListOfTasks() ;   
2392
2393   TIter it(l) ;
2394
2395   TString tsn(name);
2396
2397   tsn+=":tsm" ; 
2398
2399   TTask * task ;
2400
2401   while((task = static_cast<TTask *>(it.Next()) )){
2402
2403     TString taskname(task->GetName()) ;
2404
2405     if(taskname.BeginsWith(tsn))
2406
2407       return kTRUE ;
2408
2409   }
2410
2411   
2412
2413   AliEMCALTrackSegmentMakerv1 * emcalts = new AliEMCALTrackSegmentMakerv1() ;
2414
2415   tsn+="-v1" ;
2416
2417   emcalts->SetName(tsn) ;
2418
2419   emcalts->SetTitle(fHeaderFile) ;
2420
2421   emcal->Add(emcalts) ;      
2422
2423   return kTRUE; 
2424
2425   
2426
2427
2428
2429   
2430
2431   
2432
2433
2434
2435
2436
2437 //____________________________________________________________________________ 
2438
2439 TObject ** AliEMCALGetter::TSMakerRef(const char * name) const 
2440
2441 { //------------Track Segment Maker ------------------------------
2442
2443   
2444
2445   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2446
2447
2448
2449   if ( !tasks ) {
2450
2451     cerr << "ERROR: AliEMCALGetter::TSLakerRef TerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2452
2453     abort() ;
2454
2455   }        
2456
2457         
2458
2459   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2460
2461   if ( !emcal )  {
2462
2463     cerr <<"WARNING: AliEMCALGetter::TSMakerRef TerRef -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
2464
2465     abort() ; 
2466
2467   }   
2468
2469
2470
2471   TList * l = emcal->GetListOfTasks() ; 
2472
2473   TIter it(l) ;
2474
2475   TTask * task ;
2476
2477   TTask * tsm = 0 ;
2478
2479   TString tsmname(name) ;
2480
2481   tsmname+=":tsm-" ;
2482
2483   while((task = static_cast<TTask *>(it.Next()) )){
2484
2485     TString taskname(task->GetName()) ;
2486
2487     if(taskname.BeginsWith(tsmname)){
2488
2489       tsm = task ;
2490
2491       break ;
2492
2493     }
2494
2495   }
2496
2497   
2498
2499   if(tsm) 
2500
2501     return l->GetObjectRef(tsm) ;
2502
2503   else {
2504
2505     cerr << "ERROR: AliEMCALGetter::TSLakerRef -> task " << task->GetName() << " not found! " << endl ; 
2506
2507     abort() ;
2508
2509   }
2510
2511
2512
2513
2514
2515 //____________________________________________________________________________ 
2516
2517 const Bool_t AliEMCALGetter::PostRecParticles(const char * name) const 
2518
2519 {  // -------------------- RecParticles ------------------------
2520
2521   
2522
2523   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
2524
2525
2526
2527   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL")) ; 
2528
2529   
2530
2531   if ( !emcalFolder ) {
2532
2533     if (fDebug) {
2534
2535       cout << "WARNING: AliEMCALGetter::Post RPa -> Folder //" << fRecoFolder << "/EMCAL/ not found!" << endl;
2536
2537       cout << "INFO:    AliEMCALGetter::Post Rpa -> Adding Folder //" << fRecoFolder << "/EMCAL/" << endl;
2538
2539     }
2540
2541     emcalFolder = fRecoFolder->AddFolder("EMCAL", "Reconstructed data from EMCAL") ;  
2542
2543   }    
2544
2545
2546
2547  TFolder * emcalRPaFolder  = dynamic_cast<TFolder*>(emcalFolder->FindObject("RecParticles")) ;
2548
2549   if ( !emcalRPaFolder ) {
2550
2551     if (fDebug) {
2552
2553       cout << "WARNING: AliEMCALGetter::Post RPa -> Folder //" << fRecoFolder << "/EMCAL/RecParticles/ not found!" << endl;
2554
2555       cout << "INFO:    AliEMCALGetter::Post RPa -> Adding Folder //" << fRecoFolder << "/EMCAL/RecParticles/" << endl;
2556
2557     }
2558
2559     emcalRPaFolder = emcalFolder->AddFolder("RecParticles", "RecParticles from EMCAL") ;  
2560
2561   } 
2562
2563
2564
2565   TObject * rps = emcalRPaFolder->FindObject( name )  ;
2566
2567   if ( !rps ) {
2568
2569     TClonesArray * rp = new TClonesArray("AliEMCALRecParticle",100) ;
2570
2571     rp->SetName(name) ;    
2572
2573     emcalRPaFolder->Add(rp) ;  
2574
2575   }
2576
2577   return kTRUE; 
2578
2579
2580
2581
2582
2583 //____________________________________________________________________________ 
2584
2585 TObject ** AliEMCALGetter::RecParticlesRef(const char * name) const 
2586
2587 { // ---------------RecParticles -----------------------------------
2588
2589   
2590
2591   // the hierarchy is //Folders/Run/Event/RecData/EMCAL/TrackSegments/name
2592
2593
2594
2595  if ( !fRecoFolder ) {
2596
2597     cerr << "ERROR: AliEMCALGetter::RecParticlesRef -> Folder//" << fRecoFolder << " not found!" << endl; 
2598
2599     abort() ; 
2600
2601   }    
2602
2603
2604
2605   TFolder * emcalFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("EMCAL/RecParticles")) ; 
2606
2607   if ( !emcalFolder ) {
2608
2609     cerr << "ERROR: AliEMCALGetter::RecParticlesRef -> Folder //" << fRecoFolder << "/EMCAL/RecParticles/ not found!" << endl;
2610
2611     abort() ;
2612
2613   }    
2614
2615
2616
2617   TObject * tss =  emcalFolder->FindObject(name) ;
2618
2619   if (!tss) {
2620
2621     cerr << "ERROR: AliEMCALGetter::RecParticlesRef -> object " << name << " not found! " << endl ; 
2622
2623     abort() ;  
2624
2625   }
2626
2627   return emcalFolder->GetListOfFolders()->GetObjectRef(tss) ;
2628
2629 }
2630
2631
2632
2633 //____________________________________________________________________________ 
2634
2635 const Bool_t AliEMCALGetter::PostPID(AliEMCALPID * pid) const 
2636
2637 {      // ------------AliEMCAL PID -----------------------------
2638
2639
2640
2641   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2642
2643
2644
2645   if ( !tasks ) {
2646
2647     cerr << "ERROR: AliEMCALGetter::Post Per -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2648
2649     return kFALSE ;
2650
2651   }        
2652
2653   
2654
2655   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2656
2657   if ( !emcal )  {
2658
2659     if (fDebug) {
2660
2661       cout <<"WARNING: AliEMCALGetter::Post Per -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
2662
2663       cout <<"INFO: AliEMCALGetter::Post Per -> Adding //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl;
2664
2665     }
2666
2667     emcal = new TTask("EMCAL", "") ; 
2668
2669     tasks->Add(emcal) ; 
2670
2671   } 
2672
2673
2674
2675   AliEMCALPID * emcalpid = dynamic_cast<AliEMCALPID*>(emcal->GetListOfTasks()->FindObject(pid->GetName())) ; 
2676
2677   if (emcalpid) { 
2678
2679     if (fDebug)
2680
2681       cout << "INFO: AliEMCALGetter::Post Per -> Task " << pid->GetName()
2682
2683            << " already exists" << endl ; 
2684
2685     emcal->GetListOfTasks()->Remove(emcalpid) ;
2686
2687   }
2688
2689   
2690
2691   emcal->Add(pid) ;      
2692
2693   return kTRUE; 
2694
2695
2696
2697
2698
2699 //____________________________________________________________________________ 
2700
2701 const Bool_t AliEMCALGetter::PostPID(const char * name) const 
2702
2703 {     
2704
2705   // the hierarchy is //Folders/Tasks/Reconstructioner/EMCAL/sdigitsname
2706
2707   
2708
2709   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2710
2711
2712
2713   if ( !tasks ) {
2714
2715     cerr << "ERROR: AliEMCALGetter::Post Per -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2716
2717     return kFALSE ;
2718
2719   }        
2720
2721   
2722
2723   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2724
2725   if ( !emcal )  {
2726
2727     if (fDebug) {
2728
2729       cout <<"WARNING: AliEMCALGetter::Post Per -> //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL not found!" << endl; 
2730
2731       cout <<"INFO: AliEMCALGetter::Post Per -> Adding //" << fTasksFolder->GetName() << "/Reconstructioner/EMCAL" << endl;
2732
2733     }
2734
2735     emcal = new TTask("EMCAL", "") ; 
2736
2737     tasks->Add(emcal) ; 
2738
2739   } 
2740
2741
2742
2743   TList * l = emcal->GetListOfTasks() ;   
2744
2745   TIter it(l) ;
2746
2747   TString pidname(name) ;
2748
2749   pidname+=":pid" ; 
2750
2751   TTask * task ;
2752
2753   while((task = static_cast<TTask *>(it.Next()) )){
2754
2755     TString taskname(task->GetName()) ;
2756
2757     if(taskname.BeginsWith(pidname))
2758
2759       return kTRUE ;
2760
2761   }
2762
2763  
2764
2765   AliEMCALPIDv1 * emcalpid = new AliEMCALPIDv1() ;
2766
2767   pidname+="-v1" ;
2768
2769   emcalpid->SetName(pidname) ;
2770
2771   emcalpid->SetTitle(fHeaderFile) ;
2772
2773   emcal->Add(emcalpid) ;      
2774
2775   
2776
2777   return kTRUE; 
2778
2779
2780
2781
2782
2783 //____________________________________________________________________________ 
2784
2785 TObject ** AliEMCALGetter::PIDRef(const char * name) const 
2786
2787 { //------------PID ------------------------------
2788
2789
2790
2791   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
2792
2793
2794
2795   if ( !tasks ) {
2796
2797     cerr << "ERROR: AliEMCALGetter::PIDRef PerRef -> Task //" << fTasksFolder->GetName() << "/Reconstructioner not found!" << endl;
2798
2799     abort() ;
2800
2801   }        
2802
2803         
2804
2805   TTask * emcal = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("EMCAL")) ; 
2806
2807   if ( !emcal )  {
2808
2809     cerr <<"WARNING: AliEMCALGetter::PIDRef PerRef -> //" << fTasksFolder->GetName() << "/ReconstructionerEMCAL not found!" << endl; 
2810
2811     abort() ; 
2812
2813   }   
2814
2815   
2816
2817   TList * l = emcal->GetListOfTasks() ; 
2818
2819   TIter it(l) ;
2820
2821   TTask * task ;
2822
2823   TTask * pid = 0 ;
2824
2825   TString pidname(name) ;
2826
2827   pidname+=":pid-" ;
2828
2829   while((task = static_cast<TTask *>(it.Next()) )){
2830
2831     TString taskname(task->GetName()) ;
2832
2833     if(taskname.BeginsWith(pidname)){
2834
2835       pid = task ;
2836
2837       break ;
2838
2839     }
2840
2841   }
2842
2843   
2844
2845   if(pid) 
2846
2847     return l->GetObjectRef(pid) ;
2848
2849   else {
2850
2851     cerr << "ERROR: AliEMCALGetter::PIDRef -> task " << task->GetName() << " not found! " << endl ;  
2852
2853     abort() ;
2854
2855   }
2856
2857
2858
2859
2860
2861
2862
2863 //____________________________________________________________________________ 
2864
2865 const Bool_t AliEMCALGetter::PostQA(void) const 
2866
2867 { // ------------------ QA ---------------------------------
2868
2869
2870
2871   // the hierarchy is //Folders/Run/Conditions/QA/EMCAL/alarmsName
2872
2873
2874
2875   TFolder * emcalFolder = dynamic_cast<TFolder*>(fQAFolder->FindObject("EMCAL")) ; 
2876
2877   if ( !emcalFolder ) {
2878
2879     if (fDebug) {
2880
2881       cout << "WARNING: AliEMCALGetter::Post Q -> Folder //" << fQAFolder << "/EMCAL/ not found!" << endl;
2882
2883       cout << "INFO:    AliEMCALGetter::Post Q -> Adding Folder //" << fQAFolder << "/EMCAL/" << endl;
2884
2885     }
2886
2887     emcalFolder = fQAFolder->AddFolder("EMCAL", "QA from EMCAL") ; 
2888
2889   }      
2890
2891
2892
2893   return kTRUE;
2894
2895 }
2896
2897
2898
2899 //____________________________________________________________________________ 
2900
2901 TObject ** AliEMCALGetter::AlarmsRef(void) const 
2902
2903 {  //------- Alarms ----------------------
2904
2905
2906
2907   
2908
2909   // the hierarchy is //Folders/Run/Conditions/QA/EMCAL
2910
2911   if ( !fQAFolder ) {
2912
2913     cerr << "ERROR: AliEMCALGetter::AlarmsRef QRef -> Folder //" << fQAFolder << " not found!" << endl;
2914
2915     abort() ;
2916
2917   }    
2918
2919  
2920
2921   TFolder * emcalFolder = dynamic_cast<TFolder *>(fQAFolder->FindObject("EMCAL")) ;
2922
2923   if ( !emcalFolder ) {
2924
2925     cerr << "ERROR: AliEMCALGetter::AlarmsRef QRef -> Folder //" << fQAFolder << "/EMCAL/ not found!" << endl;
2926
2927     abort() ;
2928
2929   }
2930
2931    
2932
2933   return fQAFolder->GetListOfFolders()->GetObjectRef(emcalFolder) ;
2934
2935 }
2936
2937 */
2938
2939
2940
2941 //____________________________________________________________________________ 
2942
2943 TTree * AliEMCALGetter::TreeK(TString filename)  
2944
2945 {
2946
2947
2948
2949   // returns TreeK from file filename
2950
2951   // usefull in case of split file
2952
2953
2954
2955   if ( filename.IsNull() ) 
2956
2957     filename = fHeaderFile ; 
2958
2959
2960
2961   TFile * file = 0 ; 
2962
2963   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
2964
2965   if (!file)  {  // file not yet open 
2966
2967     file = TFile::Open(filename.Data(), "read") ; 
2968
2969   }    
2970
2971
2972   TString treeName("TreeK") ; 
2973
2974   treeName += EventNumber()  ; 
2975
2976   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
2977
2978   if (!tree && fDebug)  
2979
2980     cout << "WARNING: AliEMCALGetter::TreeK -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
2981
2982   
2983
2984   return tree ;                       
2985
2986 }
2987
2988
2989
2990 //____________________________________________________________________________ 
2991
2992 TTree * AliEMCALGetter::TreeH(TString filename)  
2993
2994 {
2995
2996
2997
2998   // returns TreeH from file filename
2999
3000   // usefull in case of split file
3001
3002
3003
3004   if ( filename.IsNull() ) 
3005
3006     filename = fHeaderFile ; 
3007
3008
3009
3010   TFile * file = 0 ; 
3011
3012   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
3013
3014   if (!file) { // file not open yet
3015
3016     file = TFile::Open(filename.Data(), "read") ; 
3017
3018   }
3019
3020   TString treeName("TreeH") ; 
3021
3022   treeName += EventNumber()  ; 
3023
3024   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
3025
3026   if (!tree && fDebug)  
3027
3028     cout << "WARNING: AliEMCALGetter::TreeH -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
3029
3030   
3031
3032   return tree ;                       
3033
3034 }
3035
3036
3037
3038 //____________________________________________________________________________ 
3039
3040 TTree * AliEMCALGetter::TreeS(TString filename)  
3041
3042 {
3043
3044
3045
3046   // returns TreeS from file filename
3047
3048   // usefull in case of split file
3049
3050
3051
3052   if ( filename.IsNull() ) 
3053
3054     filename = fHeaderFile ; 
3055
3056
3057
3058   TFile * file = 0 ; 
3059
3060   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
3061
3062   if (!file) { // file not open yet
3063
3064     file = TFile::Open(filename.Data(), "read") ; 
3065
3066   }
3067
3068   TString treeName("TreeS") ; 
3069
3070   treeName += EventNumber()  ; 
3071
3072   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
3073
3074   if (!tree && fDebug)  
3075
3076     cout << "WARNING: AliEMCALGetter::TreeS -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
3077
3078   
3079
3080   return tree ;                       
3081
3082 }
3083
3084
3085
3086 //____________________________________________________________________________ 
3087
3088 TTree * AliEMCALGetter::TreeD(TString filename)  
3089
3090 {
3091
3092
3093
3094   // returns TreeD from file filename
3095
3096   // usefull in case of split file
3097
3098
3099
3100   if ( filename.IsNull() ) 
3101
3102     filename = fHeaderFile ; 
3103
3104
3105
3106   TFile * file = 0 ; 
3107
3108   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
3109
3110   if (!file) { // file not open yet
3111
3112     file = TFile::Open(filename.Data(), "read") ; 
3113
3114   }
3115
3116   TString treeName("TreeD") ; 
3117
3118   treeName += EventNumber()  ; 
3119
3120   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
3121
3122   if (!tree && fDebug)  
3123
3124     cout << "WARNING: AliEMCALGetter::TreeD -> " << treeName.Data() << " not found in " << filename.Data() << endl ; 
3125
3126   
3127
3128   return tree ;                       
3129
3130 }
3131
3132
3133
3134 //____________________________________________________________________________ 
3135
3136 const TParticle * AliEMCALGetter::Primary(Int_t index) const
3137
3138 {
3139
3140   // Return primary particle numbered by <index>
3141
3142   
3143
3144   if(index < 0) 
3145
3146     return 0 ;
3147
3148   TParticle *  p = 0 ;
3149
3150   p = gAlice->Particle(index) ; 
3151   
3152
3153   return p ; 
3154
3155       
3156
3157 }
3158
3159
3160
3161 //____________________________________________________________________________ 
3162
3163 const TParticle * AliEMCALGetter::Secondary(TParticle* p, Int_t index) const
3164
3165 {
3166
3167   // Return first (index=1) or second (index=2) secondary particle of primary particle p 
3168
3169
3170
3171   if(index <= 0) 
3172
3173     return 0 ;
3174
3175   if(index > 2)
3176
3177     return 0 ;
3178
3179
3180
3181   if(p) {
3182
3183   Int_t daughterIndex = p->GetDaughter(index-1) ; 
3184
3185   return  gAlice->Particle(daughterIndex) ; 
3186
3187   }
3188
3189   else
3190
3191     return 0 ;
3192
3193 }
3194
3195
3196
3197 //____________________________________________________________________________ 
3198
3199 Int_t AliEMCALGetter::ReadTreeD(const Int_t event)
3200
3201 {
3202
3203   // Read the digit tree gAlice->TreeD()  
3204
3205   
3206
3207   TTree * treeD ;
3208
3209   if(fToSplit){
3210
3211     TFile * file = static_cast<TFile*>(gROOT->GetFile(fDigitsFileName)); 
3212
3213     if(!file) 
3214
3215       file = TFile::Open(fDigitsFileName) ;      
3216
3217     // Get Digits Tree header from file
3218
3219     TString treeName("TreeD") ;
3220
3221     treeName += event ; 
3222
3223     treeD = dynamic_cast<TTree*>(file->Get(treeName.Data()));
3224
3225     if(!treeD){ // TreeD not found in header file
3226
3227       if (fDebug)
3228
3229         cout << "WARNING: AliEMCALGetter::ReadTreeD -> Cannot find TreeD in " << fDigitsFileName.Data() << endl;
3230
3231       return 1;
3232
3233     }
3234
3235   }
3236
3237   else
3238
3239     treeD = gAlice->TreeD() ;
3240
3241   
3242
3243   TObjArray * lob = static_cast<TObjArray*>(treeD->GetListOfBranches()) ;
3244
3245   TIter next(lob) ; 
3246
3247   TBranch * branch = 0 ; 
3248
3249   TBranch * digitsbranch = 0 ; 
3250
3251   TBranch * digitizerbranch = 0 ; 
3252
3253   Bool_t emcalfound = kFALSE, digitizerfound = kFALSE ; 
3254
3255   
3256
3257   while ( (branch = static_cast<TBranch*>(next())) && (!emcalfound || !digitizerfound) ) {
3258
3259     if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
3260
3261       digitsbranch = branch ; 
3262
3263       emcalfound = kTRUE ;
3264
3265     }
3266
3267     else if ( (strcmp(branch->GetName(), "AliEMCALDigitizer")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
3268
3269       digitizerbranch = branch ; 
3270
3271       digitizerfound = kTRUE ; 
3272
3273     }
3274
3275   }
3276
3277
3278
3279   if ( !emcalfound || !digitizerfound ) {
3280
3281     if (fDebug)
3282
3283       cout << "WARNING: AliEMCALGetter::ReadTreeD -> Cannot find Digits and/or Digitizer with name " 
3284
3285            << fDigitsTitle << endl ;
3286
3287     return 2; 
3288
3289   }   
3290
3291  
3292
3293   //read digits
3294
3295   if(!Digits(fDigitsTitle) ) 
3296
3297     PostDigits(fDigitsTitle);
3298
3299   digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ;
3300
3301   digitsbranch->GetEntry(0) ;
3302
3303   
3304
3305   
3306
3307   // read  the Digitizer
3308
3309   RemoveTask("D", fDigitsTitle) ; // I do not understand why I need that 
3310
3311   if(!Digitizer(fDigitsTitle))
3312
3313     PostDigitizer(fDigitsTitle) ;
3314
3315   digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ;
3316
3317   digitizerbranch->GetEntry(0) ;
3318
3319  
3320
3321   lob  ->Delete();
3322
3323   if(gAlice->TreeD()!=treeD)
3324
3325     treeD->Delete();
3326
3327   return 0 ; 
3328
3329 }
3330
3331
3332
3333 //____________________________________________________________________________ 
3334
3335 Int_t AliEMCALGetter::ReadTreeH()
3336
3337 {
3338
3339   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
3340
3341
3342
3343   TTree * treeH = gAlice->TreeH() ;
3344
3345   
3346
3347   if(!treeH) {// TreeH not found in header file
3348
3349     
3350
3351     if (fDebug) 
3352
3353       cout <<   "WARNING: AliEMCALGetter::ReadTreeH -> Cannot find TreeH in " << fHeaderFile << endl ;
3354
3355     
3356
3357     TString searchFileName("EMCAL.HITS") ; 
3358
3359     if((strcmp(fBranchTitle.Data(),"Default")!=0)&&(strcmp(fBranchTitle.Data(),"")!=0)){
3360
3361       searchFileName+="." ;
3362
3363       searchFileName += fBranchTitle ;
3364
3365     }
3366
3367     searchFileName+=".root" ;
3368
3369     
3370
3371     if ( (treeH = TreeH(searchFileName)) ) { //found TreeH in the file which contains the hits
3372
3373       if (fDebug) 
3374
3375         cout << "INFO: AliEMCALGetter::ReadTreeH -> TreeH found in " << searchFileName.Data() << endl ; 
3376
3377       
3378
3379     } else {
3380
3381       cerr << "ERROR: AliEMCALGetter::ReadTreeH -> TreeH not found " << endl ; 
3382
3383       return 1;
3384
3385     }  
3386
3387   }
3388
3389   
3390
3391   TBranch * hitsbranch = static_cast<TBranch*>(gAlice->TreeH()->GetBranch("EMCAL")) ;
3392
3393   if ( !hitsbranch ) {
3394
3395     if (fDebug)
3396
3397       cout << "WARNING:  AliEMCALGetter::ReadTreeH -> Cannot find branch EMCAL" << endl ; 
3398
3399     return 2;
3400
3401   }
3402
3403   if(!Hits())
3404
3405     PostHits() ;
3406
3407  
3408
3409   if (hitsbranch->GetEntries() > 1 ) {
3410
3411     (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
3412
3413     TClonesArray * tempo =  new TClonesArray("AliEMCALHit",1000) ;
3414
3415     TClonesArray * hits = dynamic_cast<TClonesArray*>(*HitsRef()) ; 
3416
3417     hitsbranch->SetAddress(&tempo) ;
3418
3419     Int_t index = 0 ; 
3420
3421     Int_t i = 0 ;
3422
3423     for (i = 0 ; i < hitsbranch->GetEntries() ; i++) {
3424
3425       hitsbranch->GetEntry(i) ;
3426
3427       Int_t j = 0 ; 
3428
3429       for ( j = 0 ; j < tempo->GetEntries() ; j++) { 
3430
3431         const AliEMCALHit * hit = static_cast<const AliEMCALHit *>(tempo->At(j)) ; 
3432
3433         new((*hits)[index]) AliEMCALHit( *hit ) ;
3434
3435         index++ ; 
3436
3437       }
3438
3439     }
3440
3441     delete tempo ; 
3442
3443   }
3444
3445   else {
3446
3447   (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
3448
3449   hitsbranch->SetAddress(HitsRef()) ;
3450
3451   hitsbranch->GetEntry(0) ;
3452
3453   }
3454
3455   return 0 ; 
3456
3457 }
3458
3459
3460
3461 //____________________________________________________________________________ 
3462
3463 void AliEMCALGetter::Track(const Int_t itrack)
3464
3465 {
3466
3467   // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
3468
3469
3470
3471   if(gAlice->TreeH()== 0){
3472
3473     cerr <<   "ERROR: AliEMCALGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
3474
3475     return ;
3476
3477   }
3478
3479   
3480
3481   TBranch * hitsbranch = dynamic_cast<TBranch*>(gAlice->TreeH()->GetListOfBranches()->FindObject("EMCAL")) ;
3482
3483   if ( !hitsbranch ) {
3484
3485     if (fDebug)
3486
3487       cout << "WARNING:  AliEMCALGetter::ReadTreeH -> Cannot find branch EMCAL" << endl ; 
3488
3489     return ;
3490
3491   }  
3492
3493   if(!Hits())
3494
3495     PostHits() ;
3496
3497
3498
3499   (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
3500
3501   hitsbranch->SetAddress(HitsRef()) ;
3502
3503   hitsbranch->GetEntry(itrack) ;
3504
3505   
3506
3507 }
3508
3509
3510
3511 //____________________________________________________________________________ 
3512
3513 void AliEMCALGetter::ReadTreeQA()
3514
3515 {
3516
3517   if (fDebug)
3518
3519     cout << "WARNING : " << ClassName() << "::ReadTreeQA -> not implemented" << endl ; 
3520
3521   // Read the digit tree gAlice->TreeQA()
3522
3523   // so far only EMCAL knows about this Tree  
3524
3525
3526
3527 //   if(EMCAL()->TreeQA()== 0){
3528
3529 //     cerr <<   "ERROR: AliEMCALGetter::ReadTreeQA: can not read TreeQA " << endl ;
3530
3531 //     return ;
3532
3533 //   }
3534
3535   
3536
3537 //   TBranch * qabranch = EMCAL()->TreeQA()->GetBranch("EMCAL") ; 
3538
3539 //   if (!qabranch) { 
3540
3541 //     if (fDebug)
3542
3543 //       cout << "WARNING: AliEMCALGetter::ReadTreeQA -> Cannot find QA Alarms for EMCAL" << endl ;
3544
3545 //     return ; 
3546
3547 //   }   
3548
3549   
3550
3551 //   if(!Alarms())
3552
3553 //     PostQA() ; 
3554
3555
3556
3557 //   qabranch->SetAddress(AlarmsRef()) ;
3558
3559
3560
3561 //   qabranch->GetEntry(0) ;
3562
3563  
3564
3565 //   PostQA("EMCAL") ; 
3566
3567 //   TFolder * alarmsF = Alarms() ; 
3568
3569 //   alarmsF->Clear() ; 
3570
3571 //   qabranch->SetAddress(&alarmsF) ;
3572
3573 //   qabranch->GetEntry(0) ;
3574
3575   
3576
3577 }
3578
3579   
3580
3581 //____________________________________________________________________________ 
3582
3583 Int_t AliEMCALGetter::ReadTreeR(const Int_t event)
3584
3585 {
3586
3587   // Read the reconstrunction tree gAlice->TreeR()
3588
3589   // A particularity has been introduced here :
3590
3591   //  if gime->Event(ievent,"R") is called branches with the current title are read, the current title
3592
3593   //   being for example give in AliPHOSPID(fileName, title)
3594
3595   //  if gime(Event(ievent, "RA") is called the title of the branches is not checked anymore, "A" stands for any
3596
3597   // This is a feature needed by PID to be able to reconstruct several times particles (each time a ther title is given)
3598
3599   // from a given set of TrackSegments (with a given name)
3600
3601   // This is why any is NOT used to read the branch of RecParticles
3602
3603   // any migh have become obsolete : to be checked
3604
3605   // See AliEMCALPIDv1    
3606
3607
3608
3609  TTree * treeR ;
3610
3611   if(fToSplit){
3612
3613     TFile * file = static_cast<TFile*>(gROOT->GetFile(fRecPointsFileName)); 
3614
3615     if(!file) 
3616
3617       file = TFile::Open(fRecPointsFileName) ;      
3618
3619     // Get Digits Tree header from file
3620
3621     TString treeName("TreeR") ;
3622
3623     treeName += event ; 
3624
3625     treeR = dynamic_cast<TTree*>(file->Get(treeName.Data()));
3626
3627     if(!treeR){ // TreeR not found in header file
3628
3629       if (fDebug)
3630
3631         cout << "WARNING: AliEMCALGetter::ReadTreeD -> Cannot find TreeR in " << fRecPointsFileName.Data() << endl;
3632
3633       return 1;
3634
3635     }
3636
3637   }
3638
3639   else
3640
3641     treeR = gAlice->TreeR() ;
3642
3643   
3644
3645   // RecPoints 
3646
3647   TObjArray * lob = static_cast<TObjArray*>(treeR->GetListOfBranches()) ;
3648
3649   TIter next(lob) ; 
3650
3651   TBranch * branch = 0 ; 
3652
3653   TBranch * towerbranch = 0 ; 
3654
3655   TBranch * preshowerbranch = 0 ; 
3656
3657   TBranch * clusterizerbranch = 0 ; 
3658
3659   Bool_t emcalTowerRPfound = kFALSE, emcalPreShoRPfound = kFALSE, clusterizerfound = kFALSE ; 
3660
3661
3662
3663   
3664
3665   while ( (branch = static_cast<TBranch*>(next())) && (!emcalTowerRPfound || !emcalPreShoRPfound || !clusterizerfound) ) {
3666
3667     if(strcmp(branch->GetTitle(), fRecPointsTitle)==0 ) {
3668
3669       if ( strcmp(branch->GetName(), "EMCALTowerRP")==0) {
3670
3671         towerbranch = branch ; 
3672
3673         emcalTowerRPfound = kTRUE ;
3674
3675       }
3676
3677       else if ( strcmp(branch->GetName(), "EMCALPreShoRP")==0) {
3678
3679         preshowerbranch = branch ; 
3680
3681         emcalPreShoRPfound = kTRUE ;
3682
3683       }
3684
3685       else if(strcmp(branch->GetName(), "AliEMCALClusterizer")==0){
3686
3687         clusterizerbranch = branch ; 
3688
3689         clusterizerfound = kTRUE ; 
3690
3691       }
3692
3693     }
3694
3695   }
3696
3697
3698
3699   if ( !emcalTowerRPfound || !emcalPreShoRPfound || !clusterizerfound) {
3700
3701     if (fDebug)
3702
3703       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Cannot find RecPoints and/or Clusterizer with name " 
3704
3705            << fRecPointsTitle << endl ;
3706
3707  
3708
3709   } else { 
3710
3711     if(!TowerRecPoints(fRecPointsTitle) ) 
3712
3713       PostRecPoints(fRecPointsTitle) ;
3714
3715     
3716
3717     towerbranch->SetAddress(TowerRecPointsRef(fRecPointsTitle)) ;
3718
3719     towerbranch->GetEntry(0) ;
3720
3721
3722
3723     preshowerbranch->SetAddress(PreShowerRecPointsRef(fRecPointsTitle)) ; 
3724
3725     preshowerbranch->GetEntry(0) ;  
3726
3727     
3728
3729     if(!Clusterizer(fRecPointsTitle) )
3730
3731       PostClusterizer(fRecPointsTitle) ;
3732
3733     
3734
3735     clusterizerbranch->SetAddress(ClusterizerRef(fRecPointsTitle)) ;
3736
3737     clusterizerbranch->GetEntry(0) ;
3738
3739   }
3740
3741   
3742
3743 //   //------------------- TrackSegments ---------------------
3744
3745 //   next.Reset() ; 
3746
3747 //   TBranch * tsbranch = 0 ; 
3748
3749 //   TBranch * tsmakerbranch = 0 ; 
3750
3751 //   Bool_t emcaltsfound = kFALSE, tsmakerfound = kFALSE ; 
3752
3753 //   while ( (branch = static_cast<TBranch*>(next())) && (!emcaltsfound || !tsmakerfound) ) {
3754
3755 //     if(strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0 )  {
3756
3757 //       if ( strcmp(branch->GetName(), "EMCALTS")==0){
3758
3759 //      tsbranch = branch ; 
3760
3761 //      emcaltsfound = kTRUE ;
3762
3763 //       }
3764
3765 //       else if(strcmp(branch->GetName(), "AliEMCALTrackSegmentMaker")==0) {
3766
3767 //      tsmakerbranch = branch ; 
3768
3769 //      tsmakerfound  = kTRUE ; 
3770
3771 //       }
3772
3773 //     }
3774
3775 //   }
3776
3777
3778
3779 //   if ( !emcaltsfound || !tsmakerfound ) {
3780
3781 //     if (fDebug)
3782
3783 //       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Cannot find TrackSegments and/or TrackSegmentMaker with name "
3784
3785 //         << fTrackSegmentsTitle << endl ;
3786
3787 //   } else { 
3788
3789 //     // Read and Post the TrackSegments
3790
3791 //     if(!TrackSegments(fTrackSegmentsTitle))
3792
3793 //       PostTrackSegments(fTrackSegmentsTitle) ;
3794
3795 //     tsbranch->SetAddress(TrackSegmentsRef(fTrackSegmentsTitle)) ;
3796
3797 //     tsbranch->GetEntry(0) ;
3798
3799
3800
3801 //     // Read and Post the TrackSegment Maker
3802
3803 //     if(!TrackSegmentMaker(fTrackSegmentsTitle))
3804
3805 //       PostTrackSegmentMaker(fTrackSegmentsTitle) ;
3806
3807 //     tsmakerbranch->SetAddress(TSMakerRef(fTrackSegmentsTitle)) ;
3808
3809 //     tsmakerbranch->GetEntry(0) ;
3810
3811 //  }
3812
3813   
3814
3815   
3816
3817 //   //------------ RecParticles ----------------------------
3818
3819 //   next.Reset() ; 
3820
3821 //   TBranch * rpabranch = 0 ; 
3822
3823 //   TBranch * pidbranch = 0 ; 
3824
3825 //   Bool_t emcalrpafound = kFALSE, pidfound = kFALSE ; 
3826
3827   
3828
3829 //   while ( (branch = static_cast<TBranch*>(next())) && (!emcalrpafound || !pidfound) ) 
3830
3831 //     if(strcmp(branch->GetTitle(), fRecParticlesTitle)==0) {   
3832
3833 //       if ( strcmp(branch->GetName(), "EMCALRP")==0) {   
3834
3835 //      rpabranch = branch ; 
3836
3837 //      emcalrpafound = kTRUE ;
3838
3839 //       }
3840
3841 //       else if (strcmp(branch->GetName(), "AliEMCALPID")==0) {
3842
3843 //      pidbranch = branch ; 
3844
3845 //      pidfound  = kTRUE ; 
3846
3847 //       }
3848
3849 //     }
3850
3851   
3852
3853 //   if ( !emcalrpafound || !pidfound ) {
3854
3855 //     if (fDebug)
3856
3857 //       cout << "WARNING: AliEMCALGetter::ReadTreeR -> Cannot find RecParticles and/or PID with name " 
3858
3859 //         << fRecParticlesTitle << endl ; 
3860
3861 //   } else { 
3862
3863 //     // Read and Post the RecParticles
3864
3865 //     if(!RecParticles(fRecParticlesTitle)) 
3866
3867 //       PostRecParticles(fRecParticlesTitle) ;
3868
3869 //     rpabranch->SetAddress(RecParticlesRef(fRecParticlesTitle)) ;
3870
3871 //     rpabranch->GetEntry(0) ;
3872
3873 //     // Read and Post the PID
3874
3875 //     if(!PID(fRecParticlesTitle))
3876
3877 //       PostPID(fRecParticlesTitle) ;
3878
3879 //     pidbranch->SetAddress(PIDRef(fRecParticlesTitle)) ;
3880
3881 //     pidbranch->GetEntry(0) ;
3882
3883 //   }
3884
3885
3886
3887   if(gAlice->TreeR()!=treeR)
3888
3889     treeR->Delete();
3890
3891   return 0 ; 
3892
3893 }
3894
3895
3896
3897 //____________________________________________________________________________ 
3898
3899 Int_t AliEMCALGetter::ReadTreeS(Int_t event)
3900
3901 {
3902
3903   // Reads the SDigits treeS from all files  
3904
3905   // Files, which should be opened are listed in emcalF
3906
3907   // So, first get list of files
3908
3909   TFolder * emcalF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
3910
3911   if (!emcalF) 
3912
3913     emcalF = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; 
3914
3915   TCollection * folderslist = emcalF->GetListOfFolders() ; 
3916
3917   
3918
3919   // Now iterate over the list of files and read TreeS into Whiteboard
3920
3921   TIter next(folderslist) ; 
3922
3923   TFolder * folder = 0 ; 
3924
3925   TFile * file; 
3926
3927   TTree * treeS = 0;
3928
3929   while ( (folder = static_cast<TFolder*>(next())) ) {
3930
3931     TString fileName("") ;
3932
3933     if(fToSplit)
3934
3935       fileName = folder->GetTitle() ;
3936
3937     else
3938
3939       fileName = folder->GetName() ; 
3940
3941     fileName.ReplaceAll("_","/") ; 
3942
3943     file = static_cast<TFile*>(gROOT->GetFile(fileName)); 
3944
3945     if(!file) 
3946
3947       file = TFile::Open(fileName) ;      
3948
3949     // Get SDigits Tree header from file
3950
3951     TString treeName("TreeS") ;
3952
3953     treeName += event ; 
3954
3955     treeS = dynamic_cast<TTree*>(file->Get(treeName.Data()));
3956
3957
3958
3959     if(!treeS){ // TreeS not found in header file
3960
3961       if (fDebug)
3962
3963         cout << "WARNING: AliEMCALGetter::ReadTreeS -> Cannot find TreeS in " << fileName.Data() << endl;
3964
3965       return 1;
3966
3967     }
3968
3969     
3970
3971     //set address of the SDigits and SDigitizer
3972
3973     TBranch   * sdigitsBranch    = 0;
3974
3975     TBranch   * sdigitizerBranch = 0;
3976
3977     TBranch   * branch           = 0 ;