Changes suggested by Effective C++ (F.Carminati)
[u/mrichter/AliRoot.git] / STEER / AliLoader.cxx
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
30 const TString AliLoader::fgkDefaultHitsContainerName("TreeH");
31 const TString AliLoader::fgkDefaultDigitsContainerName = "TreeD";
32 const TString AliLoader::fgkDefaultSDigitsContainerName = "TreeS";
33 const TString AliLoader::fgkDefaultRecPointsContainerName = "TreeR";
34 const TString AliLoader::fgkDefaultTracksContainerName = "TreeT";
35 const TString AliLoader::fgkDefaultRecParticlesContainerName = "TreeP";
36 const TString AliLoader::fgkLoaderBaseName("Loader");
37
38 ClassImp(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
53 AliLoader::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
68 AliLoader::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
95 AliLoader::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 /*****************************************************************************/ 
113 AliLoader::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 /*****************************************************************************/ 
132 AliLoader& 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 /*****************************************************************************/ 
141 AliLoader::~AliLoader()
142 {
143 //detructor
144   if (fDataLoaders) fDataLoaders->SetOwner();
145   delete fDataLoaders;
146 }
147 /*****************************************************************************/ 
148
149 void 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
195 AliDataLoader* AliLoader::GetDataLoader(const char* name)
196 {
197 //returns Data Loader with specified name
198   return dynamic_cast<AliDataLoader*>(fDataLoaders->FindObject(name));
199 }
200 /*****************************************************************************/ 
201 void 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
222 Int_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
235 void 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
248 Int_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
276 TFolder* 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
284 TFolder* AliLoader::GetEventFolder()
285 {
286 //get EVENT folder (data that are changing from event to event, even in single run)
287   return fEventFolder;
288 }
289 /******************************************************************/
290 TFolder* 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
308 TFolder* 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
326 TFolder* 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
344 TFolder* 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 /*****************************************************************************/ 
362 TTask* AliLoader::SDigitizer() const
363 {
364 //returns SDigitizer task for this detector
365   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Task();
366
367 }
368 /*****************************************************************************/ 
369
370 AliDigitizer* AliLoader::Digitizer() const
371 {
372 //returns Digitizer task for this detector
373   return dynamic_cast<AliDigitizer*>(GetDigitsDataLoader()->GetBaseTaskLoader()->Task());
374 }
375 /*****************************************************************************/ 
376
377 TTask* 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
385 TTask* AliLoader::Tracker() const
386 {
387 //returns tracker
388   return dynamic_cast<TTask*>(GetTracksDataLoader()->GetBaseTaskLoader()->Task());
389 }
390
391 /*****************************************************************************/ 
392 TTask* AliLoader::PIDTask() const
393 {
394 //returns tracker
395   return dynamic_cast<TTask*>(GetRecParticlesDataLoader()->GetBaseTaskLoader()->Task());
396 }
397
398 /*****************************************************************************/ 
399
400 TTask* 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
436 TDirectory* 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
496 TString 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
508 void 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 /*****************************************************************************/ 
533 Int_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
542 Int_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
552 Int_t AliLoader::PostSDigitizer(TTask* sdzer) const
553 {
554   // Posts sdigitizer
555   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Post(sdzer);
556 }
557 /*****************************************************************************/ 
558
559 Int_t AliLoader::PostDigitizer(AliDigitizer* task) const
560  {
561    // Posts digitizer
562   return GetDigitsDataLoader()->GetBaseTaskLoader()->Post(task);
563  }
564 /*****************************************************************************/ 
565
566 Int_t AliLoader::PostReconstructioner(TTask* task) const
567  {
568    // Posts Reconstructioner
569   return GetRecPointsDataLoader()->GetBaseTaskLoader()->Post(task);
570  }
571 /*****************************************************************************/ 
572
573 Int_t AliLoader::PostTracker(TTask* task) const
574  {
575    // Posts a tracker
576   return GetTracksDataLoader()->GetBaseTaskLoader()->Post(task);
577  }
578 /*****************************************************************************/ 
579
580 Int_t AliLoader::PostPIDTask(TTask* task) const
581  {
582   // Posts particle identification task
583   return GetRecParticlesDataLoader()->GetBaseTaskLoader()->Post(task);
584  }
585 /*****************************************************************************/ 
586
587 TObject** 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
598 TObject** 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
610 TObject** 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
622 TObject** 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
634 TObject** 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
646 TObject** 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 /*****************************************************************************/ 
658 void 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
673 void 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
685 void 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
697 void 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
709 void 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
721 void 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
734 Int_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
753 void 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
765 Int_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
788 Int_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 /*****************************************************************************/ 
814 AliRunLoader* 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 /*****************************************************************************/ 
823 Bool_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 /*****************************************************************************/ 
835 void  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
848 void 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
857 void 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
869 void 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
881 void 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
896 Bool_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
907 Int_t AliLoader::GetDebug()
908 {
909   AliWarningClass("Don't use this method any more, use AliDebug instead");
910   return AliDebugLevelClass();
911 }
912 /*****************************************************************************/ 
913
914 void 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
928 void 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
941 void 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