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