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