c4fdcae1a1cfd581ef28980e7005971e7430339e
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALLoader.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 //_________________________________________________________________________
19 //  A singleton. This class should be used in the analysis stage to get 
20 //  reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
21 //  instead of directly reading them from galice.root file. This container 
22 //  ensures, that one reads Digits, made of these particular digits, RecPoints, 
23 //  made of these particular RecPoints, TrackSegments and RecParticles. 
24 //  This becomes non trivial if there are several identical branches, produced with
25 //  different set of parameters. 
26 //
27 //  An example of how to use (see also class AliEMCALAnalyser):
28 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
29 //     AliEMCALRecParticle * part = gime->RecParticle(1) ;
30 //     ................
31 //  please->GetEvent(event) ;    // reads new event from galice.root
32 //                  
33 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
34 //*--         Completely redesigned by Dmitri Peressounko March 2001  
35 //
36 //*-- YS June 2001 : renamed the original AliEMCALIndexToObject and make
37 //*--         systematic usage of TFolders without changing the interface        
38 //////////////////////////////////////////////////////////////////////////////
39
40
41 // --- ROOT system ---
42
43 #include "TFile.h"
44 #include "TTree.h"
45 #include "TROOT.h"
46 #include "TObjString.h"
47 #include "TFolder.h"
48 #include "TParticle.h"
49
50 // --- Standard library ---
51 #include <Riostream.h>
52
53 // --- AliRoot header files ---
54
55 #include "AliRun.h"
56 #include "AliConfig.h"
57 #include "AliDataLoader.h"
58 #include "AliEMCALLoader.h"
59 #include "AliEMCAL.h"
60 #include "AliEMCALDigitizer.h"
61 #include "AliEMCALSDigitizer.h"
62 #include "AliEMCALClusterizer.h"
63 #include "AliEMCALClusterizerv1.h"
64 #include "AliEMCALTrackSegmentMaker.h"
65 #include "AliEMCALTrackSegmentMakerv1.h"
66 #include "AliEMCALTrackSegment.h"
67 #include "AliEMCALPID.h" 
68 #include "AliEMCALPIDv1.h" 
69 #include "AliEMCALGeometry.h"
70 //#include "AliEMCALCalibrationDB.h"
71
72 ClassImp(AliEMCALLoader)
73
74
75 const TString AliEMCALLoader::fgkHitsName("HITS");//Name for TClonesArray with hits from one event
76 const TString AliEMCALLoader::fgkSDigitsName("SDIGITS");//Name for TClonesArray 
77 const TString AliEMCALLoader::fgkDigitsName("DIGITS");//Name for TClonesArray 
78 const TString AliEMCALLoader::fgkPRERecPointsName("PRERECPOINTS");//Name for TClonesArray 
79 const TString AliEMCALLoader::fgkECARecPointsName("ECARECPOINTS");//Name for TClonesArray 
80 const TString AliEMCALLoader::fgkHCARecPointsName("HCARECPOINTS");//Name for TClonesArray 
81 const TString AliEMCALLoader::fgkTracksName("TRACKS");//Name for TClonesArray 
82 const TString AliEMCALLoader::fgkRecParticlesName("RECPARTICLES");//Name for TClonesArray
83
84 const TString AliEMCALLoader::fgkPRERecPointsBranchName("EMCALPRERP");//Name for branch with PreShower Reconstructed Points
85 const TString AliEMCALLoader::fgkECARecPointsBranchName("EMCALECARP");//Name for branch with ECA Reconstructed Points
86 const TString AliEMCALLoader::fgkHCARecPointsBranchName("EMCALHCARP");//Name for branch with HCA Reconstructed Points
87 const TString AliEMCALLoader::fgkTrackSegmentsBranchName("EMCALTS");//Name for branch with TrackSegments
88 const TString AliEMCALLoader::fgkRecParticlesBranchName("EMCALRP");//Name for branch with Reconstructed Particles
89 //____________________________________________________________________________ 
90 AliEMCALLoader::AliEMCALLoader()
91  {
92   fDebug = 0;
93   fRecParticlesLoaded = kFALSE;
94  }
95 //____________________________________________________________________________ 
96 AliEMCALLoader::AliEMCALLoader(const Char_t *detname,const Char_t *eventfoldername):
97       AliLoader(detname,eventfoldername)
98 {
99   fDebug=0;
100   fRecParticlesLoaded = kFALSE;
101 }
102 //____________________________________________________________________________ 
103
104 AliEMCALLoader::~AliEMCALLoader()
105 {
106   //remove and delete arrays
107   Clean(fgkHitsName);
108   Clean(fgkSDigitsName);
109   Clean(fgkDigitsName);
110   Clean(fgkPRERecPointsName);
111   Clean(fgkECARecPointsName);
112   Clean(fgkHCARecPointsName);
113   Clean(fgkTracksName);
114   Clean(fgkRecParticlesName);
115 }
116 //____________________________________________________________________________ 
117
118 void AliEMCALLoader::CleanFolders()
119  {
120    CleanRecParticles();
121    AliLoader::CleanFolders();
122  }
123 //____________________________________________________________________________ 
124
125 Int_t AliEMCALLoader::SetEvent()
126 {
127 //Cleans loaded stuff and and sets Files and Directories
128 // do not post any data to folder/tasks
129
130
131  Int_t retval = AliLoader::SetEvent();
132   if (retval)
133    {
134      Error("SetEvent","AliLoader::SetEvent returned error");
135      return retval;
136    }
137
138
139   if (Hits()) Hits()->Clear();
140   if (SDigits()) SDigits()->Clear();
141   if (Digits()) Digits()->Clear();
142   if (PRERecPoints()) PRERecPoints()->Clear();
143   if (ECARecPoints()) ECARecPoints()->Clear();
144   if (HCARecPoints()) HCARecPoints()->Clear();
145   if (TrackSegments()) TrackSegments()->Clear();
146   if (RecParticles()) RecParticles()->Clear();
147    
148   return 0;
149 }
150 //____________________________________________________________________________ 
151
152 Int_t AliEMCALLoader::GetEvent()
153 {
154 //Overloads GetEvent method called by AliRunLoader::GetEvent(Int_t) method
155 //to add Rec Particles specific for EMCAL
156
157 //First call the original method to get whatever from std. setup is needed
158   Int_t retval;
159   
160   retval = AliLoader::GetEvent();
161   if (retval)
162    {
163      Error("GetEvent","AliLoader::GetEvent returned error");
164      return retval;
165    }
166   
167   if (GetHitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadHits();
168   if (GetSDigitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadSDigits();
169   if (GetDigitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadDigits();
170   if (GetRecPointsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadRecPoints();
171   if (GetTracksDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadTracks();
172   if (GetRecParticlesDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadRecParticles();
173
174
175 //Now, check if RecPart were loaded  
176   return 0;
177 }
178 //____________________________________________________________________________ 
179
180
181 //____________________________________________________________________________ 
182 const AliEMCAL * AliEMCALLoader::EMCAL() 
183 {
184   // returns the EMCAL object 
185   AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(GetModulesFolder()->FindObject(fDetectorName));
186   if ( emcal == 0x0) 
187     if (fDebug)
188       cout << "WARNING: AliEMCALLoader::EMCAL -> EMCAL module not found in Folders" << endl ; 
189   return emcal ; 
190 }  
191
192 //____________________________________________________________________________ 
193 const AliEMCALGeometry * AliEMCALLoader::EMCALGeometry() 
194 {
195   AliEMCALGeometry * rv = 0 ; 
196   if (EMCAL() )
197     rv =  EMCAL()->GetGeometry();
198   return rv ; 
199
200
201
202 //____________________________________________________________________________ 
203 Int_t AliEMCALLoader::LoadHits(Option_t* opt)
204 {  
205 //------- Hits ----------------------
206 //Overload (extends) LoadHits implemented in AliLoader
207 //
208   Int_t res;
209   
210   //First call the AliLoader's method to send the TreeH to folder
211   res = AliLoader::LoadHits(opt);
212   
213   if (res)
214    {//oops, error
215      Error("LoadHits","AliLoader::LoadHits returned error");
216      return res;
217    }
218
219   //read the data from tree in folder and send it to folder
220   res = ReadHits();
221   return 0;
222 }
223
224
225 //____________________________________________________________________________ 
226 Int_t AliEMCALLoader::LoadSDigits(Option_t* opt)
227 {  //---------- SDigits -------------------------
228   Int_t res;
229   //First call the AliLoader's method to send the TreeS to folder
230   res = AliLoader::LoadSDigits(opt);
231   if (res)
232    {//oops, error
233      Error("PostSDigits","AliLoader::LoadSDigits returned error");
234      return res;
235    }
236   return ReadSDigits();
237    
238
239 //____________________________________________________________________________ 
240 Int_t AliEMCALLoader::LoadDigits(Option_t* opt)
241
242   Int_t res;
243   //First call the AliLoader's method to send the TreeS to folder
244   res = AliLoader::LoadDigits(opt);
245   if (res)
246    {//oops, error
247      Error("LoadDigits","AliLoader::LoadDigits returned error");
248      return res;
249    }
250   return ReadDigits();
251 }
252 //____________________________________________________________________________ 
253 Int_t AliEMCALLoader::LoadRecPoints(Option_t* opt) 
254 { // -------------- RecPoints -------------------------------------------
255   Int_t res;
256   //First call the AliLoader's method to send the TreeR to folder
257   res = AliLoader::LoadRecPoints(opt);
258   if (res)
259    {//oops, error
260      Error("LoadRecPoints","AliLoader::LoadRecPoints returned error");
261      return res;
262    }
263
264   TFolder * emcalFolder = GetDetectorDataFolder();
265   if ( emcalFolder  == 0x0 ) 
266    {
267      Error("LoadRecPoints","Can not get detector data folder");
268      return 1;
269    }
270   return ReadRecPoints();
271 }
272 //____________________________________________________________________________ 
273
274 Int_t  AliEMCALLoader::LoadTracks(Option_t* opt)
275 {
276  //Loads Tracks: Open File, Reads Tree and posts, Read Data and Posts
277  if (GetDebug()) Info("LoadTracks","opt = %s",opt);
278  if (fTracksLoaded)
279   {
280     Warning("LoadTracks","Tracks are already loaded");
281     return 0;
282   }
283  Int_t res;
284   //First call the AliLoader's method to send the TreeS to folder
285  if (GetTracksDataLoader()->GetBaseLoader(0)->IsLoaded() == kFALSE) 
286   {//tracks can be loaded by LoadRecPoints
287    res = AliLoader::LoadTracks(opt);
288    if (res)
289     {//oops, error
290       Error("LoadTracks","AliLoader::LoadTracks returned error");
291       return res;
292     }
293   }
294  res = ReadTracks();
295  if (res)
296   {
297     Error("LoadTracks","Error occured while reading Tracks");
298     return res;
299   }
300
301  fTracksLoaded = kTRUE;
302  return 0;
303 }
304
305 //____________________________________________________________________________ 
306 Int_t AliEMCALLoader::LoadRecParticles(Option_t* opt) 
307 { // -------------- RecPoints -------------------------------------------
308   Int_t res;
309   //First call the AliLoader's method to send the TreeS to folder
310   res = AliLoader::LoadRecParticles(opt);
311   if (res)
312    {//oops, error
313      Error("LoadRecParticles","AliLoader::LoadRecParticles returned error");
314      return res;
315    }
316
317   TFolder * emcalFolder = GetDetectorDataFolder();
318   if ( emcalFolder  == 0x0 ) 
319    {
320      Error("PostDigits","Can not get detector data folder");
321      return 1;
322    }
323   return ReadRecParticles();
324 }
325
326 //____________________________________________________________________________ 
327
328 Int_t AliEMCALLoader::PostHits()
329 {
330   Int_t reval = AliLoader::PostHits();
331   if (reval)
332    {
333      Error("PostHits","AliLoader::  returned error");
334      return reval;
335    }
336   return ReadHits();
337 }
338 //____________________________________________________________________________ 
339
340 Int_t AliEMCALLoader::PostSDigits()
341 {
342   Int_t reval = AliLoader::PostSDigits();
343   if (reval)
344    {
345      Error("PostSDigits","AliLoader::PostSDigits  returned error");
346      return reval;
347    }
348   return ReadSDigits();
349 }
350 //____________________________________________________________________________ 
351
352 Int_t AliEMCALLoader::PostDigits()
353 {
354   Int_t reval = AliLoader::PostDigits();
355   if (reval)
356    {
357      Error("PostDigits","AliLoader::PostDigits  returned error");
358      return reval;
359    }
360   return ReadDigits();
361 }
362 //____________________________________________________________________________ 
363
364 Int_t AliEMCALLoader::PostRecPoints()
365 {
366   Int_t reval = AliLoader::PostRecPoints();
367   if (reval)
368    {
369      Error("PostRecPoints","AliLoader::PostRecPoints  returned error");
370      return reval;
371    }
372   return ReadRecPoints();
373 }
374
375 //____________________________________________________________________________ 
376
377 Int_t AliEMCALLoader::PostRecParticles()
378 {
379   Int_t reval = AliLoader::PostRecParticles();
380   if (reval)
381    {
382      Error("PostRecParticles","AliLoader::PostRecParticles  returned error");
383      return reval;
384    }
385   return ReadRecParticles();
386 }
387 //____________________________________________________________________________ 
388
389 Int_t AliEMCALLoader::PostTracks()
390 {
391   Int_t reval = AliLoader::PostTracks();
392   if (reval)
393    {
394      Error("PostTracks","AliLoader::PostTracks  returned error");
395      return reval;
396    }
397   return ReadTracks();
398 }
399 //____________________________________________________________________________ 
400
401
402
403 //____________________________________________________________________________ 
404 Int_t AliEMCALLoader::ReadHits()
405 {
406 // If there is no Clones Array in folder creates it and sends to folder
407 // then tries to read
408 // Reads the first entry of EMCAL branch in hit tree TreeH()
409 // Reads data from TreeH and stores it in TClonesArray that sits in DetectorDataFolder
410 //
411   TObject** hitref = HitsRef();
412   if(hitref == 0x0)
413    {
414      MakeHitsArray();
415      hitref = HitsRef();
416    }
417
418   TClonesArray* hits = dynamic_cast<TClonesArray*>(*hitref);
419
420   TTree* treeh = TreeH();
421   
422   if(treeh == 0)
423    {
424     Error("ReadHits"," Cannot read TreeH from folder");
425     return 1;
426   }
427   
428   TBranch * hitsbranch = treeh->GetBranch(fDetectorName);
429   if (hitsbranch == 0) 
430    {
431     Error("ReadHits"," Cannot find branch EMCAL"); 
432     return 1;
433   }
434   
435   if (GetDebug()) Info("ReadHits","Reading Hits");
436   
437   if (hitsbranch->GetEntries() > 1)
438    {
439     TClonesArray * tempo =  new TClonesArray("AliEMCALHit",1000);
440
441     hitsbranch->SetAddress(&tempo);
442     Int_t index = 0 ; 
443     Int_t i = 0 ;
444     for (i = 0 ; i < hitsbranch->GetEntries(); i++) 
445      {
446       hitsbranch->GetEntry(i) ;
447       Int_t j = 0 ;
448       for ( j = 0 ; j < tempo->GetEntries() ; j++) 
449        {
450          AliEMCALHit* hit = (AliEMCALHit*)tempo->At(j); 
451          new((*hits)[index]) AliEMCALHit( *hit ) ;
452          index++ ; 
453        }
454      }
455     delete tempo;
456    }
457   else 
458    {
459     hitsbranch->SetAddress(hitref);
460     hitsbranch->GetEntry(0) ;
461    }
462
463   return 0;
464 }
465 //____________________________________________________________________________ 
466 Int_t AliEMCALLoader::ReadSDigits()
467 {
468 // Read the summable digits tree TreeS():
469 // Check if TClones is in folder
470 // if not create and add to folder
471 // connect to tree if available
472 // Read the data
473
474   TObject** sdref = SDigitsRef();
475   if(sdref == 0x0)
476    {
477      MakeSDigitsArray();
478      sdref = SDigitsRef();
479    }
480    
481   TTree * treeS = TreeS();
482   if(treeS==0)
483    {
484      //May happen if file is truncated or new in LoadSDigits
485      //Error("ReadSDigits","There is no SDigit Tree");
486      return 0;
487    }
488   
489   TBranch * branch = treeS->GetBranch(fDetectorName);
490   if (branch == 0) 
491    {//easy, maybe just a new tree
492     //Error("ReadSDigits"," Cannot find branch EMCAL"); 
493     return 0;
494   }
495     
496   branch->SetAddress(SDigitsRef());
497   branch->GetEntry(0);
498   return 0;
499 }
500
501 //____________________________________________________________________________ 
502 Int_t AliEMCALLoader::ReadDigits()
503 {
504 // Read the summable digits tree TreeS():
505 // Check if TClones is in folder
506 // if not create and add to folder
507 // connect to tree if available
508 // Read the data
509   
510   TObject** dref = DigitsRef();
511   if(dref == 0x0)
512    {//if there is not array in folder, create it and put it there
513      MakeDigitsArray();
514      dref = DigitsRef();
515    }
516
517   TTree * treeD = TreeD();
518   if(treeD==0)
519    {
520      //May happen if file is truncated or new in LoadSDigits
521      //Error("ReadDigits","There is no Digit Tree");
522      return 0;
523    }
524
525   TBranch * branch = treeD->GetBranch(fDetectorName);
526   if (branch == 0) 
527    {//easy, maybe just a new tree
528     //Error("ReadDigits"," Cannot find branch ",fDetectorName.Data()); 
529     return 0;
530    }
531   
532   branch->SetAddress(dref);//connect branch to buffer sitting in folder
533   branch->GetEntry(0);//get first event 
534
535   return 0;  
536 }
537 //____________________________________________________________________________ 
538
539 void AliEMCALLoader::UnloadRecParticles()
540 {
541   fRecParticlesLoaded = kFALSE;
542   CleanRecParticles();
543   if (fTracksLoaded == kFALSE) UnloadTracks();
544 }
545 //____________________________________________________________________________ 
546
547 void AliEMCALLoader::UnloadTracks()
548 {
549  CleanTracks();//free the memory
550  //in case RecPart are loaded we can not onload tree and close the file
551  if (fRecParticlesLoaded == kFALSE) AliLoader::UnloadTracks();
552  fTracksLoaded = kFALSE;//mark that nobody needs them
553 }
554 //____________________________________________________________________________ 
555
556 void AliEMCALLoader::Track(Int_t itrack)
557 {
558 // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
559   if(TreeH()== 0)
560    {
561      if (LoadHits())
562       {
563         Error("Track","Can not load hits.");
564         return;
565       } 
566    }
567   
568   TBranch * hitsbranch = dynamic_cast<TBranch*>(TreeH()->GetListOfBranches()->FindObject("EMCAL")) ;
569   if ( !hitsbranch ) {
570     if (fDebug)
571       cout << "WARNING:  AliEMCALLoader::ReadTreeH -> Cannot find branch EMCAL" << endl ; 
572     return ;
573   }  
574   if(!Hits()) PostHits();
575
576   hitsbranch->SetAddress(HitsRef());
577   hitsbranch->GetEntry(itrack);
578
579 }
580 //____________________________________________________________________________ 
581 void AliEMCALLoader::ReadTreeQA()
582 {
583   // Read the digit tree gAlice->TreeQA()
584   // so far only EMCAL knows about this Tree  
585
586   if(EMCAL()->TreeQA()== 0){
587     cerr <<   "ERROR: AliEMCALLoader::ReadTreeQA: can not read TreeQA " << endl ;
588     return ;
589   }
590   
591   TBranch * qabranch = EMCAL()->TreeQA()->GetBranch("EMCAL");
592   if (!qabranch) { 
593     if (fDebug)
594       cout << "WARNING: AliEMCALLoader::ReadTreeQA -> Cannot find QA Alarms for EMCAL" << endl ;
595     return ; 
596   }   
597   
598 //  if(!Alarms()) PostQA();
599
600   qabranch->SetAddress(AlarmsRef()) ;
601
602   qabranch->GetEntry(0) ;
603   
604 }
605
606
607 //____________________________________________________________________________ 
608 Int_t AliEMCALLoader::ReadRecPoints()
609 {
610 //Creates and posts to folder an array container, 
611 //connects branch in tree (if exists), and reads data to array
612   
613   MakeRecPointsArray();
614   
615   TObjArray * pre = 0x0 ; 
616   TObjArray * eca = 0x0 ; 
617   TObjArray * hca = 0x0 ; 
618
619   TTree * treeR = TreeR();
620  
621   if(treeR==0)
622    {
623      //May happen if file is truncated or new in LoadSDigits
624      return 0;
625    }
626
627   Int_t retval = 0;
628   TBranch * prebranch = treeR->GetBranch(fgkPRERecPointsBranchName);
629
630   if (prebranch == 0x0)
631    {
632      Error("ReadRecPoints","Can not get branch with PRE Rec. Points named %s",fgkPRERecPointsBranchName.Data());
633      retval = 1;
634    }
635   else
636    {
637      prebranch->SetAddress(&pre) ;
638      prebranch->GetEntry(0) ;
639    }
640   TBranch * ecabranch = treeR->GetBranch(fgkECARecPointsBranchName);
641   if (ecabranch == 0x0)
642    {
643      Error("ReadRecPoints","Can not get branch with ECA Rec. Points named %s",fgkECARecPointsBranchName.Data());
644      retval = 2;
645    }
646   else
647    {
648      ecabranch->SetAddress(&eca);
649      ecabranch->GetEntry(0) ;
650    }
651   TBranch * hcabranch = treeR->GetBranch(fgkHCARecPointsBranchName);
652   if (hcabranch == 0x0)
653    {
654      Error("ReadRecPoints","Can not get branch with HCA Rec. Points named %s",fgkHCARecPointsBranchName.Data());
655      retval = 2;
656    }
657   else
658    {
659      hcabranch->SetAddress(&hca);
660      hcabranch->GetEntry(0) ;
661    }
662
663   Int_t ii ; 
664   Int_t maxpre = pre->GetEntries() ; 
665   for ( ii= 0 ; ii < maxpre ; ii++ ) 
666     PRERecPoints()->Add(pre->At(ii)) ;
667  
668   Int_t maxeca = eca->GetEntries() ; 
669   for ( ii= 0 ; ii < maxeca ; ii++ ) 
670     ECARecPoints()->Add(eca->At(ii)) ;
671   
672   Int_t maxhca = hca->GetEntries() ; 
673   for ( ii= 0 ; ii < maxhca ; ii++ ) 
674     HCARecPoints()->Add(hca->At(ii)) ;
675  
676   return retval;
677 }
678
679 //____________________________________________________________________________ 
680 Int_t AliEMCALLoader::ReadTracks()
681 {
682 //Creates and posts to folder an array container, 
683 //connects branch in tree (if exists), and reads data to arry
684
685   TObject** trkref = TracksRef();
686   if ( trkref == 0x0 )   
687    {//Create and post array
688     MakeTrackSegmentsArray();
689     trkref = TracksRef();
690    }
691
692   TTree * treeT = TreeT();
693   if(treeT==0)
694    {
695      //May happen if file is truncated or new in LoadSDigits, or the file is in update mode, 
696      //but tracking was not performed yet for a current event
697      //Error("ReadTracks","There is no Tree with Tracks");
698      return 0;
699    }
700   
701   TBranch * branch = treeT->GetBranch(fgkTrackSegmentsBranchName);
702   if (branch == 0) 
703    {//easy, maybe just a new tree
704     Error("ReadTracks"," Cannot find branch named %s",fgkTrackSegmentsBranchName.Data());
705     return 0;
706   }
707
708   branch->SetAddress(trkref);//connect branch to buffer sitting in folder
709   branch->GetEntry(0);//get first event 
710   
711   return 0;
712 }
713 //____________________________________________________________________________ 
714
715 Int_t AliEMCALLoader::ReadRecParticles()
716 {
717 //Reads Reconstructed  Particles from file
718 //Creates and posts to folder an array container, 
719 //connects branch in tree (if exists), and reads data to arry
720   
721   TObject** recpartref = RecParticlesRef();
722   
723   if ( recpartref == 0x0 )   
724    {//Create and post array
725     MakeRecParticlesArray();
726     recpartref = RecParticlesRef();
727    }
728
729   TTree * treeP = TreeP();
730   if(treeP==0)
731    {
732      //May happen if file is truncated or new in LoadSDigits, 
733      //or the file is in update mode, 
734      //but tracking was not performed yet for a current event
735      //     Error("ReadRecParticles","There is no Tree with Tracks and Reconstructed Particles");
736      return 0;
737    }
738   
739   TBranch * branch = treeP->GetBranch(fgkRecParticlesBranchName);
740   if (branch == 0) 
741    {//easy, maybe just a new tree
742     Error("ReadRecParticles"," Cannot find branch %s",fgkRecParticlesBranchName.Data()); 
743     return 0;
744   }
745
746   branch->SetAddress(recpartref);//connect branch to buffer sitting in folder
747   branch->GetEntry(0);//get first event 
748   
749   return 0;
750 }
751
752
753 AliEMCALGeometry* AliEMCALLoader::GetEMCALGeometry()
754 {
755 //returns EMCAL geometry from gAlice 
756 //static Method used by some classes where it is not convienient to pass eventfoldername
757  if (gAlice == 0x0)
758   return 0x0;
759  AliEMCAL* emcal=dynamic_cast<AliEMCAL*>(gAlice->GetDetector("EMCAL"));
760  if (emcal == 0x0)
761   return 0x0;
762  return emcal->GetGeometry();
763 }
764 /***************************************************************************************/
765
766 AliEMCALLoader* AliEMCALLoader::GetEMCALLoader(const  char* eventfoldername)
767 {
768   AliRunLoader* rn  = AliRunLoader::GetRunLoader(eventfoldername);
769   if (rn == 0x0)
770    {
771      cerr<<"Error: <AliEMCALLoader::GetEMCALLoader>: "
772          << "Can not find Run Loader in folder "<<eventfoldername<<endl;
773      return 0x0;
774    }
775   return dynamic_cast<AliEMCALLoader*>(rn->GetLoader("EMCALLoader"));
776 }
777 /***************************************************************************************/
778
779 Bool_t AliEMCALLoader::BranchExists(const TString& recName)
780  {
781   if (fBranchTitle.IsNull()) return kFALSE;
782   TString dataname, zername ;
783   TTree* tree;
784   if(recName == "SDigits") {
785     tree = TreeS();
786     dataname = GetDetectorName();
787     zername = "AliEMCALSDigitizer" ;
788   }
789   else if(recName == "Digits"){
790     tree = TreeD();
791     dataname = GetDetectorName();
792     zername = "AliEMCALDigitizer" ;
793   }
794   else if(recName == "PRERecPoints"){
795     tree = TreeR();
796     dataname = fgkPRERecPointsBranchName;
797     zername = "AliEMCALClusterizer" ;
798   }
799   else if(recName == "ECARecPoints"){
800     tree = TreeR();
801     dataname = fgkECARecPointsBranchName;
802     zername = "AliEMCALClusterizer" ;
803   }
804   else if(recName == "HCARecPoints"){
805     tree = TreeR();
806     dataname = fgkHCARecPointsBranchName;
807     zername = "AliEMCALClusterizer" ;
808   }
809   else if(recName == "TrackSegments"){
810     tree = TreeT();
811     dataname = fgkTrackSegmentsBranchName;
812     zername = "AliEMCALTrackSegmentMaker";
813   }        
814   else if(recName == "RecParticles"){
815     tree = TreeP();
816     dataname = fgkRecParticlesBranchName;
817     zername = "AliEMCALPID";
818   }
819   else
820     return kFALSE ;
821
822   
823   if(!tree ) 
824     return kFALSE ;
825
826   TObjArray * lob = static_cast<TObjArray*>(tree->GetListOfBranches()) ;
827   TIter next(lob) ; 
828   TBranch * branch = 0 ;  
829   TString titleName(fBranchTitle);
830   titleName+=":";
831
832   while ((branch = (static_cast<TBranch*>(next())))) {
833     TString branchName(branch->GetName() ) ; 
834     TString branchTitle(branch->GetTitle() ) ;  
835     if ( branchName.BeginsWith(dataname) && branchTitle.BeginsWith(fBranchTitle) ){  
836       Warning("BranchExists","branch %s  with title  %s ",dataname.Data(),fBranchTitle.Data());
837       return kTRUE ;
838     }
839     if ( branchName.BeginsWith(zername) &&  branchTitle.BeginsWith(titleName) ){
840       Warning("BranchExists","branch AliEMCAL... with title  %s ",branch->GetTitle());
841       return kTRUE ; 
842     }
843   }
844   return kFALSE ;
845
846  }
847
848 void AliEMCALLoader::SetBranchTitle(const TString& btitle)
849  {
850   if (btitle.CompareTo(fBranchTitle) == 0) return;
851   fBranchTitle = btitle;
852   ReloadAll();
853  }
854 //____________________________________________________________________________ 
855
856 void AliEMCALLoader::CleanHits()
857 {
858   AliLoader::CleanHits();
859   //Clear an array 
860   TClonesArray* hits = Hits();
861   if (hits) hits->Clear();
862 }
863 //____________________________________________________________________________ 
864
865 void AliEMCALLoader::CleanSDigits()
866 {
867   AliLoader::CleanSDigits();
868   TClonesArray* sdigits = SDigits();
869   if (sdigits) sdigits->Clear();
870   
871 }
872 //____________________________________________________________________________ 
873
874 void AliEMCALLoader::CleanDigits()
875 {
876   AliLoader::CleanDigits();
877   TClonesArray* digits = Digits();
878   if (digits) digits->Clear();
879 }
880 //____________________________________________________________________________ 
881
882 void AliEMCALLoader::CleanRecPoints()
883 {
884   AliLoader::CleanRecPoints();
885   TObjArray* recpoints = PRERecPoints();
886   if (recpoints) recpoints->Clear();
887   recpoints = ECARecPoints();
888   if (recpoints) recpoints->Clear();
889   recpoints = HCARecPoints();
890   if (recpoints) recpoints->Clear();
891 }
892 //____________________________________________________________________________ 
893
894 void AliEMCALLoader::CleanTracks()
895 {
896 //Cleans Tracks stuff
897   
898   AliLoader::CleanTracks();//tree
899   
900   //and clear the array
901   TClonesArray* tracks = TrackSegments();
902   if (tracks) tracks->Clear();
903
904 }
905 //____________________________________________________________________________ 
906
907 void AliEMCALLoader::CleanRecParticles()
908  {
909
910    TClonesArray *recpar = RecParticles();
911    if (recpar) recpar->Clear();
912   
913  
914  }
915 //____________________________________________________________________________ 
916
917 // void AliEMCALLoader::ReadCalibrationDB(const char * database,const char * filename)
918 // {
919
920 //   if(fcdb && (strcmp(database,fcdb->GetTitle())==0))
921 //     return ;
922
923 //   TFile * file = gROOT->GetFile(filename) ;
924 //   if(!file)
925 //     file = TFile::Open(filename);
926 //   if(!file){
927 //     Error ("ReadCalibrationDB", "Cannot open file %s", filename) ;
928 //     return ;
929 //   }
930 //   if(fcdb)
931 //     fcdb->Delete() ;
932 //   fcdb = dynamic_cast<AliEMCALCalibrationDB *>(file->Get("AliEMCALCalibrationDB")) ;
933 //   if(!fcdb)
934 //     Error ("ReadCalibrationDB", "No database %s in file %s", database, filename) ;
935 // }
936 //____________________________________________________________________________ 
937
938 // AliEMCALSDigitizer*  AliEMCALLoader::EMCALSDigitizer() 
939 // { 
940 // //return EMCAL SDigitizer
941 //  return  dynamic_cast<AliEMCALSDigitizer*>(SDigitizer()) ;
942 // }
943
944 //____________________________________________________________________________ 
945 void AliEMCALLoader::MakeHitsArray()
946 {
947   if (Hits()) return;
948   TClonesArray* hits = new TClonesArray("AliEMCALHit",1000);
949   hits->SetName(fgkHitsName);
950   GetDetectorDataFolder()->Add(hits);
951 }
952
953 //____________________________________________________________________________ 
954 void AliEMCALLoader::MakeSDigitsArray()
955 {
956   if ( SDigits()) return;
957   TClonesArray* sdigits = new TClonesArray("AliEMCALDigit",1);
958   sdigits->SetName(fgkSDigitsName);
959   GetDetectorDataFolder()->Add(sdigits);
960 }
961
962 //____________________________________________________________________________ 
963 void AliEMCALLoader::MakeDigitsArray()
964 {
965   if ( Digits()) return;
966   TClonesArray* digits = new TClonesArray("AliEMCALDigit",1);
967   digits->SetName(fgkDigitsName);
968   GetDetectorDataFolder()->Add(digits);
969   
970 }
971
972 //____________________________________________________________________________ 
973 void AliEMCALLoader::MakeRecPointsArray()
974 {
975   if ( PRERecPoints() == 0x0) {
976     if (GetDebug()>9) 
977       Info("MakeRecPointsArray","Making array for PRE");
978     TObjArray* pre = new TObjArray(100) ;
979     pre->SetName(fgkPRERecPointsName) ;
980     GetDetectorDataFolder()->Add(pre);
981   }
982   if ( ECARecPoints() == 0x0) {
983     if (GetDebug()>9) 
984       Info("MakeRecPointsArray","Making array for ECA");
985     TObjArray* eca = new TObjArray(100) ;
986     eca->SetName(fgkECARecPointsName) ;
987     GetDetectorDataFolder()->Add(eca);
988    }
989   if ( HCARecPoints() == 0x0) {
990     if (GetDebug()>9) 
991       Info("MakeRecPointsArray","Making array for HCA");
992     TObjArray* hca = new TObjArray(100) ;
993     hca->SetName(fgkHCARecPointsName) ;
994     GetDetectorDataFolder()->Add(hca);
995    }
996 }
997
998 //____________________________________________________________________________ 
999 void AliEMCALLoader::MakeTrackSegmentsArray()
1000 {
1001   if ( TrackSegments()) return;
1002   TClonesArray * ts = new TClonesArray("AliEMCALTrackSegment",100) ;
1003   ts->SetName(fgkTracksName);
1004   GetDetectorDataFolder()->Add(ts);
1005
1006 }
1007
1008 //____________________________________________________________________________ 
1009 void AliEMCALLoader::MakeRecParticlesArray()
1010 {
1011   if ( RecParticles()) return;
1012   TClonesArray * rp = new TClonesArray("AliEMCALRecParticle",100) ;
1013   rp->SetName(fgkRecParticlesName);
1014   GetDetectorDataFolder()->Add(rp);
1015 }