ad286785db6690509ca9b24234be1d573c7ff475
[u/mrichter/AliRoot.git] / PHOS / AliPHOSLoader.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 AliPHOSAnalyser):
28 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
29 //     AliPHOSRecParticle * 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 AliPHOSIndexToObject 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 "AliPHOSLoader.h"
59 #include "AliPHOS.h"
60 #include "AliPHOSDigitizer.h"
61 #include "AliPHOSSDigitizer.h"
62 #include "AliPHOSClusterizer.h"
63 #include "AliPHOSClusterizerv1.h"
64 #include "AliPHOSTrackSegmentMaker.h"
65 #include "AliPHOSTrackSegmentMakerv1.h"
66 #include "AliPHOSTrackSegment.h"
67 #include "AliPHOSPID.h" 
68 #include "AliPHOSPIDv1.h" 
69 #include "AliPHOSGeometry.h"
70 #include "AliPHOSCalibrationDB.h"
71
72 ClassImp(AliPHOSLoader)
73
74
75 const TString AliPHOSLoader::fgkHitsName("HITS");//Name for TClonesArray with hits from one event
76 const TString AliPHOSLoader::fgkSDigitsName("SDIGITS");//Name for TClonesArray 
77 const TString AliPHOSLoader::fgkDigitsName("DIGITS");//Name for TClonesArray 
78 const TString AliPHOSLoader::fgkEmcRecPointsName("EMCRECPOINTS");//Name for TClonesArray 
79 const TString AliPHOSLoader::fgkCpvRecPointsName("CPVRECPOINTS");//Name for TClonesArray 
80 const TString AliPHOSLoader::fgkTracksName("TRACKS");//Name for TClonesArray 
81 const TString AliPHOSLoader::fgkRecParticlesName("RECPARTICLES");//Name for TClonesArray
82
83 const TString AliPHOSLoader::fgkEmcRecPointsBranchName("PHOSEmcRP");//Name for branch with EMC Reconstructed Points
84 const TString AliPHOSLoader::fgkCpvRecPointsBranchName("PHOSCpvRP");//Name for branch with CPV Reconstructed Points
85 const TString AliPHOSLoader::fgkTrackSegmentsBranchName("PHOSTS");//Name for branch with TrackSegments
86 const TString AliPHOSLoader::fgkRecParticlesBranchName("PHOSRP");//Name for branch with Reconstructed Particles
87 //____________________________________________________________________________ 
88 AliPHOSLoader::AliPHOSLoader()
89  {
90   fDebug = 0;
91  }
92 //____________________________________________________________________________ 
93 AliPHOSLoader::AliPHOSLoader(const Char_t *detname,const Char_t *eventfoldername):
94       AliLoader(detname,eventfoldername)
95 {
96   fDebug=0;
97 }
98 //____________________________________________________________________________ 
99
100 AliPHOSLoader::~AliPHOSLoader()
101 {
102   //remove and delete arrays
103   Clean(fgkHitsName);
104   Clean(fgkSDigitsName);
105   Clean(fgkDigitsName);
106   Clean(fgkEmcRecPointsName);
107   Clean(fgkCpvRecPointsName);
108   Clean(fgkTracksName);
109   Clean(fgkRecParticlesName);
110 }
111 //____________________________________________________________________________ 
112
113 void AliPHOSLoader::CleanFolders()
114  {
115    CleanRecParticles();
116    AliLoader::CleanFolders();
117  }
118 //____________________________________________________________________________ 
119
120 Int_t AliPHOSLoader::SetEvent()
121 {
122 //Cleans loaded stuff and and sets Files and Directories
123 // do not post any data to folder/tasks
124
125
126  Int_t retval = AliLoader::SetEvent();
127   if (retval)
128    {
129      Error("SetEvent","AliLoader::SetEvent returned error");
130      return retval;
131    }
132
133
134   if (Hits()) Hits()->Clear();
135   if (SDigits()) SDigits()->Clear();
136   if (Digits()) Digits()->Clear();
137   if (EmcRecPoints()) EmcRecPoints()->Clear();
138   if (CpvRecPoints()) CpvRecPoints()->Clear();
139   if (TrackSegments()) TrackSegments()->Clear();
140   if (RecParticles()) RecParticles()->Clear();
141    
142   return 0;
143 }
144 //____________________________________________________________________________ 
145
146 Int_t AliPHOSLoader::GetEvent()
147 {
148 //Overloads GetEvent method called by AliRunLoader::GetEvent(Int_t) method
149 //to add Rec Particles specific for PHOS
150
151 //First call the original method to get whatever from std. setup is needed
152   Int_t retval;
153   
154   retval = AliLoader::GetEvent();
155   if (retval)
156    {
157      Error("GetEvent","AliLoader::GetEvent returned error");
158      return retval;
159    }
160   
161   if (GetHitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadHits();
162   if (GetSDigitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadSDigits();
163   if (GetDigitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadDigits();
164   if (GetRecPointsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadRecPoints();
165   if (GetTracksDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadTracks();
166   if (GetRecParticlesDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadRecParticles();
167
168
169 //Now, check if RecPart were loaded  
170   return 0;
171 }
172 //____________________________________________________________________________ 
173
174
175 //____________________________________________________________________________ 
176 const AliPHOS * AliPHOSLoader::PHOS() 
177 {
178   // returns the PHOS object 
179   AliPHOS * phos = dynamic_cast<AliPHOS*>(GetModulesFolder()->FindObject(fDetectorName));
180   if ( phos == 0x0) 
181     if (fDebug)
182       cout << "WARNING: AliPHOSLoader::PHOS -> PHOS module not found in Folders" << endl ; 
183   return phos ; 
184 }  
185
186 //____________________________________________________________________________ 
187 const AliPHOSGeometry * AliPHOSLoader::PHOSGeometry() 
188 {
189   // Return PHOS geometry
190   AliPHOSGeometry * rv = 0 ; 
191   if (PHOS() )
192     rv =  PHOS()->GetGeometry();
193   return rv ; 
194
195
196
197 //____________________________________________________________________________ 
198 Int_t AliPHOSLoader::LoadHits(Option_t* opt)
199 {  
200 //------- Hits ----------------------
201 //Overload (extends) LoadHits implemented in AliLoader
202 //
203   Int_t res;
204   
205   //First call the AliLoader's method to send the TreeH to folder
206   res = AliLoader::LoadHits(opt);
207   
208   if (res)
209    {//oops, error
210      Error("LoadHits","AliLoader::LoadHits returned error");
211      return res;
212    }
213
214   //read the data from tree in folder and send it to folder
215   res = ReadHits();
216   return 0;
217 }
218
219
220 //____________________________________________________________________________ 
221 Int_t AliPHOSLoader::LoadSDigits(Option_t* opt)
222 {
223   //---------- SDigits -------------------------
224   Int_t res;
225   //First call the AliLoader's method to send the TreeS to folder
226   res = AliLoader::LoadSDigits(opt);
227   if (res)
228    {//oops, error
229      Error("PostSDigits","AliLoader::LoadSDigits returned error");
230      return res;
231    }
232   return ReadSDigits();
233    
234
235 //____________________________________________________________________________ 
236 Int_t AliPHOSLoader::LoadDigits(Option_t* opt)
237
238   //---------- Digits -------------------------
239   Int_t res;
240   //First call the AliLoader's method to send the TreeS to folder
241   res = AliLoader::LoadDigits(opt);
242   if (res)
243    {//oops, error
244      Error("LoadDigits","AliLoader::LoadDigits returned error");
245      return res;
246    }
247   return ReadDigits();
248 }
249 //____________________________________________________________________________ 
250 Int_t AliPHOSLoader::LoadRecPoints(Option_t* opt) 
251 {
252   // -------------- RecPoints -------------------------------------------
253   Int_t res;
254   //First call the AliLoader's method to send the TreeR to folder
255   res = AliLoader::LoadRecPoints(opt);
256   if (res)
257    {//oops, error
258      Error("LoadRecPoints","AliLoader::LoadRecPoints returned error");
259      return res;
260    }
261
262   TFolder * phosFolder = GetDetectorDataFolder();
263   if ( phosFolder  == 0x0 ) 
264    {
265      Error("PostDigits","Can not get detector data folder");
266      return 1;
267    }
268   return ReadRecPoints();
269 }
270 //____________________________________________________________________________ 
271
272 Int_t  AliPHOSLoader::LoadTracks(Option_t* opt)
273 {
274  //Loads Tracks: Open File, Reads Tree and posts, Read Data and Posts
275  if (GetDebug()) Info("LoadTracks","opt = %s",opt);
276  Int_t res;
277  res = AliLoader::LoadTracks(opt);
278  if (res)
279    {//oops, error
280       Error("LoadTracks","AliLoader::LoadTracks returned error");
281       return res;
282    }  
283  return ReadTracks();
284 }
285
286 //____________________________________________________________________________ 
287 Int_t AliPHOSLoader::LoadRecParticles(Option_t* opt) 
288 {
289   // -------------- RecPoints -------------------------------------------
290   Int_t res;
291   //First call the AliLoader's method to send the TreeT to folder
292   res = AliLoader::LoadRecParticles(opt);
293   if (res)
294    {//oops, error
295      Error("LoadRecParticles","AliLoader::LoadRecParticles returned error");
296      return res;
297    }
298   return ReadRecParticles();
299 }
300
301 //____________________________________________________________________________ 
302
303 Int_t AliPHOSLoader::PostHits()
304 {
305   // -------------- Hits -------------------------------------------
306   Int_t reval = AliLoader::PostHits();
307   if (reval)
308    {
309      Error("PostHits","AliLoader::  returned error");
310      return reval;
311    }
312   return ReadHits();
313 }
314 //____________________________________________________________________________ 
315
316 Int_t AliPHOSLoader::PostSDigits()
317 {
318   // -------------- SDigits -------------------------------------------
319   Int_t reval = AliLoader::PostSDigits();
320   if (reval)
321    {
322      Error("PostSDigits","AliLoader::PostSDigits  returned error");
323      return reval;
324    }
325   return ReadSDigits();
326 }
327 //____________________________________________________________________________ 
328
329 Int_t AliPHOSLoader::PostDigits()
330 {
331   // -------------- Digits -------------------------------------------
332   Int_t reval = AliLoader::PostDigits();
333   if (reval)
334    {
335      Error("PostDigits","AliLoader::PostDigits  returned error");
336      return reval;
337    }
338   return ReadDigits();
339 }
340 //____________________________________________________________________________ 
341
342 Int_t AliPHOSLoader::PostRecPoints()
343 {
344   // -------------- RecPoints -------------------------------------------
345   Int_t reval = AliLoader::PostRecPoints();
346   if (reval)
347    {
348      Error("PostRecPoints","AliLoader::PostRecPoints  returned error");
349      return reval;
350    }
351   return ReadRecPoints();
352 }
353
354 //____________________________________________________________________________ 
355
356 Int_t AliPHOSLoader::PostRecParticles()
357 {
358   // -------------- RecParticles -------------------------------------------
359   Int_t reval = AliLoader::PostRecParticles();
360   if (reval)
361    {
362      Error("PostRecParticles","AliLoader::PostRecParticles  returned error");
363      return reval;
364    }
365   return ReadRecParticles();
366 }
367 //____________________________________________________________________________ 
368
369 Int_t AliPHOSLoader::PostTracks()
370 {
371   // -------------- Tracks -------------------------------------------
372   Int_t reval = AliLoader::PostTracks();
373   if (reval)
374    {
375      Error("PostTracks","AliLoader::PostTracks  returned error");
376      return reval;
377    }
378   return ReadTracks();
379 }
380 //____________________________________________________________________________ 
381
382
383
384 //____________________________________________________________________________ 
385 Int_t AliPHOSLoader::ReadHits()
386 {
387 // If there is no Clones Array in folder creates it and sends to folder
388 // then tries to read
389 // Reads the first entry of PHOS branch in hit tree TreeH()
390 // Reads data from TreeH and stores it in TClonesArray that sits in DetectorDataFolder
391 //
392   TObject** hitref = HitsRef();
393   if(hitref == 0x0)
394    {
395      MakeHitsArray();
396      hitref = HitsRef();
397    }
398
399   TClonesArray* hits = dynamic_cast<TClonesArray*>(*hitref);
400
401   TTree* treeh = TreeH();
402   
403   if(treeh == 0)
404    {
405     Error("ReadHits"," Cannot read TreeH from folder");
406     return 1;
407   }
408   
409   TBranch * hitsbranch = treeh->GetBranch(fDetectorName);
410   if (hitsbranch == 0) 
411    {
412     Error("ReadHits"," Cannot find branch PHOS"); 
413     return 1;
414   }
415   
416   if (GetDebug()) Info("ReadHits","Reading Hits");
417   
418   if (hitsbranch->GetEntries() > 1)
419    {
420     TClonesArray * tempo =  new TClonesArray("AliPHOSHit",1000);
421
422     hitsbranch->SetAddress(&tempo);
423     Int_t index = 0 ; 
424     Int_t i = 0 ;
425     for (i = 0 ; i < hitsbranch->GetEntries(); i++) 
426      {
427       hitsbranch->GetEntry(i) ;
428       Int_t j = 0 ;
429       for ( j = 0 ; j < tempo->GetEntries() ; j++) 
430        {
431          AliPHOSHit* hit = (AliPHOSHit*)tempo->At(j); 
432          new((*hits)[index]) AliPHOSHit( *hit ) ;
433          index++ ; 
434        }
435      }
436     delete tempo;
437    }
438   else 
439    {
440     hitsbranch->SetAddress(hitref);
441     hitsbranch->GetEntry(0) ;
442    }
443
444   return 0;
445 }
446 //____________________________________________________________________________ 
447 Int_t AliPHOSLoader::ReadSDigits()
448 {
449 // Read the summable digits tree TreeS():
450 // Check if TClones is in folder
451 // if not create and add to folder
452 // connect to tree if available
453 // Read the data
454
455   TObject** sdref = SDigitsRef();
456   if(sdref == 0x0)
457    {
458      MakeSDigitsArray();
459      sdref = SDigitsRef();
460    }
461    
462   TTree * treeS = TreeS();
463   if(treeS==0)
464    {
465      //May happen if file is truncated or new in LoadSDigits
466      //Error("ReadSDigits","There is no SDigit Tree");
467      return 0;
468    }
469   
470   TBranch * branch = treeS->GetBranch(fDetectorName);
471   if (branch == 0) 
472    {//easy, maybe just a new tree
473     //Error("ReadSDigits"," Cannot find branch PHOS"); 
474     return 0;
475   }
476     
477   branch->SetAddress(SDigitsRef());
478   branch->GetEntry(0);
479   return 0;
480 }
481
482 //____________________________________________________________________________ 
483 Int_t AliPHOSLoader::ReadDigits()
484 {
485 // Read the summable digits tree TreeS():
486 // Check if TClones is in folder
487 // if not create and add to folder
488 // connect to tree if available
489 // Read the data
490   
491   TObject** dref = DigitsRef();
492   if(dref == 0x0)
493    {//if there is not array in folder, create it and put it there
494      MakeDigitsArray();
495      dref = DigitsRef();
496    }
497
498   TTree * treeD = TreeD();
499   if(treeD==0)
500    {
501      //May happen if file is truncated or new in LoadSDigits
502      //Error("ReadDigits","There is no Digit Tree");
503      return 0;
504    }
505
506   TBranch * branch = treeD->GetBranch(fDetectorName);
507   if (branch == 0) 
508    {//easy, maybe just a new tree
509     //Error("ReadDigits"," Cannot find branch ",fDetectorName.Data()); 
510     return 0;
511    }
512   
513   branch->SetAddress(dref);//connect branch to buffer sitting in folder
514   branch->GetEntry(0);//get first event 
515
516   return 0;  
517 }
518
519 //____________________________________________________________________________ 
520
521 void AliPHOSLoader::Track(Int_t itrack)
522 {
523 // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
524   if(TreeH()== 0)
525    {
526      if (LoadHits())
527       {
528         Error("Track","Can not load hits.");
529         return;
530       } 
531    }
532   
533   TBranch * hitsbranch = dynamic_cast<TBranch*>(TreeH()->GetListOfBranches()->FindObject("PHOS")) ;
534   if ( !hitsbranch ) {
535     if (fDebug)
536       cout << "WARNING:  AliPHOSLoader::ReadTreeH -> Cannot find branch PHOS" << endl ; 
537     return ;
538   }  
539   if(!Hits()) PostHits();
540
541   hitsbranch->SetAddress(HitsRef());
542   hitsbranch->GetEntry(itrack);
543
544 }
545 //____________________________________________________________________________ 
546 void AliPHOSLoader::ReadTreeQA()
547 {
548   // Read the digit tree gAlice->TreeQA()
549   // so far only PHOS knows about this Tree  
550
551   if(PHOS()->TreeQA()== 0){
552     cerr <<   "ERROR: AliPHOSLoader::ReadTreeQA: can not read TreeQA " << endl ;
553     return ;
554   }
555   
556   TBranch * qabranch = PHOS()->TreeQA()->GetBranch("PHOS");
557   if (!qabranch) { 
558     if (fDebug)
559       cout << "WARNING: AliPHOSLoader::ReadTreeQA -> Cannot find QA Alarms for PHOS" << endl ;
560     return ; 
561   }   
562   
563 //  if(!Alarms()) PostQA();
564
565   qabranch->SetAddress(AlarmsRef()) ;
566
567   qabranch->GetEntry(0) ;
568   
569 }
570
571
572 //____________________________________________________________________________ 
573 Int_t AliPHOSLoader::ReadRecPoints()
574 {
575 //Creates and posts to folder an array container, 
576 //connects branch in tree (if exists), and reads data to array
577   
578   MakeRecPointsArray();
579   
580   TObjArray * cpva = 0x0 ; 
581   TObjArray * emca = 0x0 ; 
582   
583   TTree * treeR = TreeR();
584  
585   if(treeR==0)
586    {
587      //May happen if file is truncated or new in LoadSDigits
588      return 0;
589    }
590
591   Int_t retval = 0;
592   TBranch * emcbranch = treeR->GetBranch(fgkEmcRecPointsBranchName);
593
594   if (emcbranch == 0x0)
595    {
596      Error("ReadRecPoints","Can not get branch with EMC Rec. Points named %s",fgkEmcRecPointsBranchName.Data());
597      retval = 1;
598    }
599   else
600    {
601      emcbranch->SetAddress(&emca) ;
602      emcbranch->GetEntry(0) ;
603    }
604   TBranch * cpvbranch = treeR->GetBranch(fgkCpvRecPointsBranchName);
605   if (cpvbranch == 0x0)
606    {
607      Error("ReadRecPoints","Can not get branch with CPV Rec. Points named %s",fgkCpvRecPointsBranchName.Data());
608      retval = 2;
609    }
610   else
611    {
612      cpvbranch->SetAddress(&cpva);
613      cpvbranch->GetEntry(0) ;
614    }
615
616   Int_t ii ; 
617   Int_t maxemc = emca->GetEntries() ; 
618   for ( ii= 0 ; ii < maxemc ; ii++ ) 
619     EmcRecPoints()->Add(emca->At(ii)) ;
620  
621   Int_t maxcpv = cpva->GetEntries() ;
622   for ( ii= 0 ; ii < maxcpv ; ii++ )
623     CpvRecPoints()->Add(cpva->At(ii)) ; 
624
625   return retval;
626 }
627
628 //____________________________________________________________________________ 
629 Int_t AliPHOSLoader::ReadTracks()
630 {
631 //Creates and posts to folder an array container, 
632 //connects branch in tree (if exists), and reads data to arry
633
634   TObject** trkref = TracksRef();
635   if ( trkref == 0x0 )   
636    {//Create and post array
637     MakeTrackSegmentsArray();
638     trkref = TracksRef();
639    }
640
641   TTree * treeT = TreeT();
642   if(treeT==0)
643    {
644      //May happen if file is truncated or new in LoadSDigits, or the file is in update mode, 
645      //but tracking was not performed yet for a current event
646      //Error("ReadTracks","There is no Tree with Tracks");
647      return 0;
648    }
649   
650   TBranch * branch = treeT->GetBranch(fgkTrackSegmentsBranchName);
651   if (branch == 0) 
652    {//easy, maybe just a new tree
653     Error("ReadTracks"," Cannot find branch named %s",fgkTrackSegmentsBranchName.Data());
654     return 0;
655   }
656
657   branch->SetAddress(trkref);//connect branch to buffer sitting in folder
658   branch->GetEntry(0);//get first event 
659   
660   return 0;
661 }
662 //____________________________________________________________________________ 
663
664 Int_t AliPHOSLoader::ReadRecParticles()
665 {
666 //Reads Reconstructed  Particles from file
667 //Creates and posts to folder an array container, 
668 //connects branch in tree (if exists), and reads data to arry
669   
670   TObject** recpartref = RecParticlesRef();
671   
672   if ( recpartref == 0x0 )   
673    {//Create and post array
674     MakeRecParticlesArray();
675     recpartref = RecParticlesRef();
676    }
677
678   TTree * treeP = TreeP();
679   if(treeP==0)
680    {
681      //May happen if file is truncated or new in LoadSDigits, 
682      //or the file is in update mode, 
683      //but tracking was not performed yet for a current event
684      //     Error("ReadRecParticles","There is no Tree with Tracks and Reconstructed Particles");
685      return 0;
686    }
687   
688   TBranch * branch = treeP->GetBranch(fgkRecParticlesBranchName);
689   if (branch == 0) 
690    {//easy, maybe just a new tree
691     Error("ReadRecParticles"," Cannot find branch %s",fgkRecParticlesBranchName.Data()); 
692     return 0;
693   }
694
695   branch->SetAddress(recpartref);//connect branch to buffer sitting in folder
696   branch->GetEntry(0);//get first event 
697   
698   return 0;
699 }
700
701
702 AliPHOSGeometry* AliPHOSLoader::GetPHOSGeometry()
703 {
704   //returns PHOS geometry from gAlice 
705   //static Method used by some classes where it is not convienient to pass eventfoldername
706   if (gAlice == 0x0)
707     return 0x0;
708   AliPHOS* phos=dynamic_cast<AliPHOS*>(gAlice->GetDetector("PHOS"));
709   if (phos == 0x0)
710     return 0x0;
711   return phos->GetGeometry();
712 }
713 /***************************************************************************************/
714
715 AliPHOSLoader* AliPHOSLoader::GetPHOSLoader(const  char* eventfoldername)
716 {
717   // Return PHOS loader
718   AliRunLoader* rn  = AliRunLoader::GetRunLoader(eventfoldername);
719   if (rn == 0x0)
720    {
721      cerr<<"Error: <AliPHOSLoader::GetPHOSLoader>: "
722          << "Can not find Run Loader in folder "<<eventfoldername<<endl;
723      return 0x0;
724    }
725   return dynamic_cast<AliPHOSLoader*>(rn->GetLoader("PHOSLoader"));
726 }
727 /***************************************************************************************/
728
729 Bool_t AliPHOSLoader::BranchExists(const TString& recName)
730 {
731   // Check if a branch named redName exists
732   if (fBranchTitle.IsNull()) return kFALSE;
733   TString dataname, zername ;
734   TTree* tree;
735   if(recName == "SDigits")
736    {
737     tree = TreeS();
738     dataname = GetDetectorName();
739     zername = "AliPHOSSDigitizer" ;
740    }
741   else
742     if(recName == "Digits"){
743       tree = TreeD();
744       dataname = GetDetectorName();
745       zername = "AliPHOSDigitizer" ;
746     }
747     else
748       if(recName == "RecPoints"){
749        tree = TreeR();
750        dataname = fgkEmcRecPointsBranchName;
751        zername = "AliPHOSClusterizer" ;
752       }
753       else
754        if(recName == "TrackSegments"){
755          tree = TreeT();
756          dataname = fgkTrackSegmentsBranchName;
757          zername = "AliPHOSTrackSegmentMaker";
758        }        
759        else
760          if(recName == "RecParticles"){
761            tree = TreeP();
762            dataname = fgkRecParticlesBranchName;
763            zername = "AliPHOSPID";
764          }
765          else
766            return kFALSE ;
767
768   
769   if(!tree ) 
770     return kFALSE ;
771
772   TObjArray * lob = static_cast<TObjArray*>(tree->GetListOfBranches()) ;
773   TIter next(lob) ; 
774   TBranch * branch = 0 ;  
775   TString titleName(fBranchTitle);
776   titleName+=":";
777
778   while ((branch = (static_cast<TBranch*>(next())))) {
779     TString branchName(branch->GetName() ) ; 
780     TString branchTitle(branch->GetTitle() ) ;  
781     if ( branchName.BeginsWith(dataname) && branchTitle.BeginsWith(fBranchTitle) ){  
782       Warning("BranchExists","branch %s  with title  %s ",dataname.Data(),fBranchTitle.Data());
783       return kTRUE ;
784     }
785     if ( branchName.BeginsWith(zername) &&  branchTitle.BeginsWith(titleName) ){
786       Warning("BranchExists","branch AliPHOS... with title  %s ",branch->GetTitle());
787       return kTRUE ; 
788     }
789   }
790   return kFALSE ;
791
792  }
793
794 void AliPHOSLoader::SetBranchTitle(const TString& btitle)
795 {
796   // Set branch title
797   if (btitle.CompareTo(fBranchTitle) == 0) return;
798   fBranchTitle = btitle;
799   ReloadAll();
800  }
801 //____________________________________________________________________________ 
802
803 void AliPHOSLoader::CleanHits()
804 {
805   // Clean Hits array
806   AliLoader::CleanHits();
807   //Clear an array 
808   TClonesArray* hits = Hits();
809   if (hits) hits->Clear();
810 }
811 //____________________________________________________________________________ 
812
813 void AliPHOSLoader::CleanSDigits()
814 {
815   // Clean SDigits array
816   AliLoader::CleanSDigits();
817   TClonesArray* sdigits = SDigits();
818   if (sdigits) sdigits->Clear();
819   
820 }
821 //____________________________________________________________________________ 
822
823 void AliPHOSLoader::CleanDigits()
824 {
825   // Clean Digits array
826   AliLoader::CleanDigits();
827   TClonesArray* digits = Digits();
828   if (digits) digits->Clear();
829 }
830 //____________________________________________________________________________ 
831
832 void AliPHOSLoader::CleanRecPoints()
833 {
834   // Clean RecPoints array
835   AliLoader::CleanRecPoints();
836   TObjArray* recpoints = EmcRecPoints();
837   if (recpoints) recpoints->Clear();
838   recpoints = CpvRecPoints();
839   if (recpoints) recpoints->Clear();
840 }
841 //____________________________________________________________________________ 
842
843 void AliPHOSLoader::CleanTracks()
844 {
845   //Cleans Tracks stuff
846   AliLoader::CleanTracks();//tree
847   
848   //and clear the array
849   TClonesArray* tracks = TrackSegments();
850   if (tracks) tracks->Clear();
851
852 }
853 //____________________________________________________________________________ 
854
855 void AliPHOSLoader::CleanRecParticles()
856  {
857    // Clean RecParticles array
858    TClonesArray *recpar = RecParticles();
859    if (recpar) recpar->Clear();
860   
861  
862  }
863 //____________________________________________________________________________ 
864
865 void AliPHOSLoader::ReadCalibrationDB(const char * database,const char * filename)
866 {
867   // Read calibration data base from file
868   if(fcdb && (strcmp(database,fcdb->GetTitle())==0))
869     return ;
870
871   TFile * file = gROOT->GetFile(filename) ;
872   if(!file)
873     file = TFile::Open(filename);
874   if(!file){
875     Error ("ReadCalibrationDB", "Cannot open file %s", filename) ;
876     return ;
877   }
878   if(fcdb)
879     fcdb->Delete() ;
880   fcdb = dynamic_cast<AliPHOSCalibrationDB *>(file->Get("AliPHOSCalibrationDB")) ;
881   if(!fcdb)
882     Error ("ReadCalibrationDB", "No database %s in file %s", database, filename) ;
883 }
884 //____________________________________________________________________________ 
885
886 // AliPHOSSDigitizer*  AliPHOSLoader::PHOSSDigitizer() 
887 // { 
888 // //return PHOS SDigitizer
889 //  return  dynamic_cast<AliPHOSSDigitizer*>(SDigitizer()) ;
890 // }
891
892 //____________________________________________________________________________ 
893 void AliPHOSLoader::MakeHitsArray()
894 {
895   // Add Hits array to the data folder
896   if (Hits()) return;
897   TClonesArray* hits = new TClonesArray("AliPHOSHit",1000);
898   hits->SetName(fgkHitsName);
899   GetDetectorDataFolder()->Add(hits);
900 }
901
902 //____________________________________________________________________________ 
903 void AliPHOSLoader::MakeSDigitsArray()
904 {
905   // Add SDigits array to the data folder
906   if ( SDigits()) return;
907   TClonesArray* sdigits = new TClonesArray("AliPHOSDigit",1);
908   sdigits->SetName(fgkSDigitsName);
909   GetDetectorDataFolder()->Add(sdigits);
910 }
911
912 //____________________________________________________________________________ 
913 void AliPHOSLoader::MakeDigitsArray()
914 {
915   // Add Digits array to the data folder
916   if ( Digits()) return;
917   TClonesArray* digits = new TClonesArray("AliPHOSDigit",1);
918   digits->SetName(fgkDigitsName);
919   GetDetectorDataFolder()->Add(digits);
920   
921 }
922
923 //____________________________________________________________________________ 
924 void AliPHOSLoader::MakeRecPointsArray()
925 {
926   // Add RecPoints array to the data folder
927   if ( EmcRecPoints() == 0x0)
928    {
929     if (GetDebug()>9) Info("MakeRecPointsArray","Making array for EMC");
930     TObjArray* emc = new TObjArray(100) ;
931     emc->SetName(fgkEmcRecPointsName) ;
932     GetDetectorDataFolder()->Add(emc);
933    }
934
935   if ( CpvRecPoints() == 0x0)
936    {
937     if (GetDebug()>9) Info("MakeRecPointsArray","Making array for CPV");
938     TObjArray* cpv = new TObjArray(100) ;
939     cpv->SetName(fgkCpvRecPointsName);
940     GetDetectorDataFolder()->Add(cpv);
941    }
942 }
943
944 //____________________________________________________________________________ 
945 void AliPHOSLoader::MakeTrackSegmentsArray()
946 {
947   // Add TrackSegments array to the data folder
948   if ( TrackSegments()) return;
949   TClonesArray * ts = new TClonesArray("AliPHOSTrackSegment",100) ;
950   ts->SetName(fgkTracksName);
951   GetDetectorDataFolder()->Add(ts);
952
953 }
954
955 //____________________________________________________________________________ 
956 void AliPHOSLoader::MakeRecParticlesArray()
957 {
958   // Add RecParticles array to the data folder
959   if ( RecParticles()) return;
960   TClonesArray * rp = new TClonesArray("AliPHOSRecParticle",100) ;
961   rp->SetName(fgkRecParticlesName);
962   GetDetectorDataFolder()->Add(rp);
963 }