prevent running if CDB snapshot setting failed
[u/mrichter/AliRoot.git] / STEER / 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 <TFile.h>
15 #include <TFolder.h>
16 #include <TString.h>
17
18 //AliRoot includes
19 #include "AliConfig.h"
20 #include "AliDetector.h"
21 #include "AliLog.h"
22 #include "AliRun.h"
23 #include "AliRunLoader.h"
24
25 const TString AliLoader::fgkDefaultHitsContainerName("TreeH");
26 const TString AliLoader::fgkDefaultDigitsContainerName = "TreeD";
27 const TString AliLoader::fgkDefaultSDigitsContainerName = "TreeS";
28 const TString AliLoader::fgkDefaultRecPointsContainerName = "TreeR";
29 const TString AliLoader::fgkDefaultTracksContainerName = "TreeT";
30 const TString AliLoader::fgkDefaultRecParticlesContainerName = "TreeP";
31 const TString AliLoader::fgkLoaderBaseName("Loader");
32
33 ClassImp(AliLoader)
34 //___________________________________________________________________
35 /////////////////////////////////////////////////////////////////////
36 //                                                                 //
37 //  class AliLoader                                                //
38 //                                                                 //
39 //  Base class for Loaders.                                        //
40 //  Loader provides base I/O fascilities for "standard" data.      //
41 //  Each detector has a laoder data member                         //
42 //  loader is accessible via folder structure as well              //
43 //                                                                 //
44 /////////////////////////////////////////////////////////////////////
45  
46 /*****************************************************************************/ 
47
48 AliLoader::AliLoader():
49  fDataLoaders(0x0),
50  fDetectorName(""),
51  fEventFolder(0x0),
52  fDataFolder(0x0),
53  fDetectorDataFolder(0x0),
54  fModuleFolder(0x0)
55 {
56   //default constructor
57   
58 }
59 /******************************************************************/
60
61 AliLoader::AliLoader(const Char_t* detname,const Char_t* eventfoldername):
62  fDataLoaders(new TObjArray(kNDataTypes)),
63  fDetectorName(""),
64  fEventFolder(0x0),
65  fDataFolder(0x0),
66  fDetectorDataFolder(0x0),
67  fModuleFolder(0x0)
68 {
69   //ctor
70    AliDebug(1, Form("detname = %s eventfoldername = %s",detname,eventfoldername));
71
72    //try to find folder eventfoldername in top alice folder
73    //safe because GetTopFolder will abort in case of failure
74
75    fDetectorName = detname;
76    fName = fDetectorName+"Loader";
77    InitDefaults();
78
79    TObject* fobj = GetTopFolder()->FindObject(eventfoldername);
80    fEventFolder = (fobj)?dynamic_cast<TFolder*>(fobj):0x0;//in case FindObject returns NULL dynamic cast cause seg. fault
81    SetEventFolder(fEventFolder);
82    
83  }
84 /*****************************************************************************/ 
85
86 AliLoader::AliLoader(const Char_t * detname,TFolder* eventfolder):
87  fDataLoaders(new TObjArray(kNDataTypes)),
88  fDetectorName(detname),
89  fEventFolder(0x0),
90  fDataFolder(0x0),
91  fDetectorDataFolder(0x0),
92  fModuleFolder(0x0)
93 {
94 //constructor
95    fDetectorName = detname;
96    fName = fDetectorName+"Loader";
97    InitDefaults();
98    SetEventFolder(eventfolder);
99    //fileoption's don't need to initialized because default TString ctor does it correctly
100 }
101
102 /*****************************************************************************/ 
103 AliLoader::~AliLoader()
104 {
105 //detructor
106   if (fDataLoaders) fDataLoaders->SetOwner();
107   delete fDataLoaders;
108 }
109 /*****************************************************************************/ 
110
111 void AliLoader::InitDefaults()
112 {
113   // H I T S 
114   AliDataLoader* dl;
115   dl = new AliDataLoader(fDetectorName + ".Hits.root",fgkDefaultHitsContainerName, "Hits" );
116   fDataLoaders->AddAt(dl,kHits);
117   
118   
119   // S U M M A B L E   D I G I T S
120   dl = new AliDataLoader(fDetectorName + ".SDigits.root",fgkDefaultSDigitsContainerName, "Summable Digits");
121   fDataLoaders->AddAt(dl,kSDigits);
122
123   // D I G I T S  
124   dl = new AliDataLoader(fDetectorName + ".Digits.root",fgkDefaultDigitsContainerName, "Digits");
125   fDataLoaders->AddAt(dl,kDigits);
126   
127   // 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 
128   dl = new AliDataLoader(fDetectorName + ".RecPoints.root",fgkDefaultRecPointsContainerName, "Reconstructed Points");
129   fDataLoaders->AddAt(dl,kRecPoints);
130   
131   // T R A C K S
132   dl = new AliDataLoader(fDetectorName + ".Tracks.root",fgkDefaultTracksContainerName, "Tracks");
133   fDataLoaders->AddAt(dl,kTracks);
134   
135   // 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 
136   dl = new AliDataLoader(fDetectorName + ".RecParticles.root",fgkDefaultRecParticlesContainerName, "Reconstructed Particles");
137   fDataLoaders->AddAt(dl,kRecParticles);
138
139  }
140 /*****************************************************************************/ 
141
142 AliDataLoader* AliLoader::GetDataLoader(const char* name)
143 {
144 //returns Data Loader with specified name
145   return dynamic_cast<AliDataLoader*>(fDataLoaders->FindObject(name));
146 }
147 /*****************************************************************************/ 
148 void AliLoader::AddDataLoader(AliDataLoader* dl)
149 {
150   //
151   // Adds a data loader
152   //
153   if (dl == 0x0)
154    {
155      AliError("Pointer is NULL");
156      return;
157    }
158   if (fDataLoaders->FindObject(dl->GetName()))
159    {
160      AliError("Such a loader exists");
161      return;
162    }
163   fDataLoaders->AddLast(dl);
164   dl->SetEventFolder(fEventFolder);
165   dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
166 }
167 /*****************************************************************************/ 
168
169 Int_t AliLoader::SetEvent()
170 {
171  //basically the same that GetEvent but do not post data to folders
172  TIter next(fDataLoaders);
173  AliDataLoader* dl;
174  while ((dl = (AliDataLoader*)next()))
175   {
176     dl->SetEvent();
177   }
178  return 0;
179 }
180 /******************************************************************/
181
182 void AliLoader::UnloadAll()
183 {
184  //calls UnloadAll for all base laoders
185  //Unloads everything
186  TIter next(fDataLoaders);
187  AliDataLoader* dl;
188  while ((dl = (AliDataLoader*)next()))
189   {
190     dl->UnloadAll();
191   }
192 }
193 /******************************************************************/
194
195 Int_t AliLoader::GetEvent()
196 {
197  //changes to proper root  directory and tries to load data from files to folders
198  // event number is defined in RunLoader
199  // 
200  //returns:
201  //     0  - in case of no error
202  //     1  - event not found
203  //     
204  
205  Int_t retval;   
206  TIter next(fDataLoaders);
207  AliDataLoader* dl;
208  while ((dl = (AliDataLoader*)next()))
209   {
210     retval = dl->GetEvent();
211     if (retval)
212      {
213        AliError(Form("Error occured while GetEvent for %s",dl->GetName()));
214        return retval;
215      }
216   }
217
218  return 0;
219 }
220
221 /******************************************************************/
222
223 TFolder* AliLoader::GetTopFolder()
224 {
225 //returns TOP aliroot folder, just a simple interface to AliConfig (gives shorter notation)
226  return AliConfig::Instance()->GetTopFolder();
227 }
228
229 /******************************************************************/
230
231 TFolder* AliLoader::GetEventFolder()
232 {
233 //get EVENT folder (data that are changing from event to event, even in single run)
234   return fEventFolder;
235 }
236 /******************************************************************/
237 TFolder* AliLoader::GetDataFolder()
238 {
239 //returns the folder speciofic to given detector e.g. /Folders/Event/Data/
240  if (!fDataFolder)
241   {
242    fDataFolder =  dynamic_cast<TFolder*>(GetEventFolder()->FindObject(AliConfig::Instance()->GetDataFolderName()));
243    
244    if (!fDataFolder)
245     {
246      AliFatal("Can not find AliRoot data folder. Aborting");
247      return 0x0;
248     }
249   }
250   return fDataFolder;
251 }
252
253 /*****************************************************************************/ 
254
255 TFolder* AliLoader::GetModulesFolder()
256 {
257   //returns pointer to the folder containing modules
258  if (!fModuleFolder)
259   {
260    fModuleFolder =  dynamic_cast<TFolder*>(GetEventFolder()->FindObjectAny(AliConfig::GetModulesFolderName()));
261    
262    if (!fModuleFolder)
263     {
264      AliFatal("Can not find modules folder. Aborting");
265      return 0x0;
266     }
267   }
268  return fModuleFolder;
269    
270 }
271
272 /*****************************************************************************/ 
273
274 TDirectory* AliLoader::ChangeDir(TFile* file, Int_t eventno)
275 {
276 //changes the root directory in "file" to "dirname" which corresponds to event 'eventno'
277 //in case of success returns the pointer to directory
278 //else NULL
279  
280  if (file == 0x0)
281   {
282     AliErrorClass("File is null");
283     return 0x0;
284   }
285  if (file->IsOpen() == kFALSE)
286   {
287     AliErrorClass("File is not opened");
288     return 0x0;
289   }
290
291  TString dirname("Event");
292  dirname+=eventno;
293  AliDebugClass(1, Form("Changing Dir to %s in file %s.",dirname.Data(),file->GetName()));
294
295  Bool_t result;
296  
297  TDirectory* dir = dynamic_cast<TDirectory*>(file->Get(dirname));
298
299  if (dir == 0x0)
300   {
301     AliDebugClass(1, Form("Can not find directory %s in file %s, creating...",
302                      dirname.Data(),file->GetName()));
303     
304     if (file->IsWritable() == kFALSE)
305      {
306        AliErrorClass(Form("Can not create directory. File %s in not writable.",
307                      file->GetName()));
308        return 0x0;
309      }
310             
311     TDirectory* newdir = file->mkdir(dirname);
312     if (newdir == 0x0)
313      {
314        AliErrorClass(Form("Failed to create new directory in file %s.",
315                      file->GetName()));
316        return 0x0;
317      }
318     result = file->cd(dirname);
319     if (result == kFALSE)
320      {
321        return 0x0;
322      }
323   }
324  else
325   {
326    file->cd();//make a file active 
327    file->cd(dirname);//cd event dir
328   }
329
330  return gDirectory;
331 }
332 /*****************************************************************************/ 
333
334 TString AliLoader::GetUnixDir() const
335  {
336  //This Method will manage jumping through unix directories in case of 
337  //run with more events per run than defined in gAlice
338  
339    TString dir;
340    
341    return dir;
342  }
343 /*****************************************************************************/ 
344 /************************************************************/
345
346 void AliLoader::MakeTree(Option_t *option)
347  {
348 //Makes a tree depending on option 
349 //   H: - Hits
350 //   D: - Digits
351 //   S: - Summable Digits
352 //   R: - Reconstructed Points (clusters)
353 //   T: - Tracks (tracklets)
354
355   const char *oH = strstr(option,"H");
356   const char *oD = strstr(option,"D");
357   const char *oS = strstr(option,"S");
358   const char *oR = strstr(option,"R");
359   const char *oT = strstr(option,"T");
360   const char *oP = strstr(option,"P");
361   
362   if (oH) MakeHitsContainer();
363   if (oD) MakeDigitsContainer();
364   if (oS) MakeSDigitsContainer();
365   if (oR) MakeRecPointsContainer();
366   if (oT) MakeTracksContainer();
367   if (oP) MakeRecParticlesContainer();
368  }
369
370 /*****************************************************************************/ 
371 Int_t  AliLoader::WriteHits(Option_t* opt) const
372  {
373    // Writes hits
374    AliDataLoader* dl = GetHitsDataLoader();
375    Int_t ret = dl->WriteData(opt);
376    return ret;
377  }
378 /*****************************************************************************/ 
379
380 Int_t AliLoader::WriteSDigits(Option_t* opt) const
381  {
382    // Writes summable digits
383    AliDataLoader* dl = GetSDigitsDataLoader();
384    Int_t ret = dl->WriteData(opt);
385    return ret;
386  }
387  
388 /*****************************************************************************/ 
389
390 TObject** AliLoader::GetDetectorDataRef(TObject *obj)
391 {
392   // Returns pointer to an entry in the list of folders pointing to "obj"
393  if (obj == 0x0)
394   {
395     return 0x0;
396   }
397  return GetDetectorDataFolder()->GetListOfFolders()->GetObjectRef(obj) ;
398 }
399
400 /*****************************************************************************/ 
401 void AliLoader::CleanFolders()
402  {
403  //Cleans all posted objects == removes from folders and deletes them
404    TIter next(fDataLoaders);
405    AliDataLoader* dl;
406    while ((dl = (AliDataLoader*)next()))
407     { 
408       AliDebug(1, Form("name = %s cleaning",dl->GetName()));
409       dl->Clean();
410     }
411  }
412
413 /*****************************************************************************/ 
414
415 Int_t AliLoader::ReloadAll()
416 {
417   // Calling Reload function for all the data loaders
418  TIter next(fDataLoaders);
419  AliDataLoader* dl;
420  
421  while((dl = (AliDataLoader*)next()))
422   {
423    Int_t err = dl->Reload();
424    if (err)
425     {
426       AliError(Form("Reload returned error for %s",dl->GetName()));
427       return err;
428     }
429   }
430  return 0;
431 }
432 /*****************************************************************************/ 
433
434 void AliLoader::CloseFiles()
435 {
436 //close files for data loaders
437  TIter next(fDataLoaders);
438  AliDataLoader* dl;
439  while((dl = (AliDataLoader*)next()))
440   {
441    dl->CloseFile();
442   }
443 }
444 /*****************************************************************************/ 
445
446 Int_t  AliLoader::SetEventFolder(TFolder* eventfolder)
447 {
448   //sets the event folder
449  if (eventfolder == 0x0)
450   {
451     AliError("Stupid joke. Argument is NULL");
452     return 1;
453   }
454
455  fEventFolder = eventfolder;
456  TIter next(fDataLoaders);
457  AliDataLoader* dl;
458  
459  while((dl = (AliDataLoader*)next()))
460   {
461     dl->SetEventFolder(fEventFolder);
462     dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
463   }
464
465  return 0;
466 }//sets the event folder
467 /*****************************************************************************/ 
468
469 Int_t AliLoader::Register(TFolder* eventFolder)
470 {
471 //triggers creation of subfolders for a given detector
472 //this method is called when session is read from disk
473 //
474 //warning: AliDetector in constructor (not default) calls
475 //creation of folder structure as well (some detectors needs folders 
476 //alrady in constructors)
477
478  AliDebug(1, Form("Name is %s.",GetName()));
479  if (eventFolder == 0x0)
480   {
481     AliError("Event folder is not set.");
482     return 1;
483   }
484  Int_t retval = AliConfig::Instance()->AddDetector(eventFolder,fDetectorName,fDetectorName);
485  if(retval)
486   {
487     AliError(Form("Can not create folders for %s. Event folder name is %s",
488                   fDetectorName.Data(),eventFolder->GetName()));
489     return retval;
490   }
491  SetEventFolder(eventFolder);
492  return 0;
493 }
494 /*****************************************************************************/ 
495 AliRunLoader* AliLoader::GetRunLoader()
496 {
497 //gets the run-loader from event folder
498   AliRunLoader* rg = 0x0;
499   TObject * obj = GetEventFolder()->FindObject(AliRunLoader::GetRunLoaderName());
500   if (obj) rg = dynamic_cast<AliRunLoader*>(obj);
501   return rg;
502 }
503 /*****************************************************************************/ 
504 Bool_t  AliLoader::TestFileOption(Option_t* opt)
505 {
506 //tests the TFile::Option
507 //if file is truncated at opening moment ("recreate", "new" or "create") returns kFALSE;
508 //else kTRUE (means opened with "read" or "update" mode)
509   TString option(opt);
510   if (option.CompareTo("recreate",TString::kIgnoreCase) == 0) return kFALSE;
511   if (option.CompareTo("new",TString::kIgnoreCase) == 0) return kFALSE;
512   if (option.CompareTo("create",TString::kIgnoreCase) == 0) return kFALSE;
513   return kTRUE;
514 }
515 /*****************************************************************************/ 
516 void  AliLoader::SetDirName(TString& dirname)
517 {
518 //adds "dirname" to each file. Dirname should end with "#","/", or ":" 
519   TIter next(fDataLoaders);
520   AliDataLoader* dl;
521   while((dl = (AliDataLoader*)next()))
522    {
523     dl->SetDirName(dirname);
524    }
525 }
526
527 /*****************************************************************************/ 
528
529 void AliLoader::SetDigitsFileNameSuffix(const TString& suffix) const
530 {
531   //adds the suffix before ".root", 
532   //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
533   //made on Jiri Chudoba demand
534   GetDigitsDataLoader()->SetFileNameSuffix(suffix);
535 }
536 /*****************************************************************************/ 
537
538 void AliLoader::SetCompressionLevel(Int_t cl)
539 {
540 //sets comression level for data defined by di
541   TIter next(fDataLoaders);
542   AliDataLoader* dl;
543   while((dl = (AliDataLoader*)next()))
544    {
545      dl->SetCompressionLevel(cl);
546    }
547 }
548 /*****************************************************************************/ 
549
550 void AliLoader::Clean()
551 {
552 //Cleans all data loaders
553   TIter next(fDataLoaders);
554   AliDataLoader* dl;
555   while((dl = (AliDataLoader*)next()))
556    {
557      dl->Clean();
558    }
559 }
560 /*****************************************************************************/
561
562 void AliLoader::Clean(const TString& name)
563 {
564   // Removes object with "name" from the detector's data folder
565   // and from the memory
566   TObject* obj = GetDetectorDataFolder()->FindObject(name);
567   if(obj)
568    {
569      AliDebug(1, Form("name=%s, cleaning %s.",GetName(),name.Data()));
570      GetDetectorDataFolder()->Remove(obj);
571      delete obj;
572    }
573 }
574
575 /*****************************************************************************/ 
576
577 Bool_t AliLoader::IsOptionWritable(const TString& opt)
578 {
579   // Returns "true" if the option means also "writable"
580   if (opt.CompareTo("recreate",TString::kIgnoreCase)) return kTRUE;
581   if (opt.CompareTo("new",TString::kIgnoreCase)) return kTRUE;
582   if (opt.CompareTo("create",TString::kIgnoreCase)) return kTRUE;
583   if (opt.CompareTo("update",TString::kIgnoreCase)) return kTRUE;
584   return kFALSE;
585 }
586
587 /*****************************************************************************/ 
588
589 void AliLoader::SetDebug(Int_t deb)
590 {
591   // Sets debug level
592   AliLog::SetClassDebugLevel("AliRunLoader", deb);
593   AliLog::SetClassDebugLevel("AliLoader", deb);
594   AliLog::SetClassDebugLevel("AliDataLoader", deb);
595   AliLog::SetClassDebugLevel("AliBaseLoader", deb);
596   AliLog::SetClassDebugLevel("AliObjectLoader", deb);
597   AliLog::SetClassDebugLevel("AliTreeLoader", deb);
598   AliLog::SetClassDebugLevel("AliConfig", deb);
599 }
600 /*****************************************************************************/ 
601
602 void AliLoader::SetTAddrInDet()
603 {
604   //calls SetTreeAddress for corresponding detector
605   AliRunLoader* rl = GetRunLoader();   
606   if (rl == 0x0) return;
607   AliRun* ar = rl->GetAliRun();
608   if (ar == 0x0) return;
609   AliDetector* det = ar->GetDetector(fDetectorName);  
610   if (det == 0x0) return;
611   det->SetTreeAddress();
612 }
613 /*****************************************************************************/ 
614
615 void AliLoader::Synchronize()
616 {
617   //synchrinizes all writtable files 
618  TIter next(fDataLoaders);
619  AliDataLoader* dl;
620  while ((dl = (AliDataLoader*)next()))
621   {
622     dl->Synchronize();
623   }
624   
625 }
626 /*****************************************************************************/ 
627 /*****************************************************************************/ 
628 /*****************************************************************************/ 
629