]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliLoader.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
EMCAL included in ESD
[u/mrichter/AliRoot.git] / STEER / AliLoader.cxx
CommitLineData
88cb7938 1//
2//Class (base) responsible for management of data:
3// - opening and closing proper files
4// - posting data to folders
5// - writing data from folders to proper files
6//
7//Author: Alice Offline Group http://alisoft.cern.ch
8//Responsible: Piotr.Skowronski@cern.ch
9//
10#include <AliLoader.h>
11
12//Root includes
13#include <TROOT.h>
14#include <TFolder.h>
15#include <TFile.h>
16#include <TTree.h>
17#include <TTask.h>
18#include <TString.h>
19#include <TError.h>
20
21//AliRoot includes
22#include <AliRun.h>
23#include <AliRunLoader.h>
24#include <AliRunDigitizer.h>
25#include <AliDigitizer.h>
26#include <AliDetector.h>
d0d4a6b3 27#include "AliConfig.h"
88cb7938 28
29Int_t AliLoader::fgDebug = 0;
30
31const TString AliLoader::fgkDefaultHitsContainerName("TreeH");
32const TString AliLoader::fgkDefaultDigitsContainerName = "TreeD";
33const TString AliLoader::fgkDefaultSDigitsContainerName = "TreeS";
34const TString AliLoader::fgkDefaultRecPointsContainerName = "TreeR";
35const TString AliLoader::fgkDefaultTracksContainerName = "TreeT";
36const TString AliLoader::fgkDefaultRecParticlesContainerName = "TreeP";
37const TString AliLoader::fgkLoaderBaseName("Loader");
38
39ClassImp(AliLoader)
40//___________________________________________________________________
41/////////////////////////////////////////////////////////////////////
42// //
43// class AliLoader //
44// //
45// Base class for Loaders. //
46// Loader provides base I/O fascilities for "standard" data. //
47// Each detector has a laoder data member //
48// loader is accessible via folder structure as well //
49// //
50/////////////////////////////////////////////////////////////////////
51
52/*****************************************************************************/
53
54AliLoader::AliLoader():
55 fDataLoaders(0x0),
56 fDetectorName(""),
57 fEventFolder(0x0),
58 fDataFolder(0x0),
59 fDetectorDataFolder(0x0),
60 fModuleFolder(0x0),
61 fTasksFolder(0x0),
62 fQAFolder(0x0)
63 {
64//default constructor
65
66 }
67/******************************************************************/
68
69AliLoader::AliLoader(const Char_t* detname,const Char_t* eventfoldername):
70 fDataLoaders(new TObjArray(kNDataTypes)),
71 fDetectorName(""),
72 fEventFolder(0x0),
73 fDataFolder(0x0),
74 fDetectorDataFolder(0x0),
75 fModuleFolder(0x0),
76 fTasksFolder(0x0),
77 fQAFolder(0x0)
78{
79 //ctor
80 if (GetDebug()) Info("AliLoader(const Char_t* detname,const Char_t* eventfoldername)",
81 "detname = %s eventfoldername = %s",detname,eventfoldername);
82
83 //try to find folder eventfoldername in top alice folder
84 //safe because GetTopFolder will abort in case of failure
85
86 fDetectorName = detname;
87 fName = fDetectorName+"Loader";
88 InitDefaults();
89
90 TObject* fobj = GetTopFolder()->FindObject(eventfoldername);
91 fEventFolder = (fobj)?dynamic_cast<TFolder*>(fobj):0x0;//in case FindObject returns NULL dynamic cast cause seg. fault
92 SetEventFolder(fEventFolder);
93
94 }
95/*****************************************************************************/
96
97AliLoader::AliLoader(const Char_t * detname,TFolder* eventfolder):
98 fDataLoaders(new TObjArray(kNDataTypes)),
99 fDetectorName(detname),
100 fEventFolder(0x0),
101 fDataFolder(0x0),
102 fDetectorDataFolder(0x0),
103 fModuleFolder(0x0),
104 fTasksFolder(0x0),
105 fQAFolder(0x0)
106{
107//constructor
108 fDetectorName = detname;
109 fName = fDetectorName+"Loader";
110 InitDefaults();
111 SetEventFolder(eventfolder);
112 //fileoption's don't need to initialized because default TString ctor does it correctly
113}
114/*****************************************************************************/
d0d4a6b3 115AliLoader::AliLoader(const AliLoader& source):TNamed(source) {
116 // dummy copy constructor
117 if(&source==this)return;
118
119 Fatal("AliLoader","Copy constructor not implemented. Aborting");
120 return;
121}
88cb7938 122
d0d4a6b3 123/*****************************************************************************/
124AliLoader& AliLoader::operator=(const AliLoader& source) {
125 // dummy assignment operator
126 if(&source==this) return *this;
127
128 Fatal("AliLoader","Assignment operator not implemented. Aborting");
129 return *this;
130}
131
132/*****************************************************************************/
88cb7938 133AliLoader::~AliLoader()
134{
135//detructor
136 if (fDataLoaders) fDataLoaders->SetOwner();
137 delete fDataLoaders;
138}
139/*****************************************************************************/
140
141void AliLoader::InitDefaults()
142{
143 // H I T S
144 AliDataLoader* dl;
145 dl = new AliDataLoader(fDetectorName + ".Hits.root",fgkDefaultHitsContainerName, "Hits" );
146 fDataLoaders->AddAt(dl,kHits);
147
148
149 // S U M M A B L E D I G I T S
150 dl = new AliDataLoader(fDetectorName + ".SDigits.root",fgkDefaultSDigitsContainerName, "Summable Digits");
151 AliTaskLoader* tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetSDigitizerTaskName(),
152 dl,AliRunLoader::GetRunSDigitizer(),kTRUE);
153 dl->SetBaseTaskLoader(tl);
154 fDataLoaders->AddAt(dl,kSDigits);
155
156 // D I G I T S
157 dl = new AliDataLoader(fDetectorName + ".Digits.root",fgkDefaultDigitsContainerName, "Digits");
158 tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetDigitizerTaskName(),
159 dl,AliRunLoader::GetRunDigitizer(),kTRUE);
160 dl->SetBaseTaskLoader(tl);
161 fDataLoaders->AddAt(dl,kDigits);
162
163 // R E C O N S T R U C T E D P O I N T S aka C L U S T E R S
164 dl = new AliDataLoader(fDetectorName + ".RecPoints.root",fgkDefaultRecPointsContainerName, "Reconstructed Points");
165 tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetReconstructionerTaskName(),
166 dl,AliRunLoader::GetRunReconstructioner(),kTRUE);
167 dl->SetBaseTaskLoader(tl);
168 fDataLoaders->AddAt(dl,kRecPoints);
169
170 // T R A C K S
171 dl = new AliDataLoader(fDetectorName + ".Tracks.root",fgkDefaultTracksContainerName, "Tracks");
172 tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetTrackerTaskName(),
173 dl,AliRunLoader::GetRunTracker(),kTRUE);
174 dl->SetBaseTaskLoader(tl);
175 fDataLoaders->AddAt(dl,kTracks);
176
177 // R E C O N S T R U C T E D P O I N T S aka C L U S T E R S
178 dl = new AliDataLoader(fDetectorName + ".RecParticles.root",fgkDefaultRecParticlesContainerName, "Reconstructed Particles");
179 tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetPIDTaskName(),
180 dl,AliRunLoader::GetRunPIDTask(),kTRUE);
181 dl->SetBaseTaskLoader(tl);
182 fDataLoaders->AddAt(dl,kRecParticles);
183
184 }
185/*****************************************************************************/
186
187AliDataLoader* AliLoader::GetDataLoader(const char* name)
188{
189//returns Data Loader with specified name
190 return dynamic_cast<AliDataLoader*>(fDataLoaders->FindObject(name));
191}
192/*****************************************************************************/
deee9e3b 193void AliLoader::AddDataLoader(AliDataLoader* dl)
194{
195
196 if (dl == 0x0)
197 {
198 Error("AddDataLoader","Pointer is NULL");
199 return;
200 }
201 if (fDataLoaders->FindObject(dl->GetName()))
202 {
203 Error("AddDataLoader","Such a loader exists");
204 return;
205 }
206 fDataLoaders->AddLast(dl);
207 dl->SetEventFolder(fEventFolder);
208 dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
209}
210/*****************************************************************************/
88cb7938 211
212Int_t AliLoader::SetEvent()
213{
214 //basically the same that GetEvent but do not post data to folders
215 TIter next(fDataLoaders);
216 AliDataLoader* dl;
217 while ((dl = (AliDataLoader*)next()))
218 {
219 dl->SetEvent();
220 }
221 return 0;
222}
223/******************************************************************/
224
1bb20a37 225void AliLoader::UnloadAll()
226{
227 //calls UnloadAll for all base laoders
228 //Unloads everything
229 TIter next(fDataLoaders);
230 AliDataLoader* dl;
231 while ((dl = (AliDataLoader*)next()))
232 {
233 dl->UnloadAll();
234 }
235}
236/******************************************************************/
237
88cb7938 238Int_t AliLoader::GetEvent()
239{
240 //changes to proper root directory and tries to load data from files to folders
241 // event number is defined in RunLoader
242 //
243 //returns:
244 // 0 - in case of no error
245 // 1 - event not found
246 //
247
248 Int_t retval;
249 TIter next(fDataLoaders);
250 AliDataLoader* dl;
251 while ((dl = (AliDataLoader*)next()))
252 {
253 retval = dl->GetEvent();
254 if (retval)
255 {
256 Error("GetEvent","Error occured while GetEvent for %s",dl->GetName());
257 return retval;
258 }
259 }
260
261 return 0;
262}
263
264/******************************************************************/
265
266TFolder* AliLoader::GetTopFolder()
267{
268//returns TOP aliroot folder, just a simple interface to AliConfig (gives shorter notation)
269 return AliConfig::Instance()->GetTopFolder();
270}
271
272/******************************************************************/
273
274TFolder* AliLoader::GetEventFolder()
275{
276//get EVENT folder (data that are changing from event to event, even in single run)
277 return fEventFolder;
278}
279/******************************************************************/
280TFolder* AliLoader::GetDataFolder()
281{
282//returns the folder speciofic to given detector e.g. /Folders/Event/Data/
283 if (!fDataFolder)
284 {
285 fDataFolder = dynamic_cast<TFolder*>(GetEventFolder()->FindObject(AliConfig::fgkDataFolderName));
286
287 if (!fDataFolder)
288 {
289 Fatal("GetDataFolder","Can not find AliRoot data folder. Aborting");
290 return 0x0;
291 }
292 }
293 return fDataFolder;
294}
295
296/*****************************************************************************/
297
298TFolder* AliLoader::GetTasksFolder()
299{
300//Returns pointer to Folder with Alice Tasks
301 if (!fTasksFolder)
302 {
303 fTasksFolder = dynamic_cast<TFolder*>(GetTopFolder()->FindObject(AliConfig::fgkTasksFolderName));
304
305 if (!fTasksFolder)
306 {
307 Fatal("GetTasksFolder","Can not find tasks folder. Aborting");
308 return 0x0;
309 }
310 }
311 return fTasksFolder;
312
313}
314/*****************************************************************************/
315
316TFolder* AliLoader::GetModulesFolder()
317{
d0d4a6b3 318 //returns pointer to the folder containing modules
88cb7938 319 if (!fModuleFolder)
320 {
321 fModuleFolder = dynamic_cast<TFolder*>(GetEventFolder()->FindObjectAny(AliConfig::GetModulesFolderName()));
322
323 if (!fModuleFolder)
324 {
325 Fatal("GetModulesFolder","Can not find modules folder. Aborting");
326 return 0x0;
327 }
328 }
329 return fModuleFolder;
330
331}
332/*****************************************************************************/
333
334TFolder* AliLoader::GetQAFolder()
335{
336 //returns folder with Quality assurance
337 if (fQAFolder == 0x0)
338 {
339 TObject *obj = GetEventFolder()->FindObjectAny(AliConfig::Instance()->GetQAFolderName());
340 fQAFolder = (obj)?dynamic_cast<TFolder*>(obj):0x0;
341
342 if (fQAFolder == 0x0)
343 {
344 Fatal("GetQAFolder","Can not find Quality Assurance folder. Aborting");
345 return 0x0;
346 }
347 }
348 return fQAFolder;
349
350}
351/*****************************************************************************/
d0d4a6b3 352TTask* AliLoader::SDigitizer() const
88cb7938 353{
354//returns SDigitizer task for this detector
355 return GetSDigitsDataLoader()->GetBaseTaskLoader()->Task();
356
357}
358/*****************************************************************************/
359
d0d4a6b3 360AliDigitizer* AliLoader::Digitizer() const
88cb7938 361{
362//returns Digitizer task for this detector
363 return dynamic_cast<AliDigitizer*>(GetDigitsDataLoader()->GetBaseTaskLoader()->Task());
364}
365/*****************************************************************************/
366
d0d4a6b3 367TTask* AliLoader::Reconstructioner() const
88cb7938 368{
369//returns Recontructioner (Cluster Finder, Cluster Maker,
370//or whatever you want to call it) task for this detector
371 return GetRecPointsDataLoader()->GetBaseTaskLoader()->Task();
372}
373/*****************************************************************************/
374
d0d4a6b3 375TTask* AliLoader::Tracker() const
88cb7938 376{
377//returns tracker
378 return dynamic_cast<TTask*>(GetTracksDataLoader()->GetBaseTaskLoader()->Task());
379}
380
381/*****************************************************************************/
d0d4a6b3 382TTask* AliLoader::PIDTask() const
88cb7938 383{
384//returns tracker
385 return dynamic_cast<TTask*>(GetRecParticlesDataLoader()->GetBaseTaskLoader()->Task());
386}
387
388/*****************************************************************************/
389
d0d4a6b3 390TTask* AliLoader::QAtask(const char* name) const
88cb7938 391{
d0d4a6b3 392 // Returns pointer to the quality assurance task
88cb7938 393 TTask* qat = AliRunLoader::GetRunQATask();
394 if ( qat == 0x0 )
395 {
396 Error("QAtask","Can not get RunQATask. (Name:%s)",GetName());
397 return 0x0;
398 }
399
400 TString dqatname(fDetectorName + AliConfig::Instance()->GetQATaskName());
401 TTask* dqat = dynamic_cast<TTask*>(qat->GetListOfTasks()->FindObject(dqatname));
402
403 if ( dqat == 0x0 )
404 {
405 Error("QAtask","Can not find QATask in RunQATask for %s",GetDetectorName().Data());
406 return 0x0;
407 }
408
409 if (strlen(name) == 0) return dqat;
410
411 TList* list = dqat->GetListOfTasks();
412
413 TIter it(list) ;
414 TTask * task = 0 ;
415 while((task = static_cast<TTask *>(it.Next()) ))
416 {
417 TString taskname(task->GetName()) ;
418 if(taskname.BeginsWith(name))
419 return task ;
420 }
421 Error("QAtask","Can not find sub-task with name starting with %s in task %s",name,dqat->GetName());
422 return 0x0;
423}
424/*****************************************************************************/
425
426TDirectory* AliLoader::ChangeDir(TFile* file, Int_t eventno)
427{
428//changes the root directory in "file" to "dirname" which corresponds to event 'eventno'
429//in case of success returns the pointer to directory
430//else NULL
431
432 if (file == 0x0)
433 {
434 ::Error("AliLoader::ChangeDir","File is null");
435 return 0x0;
436 }
437 if (file->IsOpen() == kFALSE)
438 {
439 ::Error("AliLoader::ChangeDir","File is not opened");
440 return 0x0;
441 }
442
443 TString dirname("Event");
444 dirname+=eventno;
445 if (AliLoader::fgDebug > 1)
446 ::Info("AliLoader::ChangeDir","Changing Dir to %s in file %s.",dirname.Data(),file->GetName());
447
448 Bool_t result;
449
450 TDirectory* dir = dynamic_cast<TDirectory*>(file->Get(dirname));
451
452 if (dir == 0x0)
453 {
454 if (AliLoader::fgDebug > 1)
455 ::Info("AliLoader::ChangeDir","Can not find directory %s in file %s, creating...",
456 dirname.Data(),file->GetName());
457
458 if (file->IsWritable() == kFALSE)
459 {
460 ::Error("AliLoader::ChangeDir","Can not create directory. File %s in not writable.",
461 file->GetName());
462 return 0x0;
463 }
464
465 TDirectory* newdir = file->mkdir(dirname);
466 if (newdir == 0x0)
467 {
468 ::Error("AliLoader::ChangeDir","Failed to create new directory in file %s.",
469 file->GetName());
470 return 0x0;
471 }
472 result = file->cd(dirname);
473 if (result == kFALSE)
474 {
475 return 0x0;
476 }
477 }
478 else
479 {
480 file->cd();//make a file active
481 file->cd(dirname);//cd event dir
482 }
483
484 return gDirectory;
485}
486/*****************************************************************************/
487
d0d4a6b3 488TString AliLoader::GetUnixDir() const
88cb7938 489 {
490 //This Method will manage jumping through unix directories in case of
491 //run with more events per run than defined in gAlice
492
493 TString dir;
494
495 return dir;
496 }
497/*****************************************************************************/
498/************************************************************/
499
500void AliLoader::MakeTree(Option_t *option)
501 {
502//Makes a tree depending on option
503// H: - Hits
504// D: - Digits
505// S: - Summable Digits
506// R: - Reconstructed Points (clusters)
507// T: - Tracks (tracklets)
508
509 const char *oH = strstr(option,"H");
510 const char *oD = strstr(option,"D");
511 const char *oS = strstr(option,"S");
512 const char *oR = strstr(option,"R");
513 const char *oT = strstr(option,"T");
514 const char *oP = strstr(option,"P");
515
516 if (oH) MakeHitsContainer();
517 if (oD) MakeDigitsContainer();
518 if (oS) MakeSDigitsContainer();
519 if (oR) MakeRecPointsContainer();
520 if (oT) MakeTracksContainer();
521 if (oP) MakeRecParticlesContainer();
522 }
523
524/*****************************************************************************/
9bb30bcb 525Int_t AliLoader::WriteHits(Option_t* opt) const
88cb7938 526 {
d0d4a6b3 527 // Writes hits
88cb7938 528 AliDataLoader* dl = GetHitsDataLoader();
529 Int_t ret = dl->WriteData(opt);
530 return ret;
531 }
532/*****************************************************************************/
533
9bb30bcb 534Int_t AliLoader::WriteSDigits(Option_t* opt) const
88cb7938 535 {
d0d4a6b3 536 // Writes summable digits
88cb7938 537 AliDataLoader* dl = GetSDigitsDataLoader();
538 Int_t ret = dl->WriteData(opt);
539 return ret;
540 }
541
542/*****************************************************************************/
543
9bb30bcb 544Int_t AliLoader::PostSDigitizer(TTask* sdzer) const
88cb7938 545{
d0d4a6b3 546 // Posts sdigitizer
88cb7938 547 return GetSDigitsDataLoader()->GetBaseTaskLoader()->Post(sdzer);
548}
549/*****************************************************************************/
550
9bb30bcb 551Int_t AliLoader::PostDigitizer(AliDigitizer* task) const
88cb7938 552 {
d0d4a6b3 553 // Posts digitizer
88cb7938 554 return GetDigitsDataLoader()->GetBaseTaskLoader()->Post(task);
555 }
556/*****************************************************************************/
557
9bb30bcb 558Int_t AliLoader::PostReconstructioner(TTask* task) const
88cb7938 559 {
d0d4a6b3 560 // Posts Reconstructioner
88cb7938 561 return GetRecPointsDataLoader()->GetBaseTaskLoader()->Post(task);
562 }
563/*****************************************************************************/
564
9bb30bcb 565Int_t AliLoader::PostTracker(TTask* task) const
88cb7938 566 {
d0d4a6b3 567 // Posts a tracker
88cb7938 568 return GetTracksDataLoader()->GetBaseTaskLoader()->Post(task);
569 }
570/*****************************************************************************/
571
9bb30bcb 572Int_t AliLoader::PostPIDTask(TTask* task) const
88cb7938 573 {
d0d4a6b3 574 // Posts particle identification task
88cb7938 575 return GetRecParticlesDataLoader()->GetBaseTaskLoader()->Post(task);
576 }
577/*****************************************************************************/
578
579TObject** AliLoader::GetDetectorDataRef(TObject *obj)
580{
d0d4a6b3 581 // Returns pointer to an entry in the list of folders pointing to "obj"
88cb7938 582 if (obj == 0x0)
583 {
584 return 0x0;
585 }
586 return GetDetectorDataFolder()->GetListOfFolders()->GetObjectRef(obj) ;
587}
588/*****************************************************************************/
589
590TObject** AliLoader::SDigitizerRef()
591{
d0d4a6b3 592 // Returns pointer to a Runloader's task-list entry pointing to SDigitizer
88cb7938 593 TTask* rsd = AliRunLoader::GetRunSDigitizer();
594 if (rsd == 0x0)
595 {
596 return 0x0;
597 }
598 return rsd->GetListOfTasks()->GetObjectRef(SDigitizer());
599}
600/*****************************************************************************/
601
602TObject** AliLoader::DigitizerRef()
603{
d0d4a6b3 604 // Returns pointer to a Runloader's task-list entry pointing to Digitizer
88cb7938 605 TTask* rd = AliRunLoader::GetRunDigitizer();
606 if (rd == 0x0)
607 {
608 return 0x0;
609 }
610 return rd->GetListOfTasks()->GetObjectRef(Digitizer()) ;
611}
612/*****************************************************************************/
613
614TObject** AliLoader::ReconstructionerRef()
615{
d0d4a6b3 616 // Returns pointer to a Runloader's task-list entry pointing to Reconstructioner
88cb7938 617 TTask* rrec = AliRunLoader::GetRunReconstructioner();
618 if (rrec == 0x0)
619 {
620 return 0x0;
621 }
622 return rrec->GetListOfTasks()->GetObjectRef(Reconstructioner());
623}
624/*****************************************************************************/
625
626TObject** AliLoader::TrackerRef()
627{
d0d4a6b3 628 // Returns pointer to a Runloader's task-list entry pointing to Tracker
88cb7938 629 TTask* rrec = AliRunLoader::GetRunTracker();
630 if (rrec == 0x0)
631 {
632 return 0x0;
633 }
634 return rrec->GetListOfTasks()->GetObjectRef(Tracker());
635}
636/*****************************************************************************/
637
638TObject** AliLoader::PIDTaskRef()
639{
d0d4a6b3 640 // Returns pointer to a Runloader's task-list entry pointing to PIDTask
88cb7938 641 TTask* rrec = AliRunLoader::GetRunPIDTask();
642 if (rrec == 0x0)
643 {
644 return 0x0;
645 }
646 return rrec->GetListOfTasks()->GetObjectRef(PIDTask());
647}
648
649/*****************************************************************************/
650void AliLoader::CleanFolders()
651 {
652 //Cleans all posted objects == removes from folders and deletes them
653 TIter next(fDataLoaders);
654 AliDataLoader* dl;
655 while ((dl = (AliDataLoader*)next()))
656 {
657 if (GetDebug()) Info("CleanFolders","name = %s cleaning",dl->GetName());
658 dl->Clean();
659 }
660 }
661/*****************************************************************************/
662
663/*****************************************************************************/
664
665void AliLoader::CleanSDigitizer()
666{
667//removes and deletes detector task from Run Task
668 TTask* task = AliRunLoader::GetRunSDigitizer();
669 if (task == 0x0)
670 {
671 Error("CleanSDigitizer","Can not get RunSDigitizer from folder. Can not clean");
672 return;
673 }
674
675 if (GetDebug()) Info("CleanSDigitizer","Attempting to delete S Digitizer");
676 delete task->GetListOfTasks()->Remove(SDigitizer()); //TTList::Remove does not delete object
677}
678/*****************************************************************************/
679
680void AliLoader::CleanDigitizer()
681{
682//removes and deletes detector task from Run Task
683 TTask* task = AliRunLoader::GetRunDigitizer();
684 if (task == 0x0)
685 {
686 Error("CleanDigitizer","Can not get RunDigitizer from folder. Can not clean");
687 return;
688 }
689
690 if (GetDebug())
691 Info("CleanDigitizer","Attempting to delete Digitizer %X",
692 task->GetListOfTasks()->Remove(Digitizer()));
693 delete task->GetListOfTasks()->Remove(Digitizer()); //TTList::Remove does not delete object
694}
695/*****************************************************************************/
696
697void AliLoader::CleanReconstructioner()
698{
699//removes and deletes detector Reconstructioner from Run Reconstructioner
700 TTask* task = AliRunLoader::GetRunReconstructioner();
701 if (task == 0x0)
702 {
703 Error("CleanReconstructioner","Can not get RunReconstructioner from folder. Can not clean");
704 return;
705 }
706
707 if (GetDebug())
708 Info("CleanReconstructioner","Attempting to delete Reconstructioner");
709 delete task->GetListOfTasks()->Remove(Reconstructioner()); //TTList::Remove does not delete object
710}
711/*****************************************************************************/
712
713void AliLoader::CleanTracker()
714{
715//removes and deletes detector tracker from Run Tracker
716 TTask* task = AliRunLoader::GetRunTracker();
717 if (task == 0x0)
718 {
719 Error("CleanTracker","Can not get RunTracker from folder. Can not clean");
720 return;
721 }
722
723 if (GetDebug())
724 Info("CleanTracker","Attempting to delete Tracker %X",
725 task->GetListOfTasks()->Remove(Tracker()));
726 delete task->GetListOfTasks()->Remove(Tracker()); //TTList::Remove does not delete object
727}
728/*****************************************************************************/
729
730void AliLoader::CleanPIDTask()
731{
732//removes and deletes detector Reconstructioner from Run Reconstructioner
733 TTask* task = AliRunLoader::GetRunPIDTask();
734 if (task == 0x0)
735 {
736 Error("CleanPIDTask","Can not get Run PID Task from folder. Can not clean");
737 return;
738 }
739
740 if (GetDebug())
741 Info("CleanPIDTask","Attempting to delete PID Task");
742 delete task->GetListOfTasks()->Remove(PIDTask()); //TTList::Remove does not delete object
743}
744/*****************************************************************************/
745
746Int_t AliLoader::ReloadAll()
747{
d0d4a6b3 748 // Calling Reload function for all the data loaders
88cb7938 749 TIter next(fDataLoaders);
750 AliDataLoader* dl;
751
752 while((dl = (AliDataLoader*)next()))
753 {
754 Int_t err = dl->Reload();
755 if (err)
756 {
757 Error("ReloadAll","Reload returned error for %s",dl->GetName());
758 return err;
759 }
760 }
761 return 0;
762}
763/*****************************************************************************/
764
765void AliLoader::CloseFiles()
766{
767//close files for data loaders
768 TIter next(fDataLoaders);
769 AliDataLoader* dl;
770 while((dl = (AliDataLoader*)next()))
771 {
772 dl->CloseFile();
773 }
774}
775/*****************************************************************************/
776
777Int_t AliLoader::SetEventFolder(TFolder* eventfolder)
778{
d0d4a6b3 779 //sets the event folder
88cb7938 780 if (eventfolder == 0x0)
781 {
782 Error("SetEventFolder","Stupid joke. Argument is NULL");
783 return 1;
784 }
785
786 fEventFolder = eventfolder;
787 TIter next(fDataLoaders);
788 AliDataLoader* dl;
789
790 while((dl = (AliDataLoader*)next()))
791 {
792 dl->SetEventFolder(fEventFolder);
793 dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
794 }
795
796 return 0;
797}//sets the event folder
798/*****************************************************************************/
799
800Int_t AliLoader::Register(TFolder* eventFolder)
801{
802//triggers creation of subfolders for a given detector
803//this method is called when session is read from disk
804//
805//warning: AliDetector in constructor (not default) calls
806//creation of folder structure as well (some detectors needs folders
807//alrady in constructors)
808
809 if (GetDebug()) Info("Register","Name is %s.",GetName());
810 if (eventFolder == 0x0)
811 {
812 Error("Register","Event folder is not set.");
813 return 1;
814 }
815 Int_t retval = AliConfig::Instance()->AddDetector(eventFolder,fDetectorName,fDetectorName);
816 if(retval)
817 {
818 Error("SetEventFolder","Can not create tasks and/or folders for %s. Event folder name is %s",
819 fDetectorName.Data(),eventFolder->GetName());
820 return retval;
821 }
822 SetEventFolder(eventFolder);
823 return 0;
824}
825/*****************************************************************************/
826AliRunLoader* AliLoader::GetRunLoader()
827{
828//gets the run-loader from event folder
829 AliRunLoader* rg = 0x0;
830 TObject * obj = GetEventFolder()->FindObject(AliRunLoader::fgkRunLoaderName);
831 if (obj) rg = dynamic_cast<AliRunLoader*>(obj);
832 return rg;
833}
834/*****************************************************************************/
835Bool_t AliLoader::TestFileOption(Option_t* opt)
836{
837//tests the TFile::Option
838//if file is truncated at opening moment ("recreate", "new" or "create") returns kFALSE;
839//else kTRUE (means opened with "read" or "update" mode)
840 TString option(opt);
841 if (option.CompareTo("recreate",TString::kIgnoreCase) == 0) return kFALSE;
842 if (option.CompareTo("new",TString::kIgnoreCase) == 0) return kFALSE;
843 if (option.CompareTo("create",TString::kIgnoreCase) == 0) return kFALSE;
844 return kTRUE;
845}
846/*****************************************************************************/
847void AliLoader::SetDirName(TString& dirname)
848{
849//adds "dirname/" to each file
850 TIter next(fDataLoaders);
851 AliDataLoader* dl;
852 while((dl = (AliDataLoader*)next()))
853 {
854 dl->SetDirName(dirname);
855 }
856}
857
858/*****************************************************************************/
859
9bb30bcb 860void AliLoader::SetDigitsFileNameSuffix(const TString& suffix) const
88cb7938 861{
862 //adds the suffix before ".root",
863 //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
864 //made on Jiri Chudoba demand
865 GetDigitsDataLoader()->SetFileNameSuffix(suffix);
866}
867/*****************************************************************************/
868
869void AliLoader::SetCompressionLevel(Int_t cl)
870{
871//sets comression level for data defined by di
872 TIter next(fDataLoaders);
873 AliDataLoader* dl;
874 while((dl = (AliDataLoader*)next()))
875 {
876 dl->SetCompressionLevel(cl);
877 }
878}
879/*****************************************************************************/
880
881void AliLoader::Clean()
882{
883//Cleans all data loaders
884 TIter next(fDataLoaders);
885 AliDataLoader* dl;
886 while((dl = (AliDataLoader*)next()))
887 {
888 dl->Clean();
889 }
890}
891/*****************************************************************************/
892
893void AliLoader::Clean(const TString& name)
894{
d0d4a6b3 895 // Removes object with "name" from the detector's data folder
896 // and from the memory
88cb7938 897 TObject* obj = GetDetectorDataFolder()->FindObject(name);
898 if(obj)
899 {
900 if (GetDebug())
901 Info("Clean(const TString&)","name=%s, cleaning %s.",GetName(),name.Data());
902 GetDetectorDataFolder()->Remove(obj);
903 delete obj;
904 }
905}
906
907/*****************************************************************************/
908
909Bool_t AliLoader::IsOptionWritable(const TString& opt)
910{
d0d4a6b3 911 // Returns "true" if the option means also "writable"
88cb7938 912 if (opt.CompareTo("recreate",TString::kIgnoreCase)) return kTRUE;
913 if (opt.CompareTo("new",TString::kIgnoreCase)) return kTRUE;
914 if (opt.CompareTo("create",TString::kIgnoreCase)) return kTRUE;
915 if (opt.CompareTo("update",TString::kIgnoreCase)) return kTRUE;
916 return kFALSE;
917}
918/*****************************************************************************/
919
920void AliLoader::SetTAddrInDet()
921{
922 //calls SetTreeAddress for corresponding detector
923 AliRunLoader* rl = GetRunLoader();
924 if (rl == 0x0) return;
925 AliRun* ar = rl->GetAliRun();
926 if (ar == 0x0) return;
927 AliDetector* det = ar->GetDetector(fDetectorName);
928 if (det == 0x0) return;
929 det->SetTreeAddress();
930}
931/*****************************************************************************/
f0f6f856 932
933void AliLoader::Synchronize()
934{
935 //synchrinizes all writtable files
936 TIter next(fDataLoaders);
937 AliDataLoader* dl;
938 while ((dl = (AliDataLoader*)next()))
939 {
940 dl->Synchronize();
941 }
942
943}
944/*****************************************************************************/
88cb7938 945/*****************************************************************************/
946/*****************************************************************************/
947