]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliDataLoader.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
reduce printout
[u/mrichter/AliRoot.git] / STEER / AliDataLoader.cxx
CommitLineData
88cb7938 1#include <AliDataLoader.h>
2//__________________________________________
3/////////////////////////////////////////////////////////////////////////////////////////////
4// //
5// class AliDataLoader //
6// //
7// Container of all data needed for full //
8// description of each data type //
9// (Hits, Kine, ...) //
10// //
11// Each data loader has a basic standard setup of BaseLoaders //
12// which can be identuified by indexes (defined by EStdBasicLoaders) //
13// Data managed by these standard base loaders has fixed naming convention //
14// e.g. - tree with hits is always named TreeH //
15// (defined in AliLoader::fgkDefaultHitsContainerName) //
16// - task DtectorName+Name defined //
17// //
18// EStdBasicLoaders idx Object Type Description //
19// kData 0 TTree or TObject main data itself (hits,digits,...) //
20// kTask 1 TTask object producing main data //
21// kQA 2 TTree quality assurance tree //
22// kQATask 3 TTask task producing QA object //
23// //
24// //
25// User can define and add more basic loaders even Run Time. //
26// Caution: in order to save information about added base loader //
27// user must rewrite Run Loader to galice.file, overwriting old setup //
28// //
29/////////////////////////////////////////////////////////////////////////////////////////////
30
31#include <TROOT.h>
32#include <TFile.h>
33#include <TString.h>
34#include <TBits.h>
88cb7938 35
36#include "AliRunLoader.h"
37
38ClassImp(AliDataLoader)
39
40AliDataLoader::AliDataLoader():
41 fFileName(0),
42 fFile(0x0),
43 fDirectory(0x0),
44 fFileOption(),
45 fCompressionLevel(2),
46 fBaseLoaders(0x0),
47 fHasTask(kFALSE),
48 fTaskName(),
49 fParentalTask(0x0),
50 fEventFolder(0x0),
51 fFolder(0x0)
52{
53
54}
55/*****************************************************************************/
56
57AliDataLoader::AliDataLoader(const char* filename, const char* contname, const char* name, Option_t* opt):
58 TNamed(name,name),
59 fFileName(filename),
60 fFile(0x0),
61 fDirectory(0x0),
62 fFileOption(0),
63 fCompressionLevel(2),
64 fBaseLoaders(new TObjArray(4)),
65 fHasTask(kFALSE),
66 fTaskName(),
67 fParentalTask(0x0),
68 fEventFolder(0x0),
69 fFolder(0x0)
70{
71//constructor
72// creates a 0 loader, depending on option, default "T" is specialized loader for trees
73// else standard object loader
74// trees needs special care, becouse we need to set dir before writing
75 if (GetDebug())
76 Info("AliDataLoader","File name is %s",fFileName.Data());
77
78 TString option(opt);
79 AliBaseLoader* bl;
80 if (option.CompareTo("T",TString::kIgnoreCase) == 0)
81 bl = new AliTreeLoader(contname,this);
82 else
83 bl = new AliObjectLoader(contname,this);
84 fBaseLoaders->AddAt(bl,kData);
85
86}
87/*****************************************************************************/
d0d4a6b3 88AliDataLoader::AliDataLoader(const AliDataLoader& source):TNamed(source) {
89 // copy constructor
90 Fatal("AliDataLoader","Copy constructor not implemented");
91}
92/*****************************************************************************/
93AliDataLoader& AliDataLoader::operator=(const AliDataLoader& /*source*/) {
94 // Assignment operator
95 Fatal("AliDataLoader","Assignment operator not implemented");
96 return *this;
97}
98/*****************************************************************************/
88cb7938 99
100AliDataLoader::~AliDataLoader()
101{
102//dtor
103 UnloadAll();
104}
105/*****************************************************************************/
106
107Int_t AliDataLoader::SetEvent()
108{
109//basically the same that GetEvent but do not post data to folders
110 AliRunLoader* rl = GetRunLoader();
111 if (rl == 0x0)
112 {
113 Error("SetEvent","Can not get RunGettr");
114 return 1;
115 }
116
117 Int_t evno = rl->GetEventNumber();
118
119 TIter next(fBaseLoaders);
120 AliBaseLoader* bl;
121 while ((bl = (AliBaseLoader*)next()))
122 {
123 if (bl->DoNotReload() == kFALSE) bl->Clean();
124 }
125
126 if(fFile)
127 {
128 if (CheckReload())
129 {
130 delete fFile;
131 fFile = 0x0;
132 if (GetDebug()) Info("SetEvent","Reloading new file. File opt is %s",fFileOption.Data());
133 OpenFile(fFileOption);
134 }
135
136 fDirectory = AliLoader::ChangeDir(fFile,evno);
137 if (fDirectory == 0x0)
138 {
139 Error("SetEvent","Can not chage directory in file %s",fFile->GetName());
140 return 1;
141 }
142 }
143 return 0;
144}
145/*****************************************************************************/
146
147Int_t AliDataLoader::GetEvent()
148{
149 // posts all loaded data from files to White Board
150 // event number is defined in RunLoader
151 //
152 //returns:
153 // 0 - in case of no error
154 // 1 - event not found
155 //
156 //for each base laoder post, if was loaded before GetEvent
157
158 //call set event to switch to new directory in file
159
160
161 //post all data that were loaded before
162 // ->SetEvent does not call Unload, but only cleans White Board
163 // such IsLoaded flag stays untached
164
165 if ( AliLoader::TestFileOption(fFileOption) == kTRUE ) //if file is read or update mode try to post
166 { //in other case there is no sense to post: file is new
167 TIter nextbl(fBaseLoaders);
168 AliBaseLoader* bl;
169 while ((bl = (AliBaseLoader*)nextbl()))
170 {
171 if (bl->IsLoaded())
172 {
173 if (bl->DoNotReload() == kFALSE) bl->Post();
174 }
175 }
176 }
177 return 0;
178}
179/*****************************************************************************/
180
181Int_t AliDataLoader::OpenFile(Option_t* opt)
182{
183//Opens file named 'filename', and assigns pointer to it to 'file'
184//jumps to fDirectoryectory corresponding to current event and stores the pointer to it in 'fDirectory'
185//option 'opt' is passed to TFile::Open
186 if (fFile)
187 {
188 if(fFile->IsOpen() == kTRUE)
189 {
190 Warning("OpenFile"," File %s already opened. First close it.",fFile->GetName());
191 return 0;
192 }
193 else
194 {
195 Warning("OpenFile","Pointer to file %s is not null, but file is not opened",
196 fFile->GetName());
197 delete fFile;
198 fFile = 0x0;
199 }
200 }
201
202 TString fname(SetFileOffset(fFileName));
203
204 fFile = (TFile *)(gROOT->GetListOfFiles()->FindObject(fname));
205 if (fFile)
206 {
207 if(fFile->IsOpen() == kTRUE)
208 {
209 Warning("OpenFile","File %s already opened by sombody else. First close it.",
210 fFile->GetName());
211 return 0;
212 }
213 }
214
215 fFileOption = opt;
216 fFile = TFile::Open(fname,fFileOption);//open the file
217 if (fFile == 0x0)
218 {//file is null
219 Error("OpenFile","Can not open file %s",fname.Data());
220 return 1;
221 }
222 if (fFile->IsOpen() == kFALSE)
223 {//file is null
224 Error("OpenFile","Can not open file %s",fname.Data());
225 return 1;
226 }
227
228 fFile->SetCompressionLevel(fCompressionLevel);
229
230 AliRunLoader* rg = GetRunLoader();
231 if (rg == 0x0)
232 {
233 Error("OpenFile","Can not find Run-Loader in folder.");
234 return 2;
235 }
236 Int_t evno = rg->GetEventNumber();
237
238 fDirectory = AliLoader::ChangeDir(fFile,evno);
239 if (fDirectory == 0x0)
240 {
241 Error("OpenFile","Can not chage fDirectory in file %s.",fFile->GetName());
242 return 3;
243 }
244 return 0;
245}
246/*****************************************************************************/
247
248void AliDataLoader::Unload()
249{
250 //unloads main data - shortcut method
251 GetBaseLoader(0)->Unload();
252}
253/*****************************************************************************/
254
255void AliDataLoader::UnloadAll()
256{
257//Unloads all data and tasks
1bb20a37 258 if ( fFile == 0x0 ) return; //nothing loaded
259
88cb7938 260 TIter next(fBaseLoaders);
261 AliBaseLoader* bl;
262 while ((bl = (AliBaseLoader*)next()))
263 {
264 bl->Unload();
265 }
266}
267/*****************************************************************************/
268
269Int_t AliDataLoader::Reload()
270{
271 //Unloads and loads data again
272 if ( fFile == 0x0 ) return 0;
273
274 TBits loaded(fBaseLoaders->GetEntries());
275 TIter next(fBaseLoaders);
276 AliBaseLoader* bl;
277
278 Int_t i = 0;
279 while ((bl = (AliBaseLoader*)next()))
280 {
281 if (bl->IsLoaded())
282 {
283 loaded.SetBitNumber(i++,kTRUE);
284 bl->Unload();
285 }
286 }
287
288 Int_t retval;
289 i = 0;
290 next.Reset();
291 while ((bl = (AliBaseLoader*)next()))
292 {
293 if (loaded.TestBitNumber(i++))
294 {
295 retval = bl->Load(fFileOption);
296 if (retval)
297 {
298 Error("Reload","Error occur while loading %s",bl->GetName());
299 return retval;
300 }
301 }
302 }
303
304
305 return 0;
306 }
307/*****************************************************************************/
308Int_t AliDataLoader::WriteData(Option_t* opt)
309{
310//Writes primary data == first BaseLoader
311 if (GetDebug())
312 Info("WriteData","Writing %s container for %s data. Option is %s.",
313 GetBaseLoader(0)->GetName(),GetName(),opt);
314 return GetBaseLoader(0)->WriteData(opt);
315}
316/*****************************************************************************/
317
318Int_t AliDataLoader::Load(Option_t* opt)
319{
320//Writes primary data == first BaseLoader
321 return GetBaseLoader(0)->Load(opt);
322}
323/*****************************************************************************/
324
325Int_t AliDataLoader::SetEventFolder(TFolder* eventfolder)
326{
327 //sets the event folder
328 if (eventfolder == 0x0)
329 {
330 Error("SetEventFolder","Stupid joke. Argument is NULL");
331 return 1;
332 }
333 if (GetDebug())
334 Info("SetFolder","name = %s Setting Event Folder named %s.",
335 GetName(),eventfolder->GetName());
336
337 fEventFolder = eventfolder;
338 return 0;
339}
340/*****************************************************************************/
341
342Int_t AliDataLoader::SetFolder(TFolder* folder)
343{
d0d4a6b3 344 // Sets the folder and the data loaders
88cb7938 345 if (folder == 0x0)
346 {
347 Error("SetFolder","Stupid joke. Argument is NULL");
348 return 1;
349 }
350
351 if (GetDebug()) Info("SetFolder","name = %s Setting folder named %s.",GetName(),folder->GetName());
352
353 fFolder = folder;
354 TIter next(fBaseLoaders);
355 AliBaseLoader* bl;
356
357 while ((bl = (AliBaseLoader*)next()))
358 {
359 bl->SetDataLoader(this);
360 }
361
362 return 0;
363}
364/******************************************************************/
365
366TFolder* AliDataLoader::GetEventFolder()
367{
368//get EVENT folder (data that are changing from event to event, even in single run)
369 if (GetDebug()) Info("GetEventFolder","EF = %#x");
370 return fEventFolder;
371}
372/*****************************************************************************/
373
374AliRunLoader* AliDataLoader::GetRunLoader()
375{
376//gets the run-loader from event folder
377 AliRunLoader* rg = 0x0;
378 TFolder* ef = GetEventFolder();
379 if (ef == 0x0)
380 {
381 Error("GetRunLoader","Can not get event folder.");
382 return 0;
383 }
024a7e64 384 rg = dynamic_cast<AliRunLoader*>(ef->FindObject(AliRunLoader::GetRunLoaderName()));
88cb7938 385 return rg;
386}
387
388/*****************************************************************************/
389void AliDataLoader::CloseFile()
390{
391 //closes file
392 TIter next(fBaseLoaders);
393 AliBaseLoader* bl;
394 while ((bl = (AliBaseLoader*)next()))
395 {
396 if (bl->IsLoaded()) return;
397 }
398
399 if (GetDebug())
400 Info("CloseFile","Closing and deleting (object) file.");
401
402 delete fFile;
403 fFile = 0x0;
404 fDirectory = 0x0;
405}
406/*****************************************************************************/
407
408void AliDataLoader::Clean()
409{
410 //Cleans main data
411 GetBaseLoader(0)->Clean();
412}
413/*****************************************************************************/
414
415void AliDataLoader::CleanAll()
416{
417 //Cleans all folders and tasks
418 TIter next(fBaseLoaders);
419 AliBaseLoader* bl;
420 while ((bl = (AliBaseLoader*)next()))
421 {
422 bl->Clean();
423 }
424}
425/*****************************************************************************/
426
427void AliDataLoader::SetFileNameSuffix(const TString& suffix)
428{
429 //adds the suffix before ".root",
430 //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
431 //made on Jiri Chudoba demand
432 if (GetDebug())
433 {
434 Info("SetFileNameSuffix","suffix=%s",suffix.Data());
435 Info("SetFileNameSuffix"," Digits File Name before: %s",fFileName.Data());
436 }
437
438 static TString dotroot(".root");
439 const TString& suffixdotroot = suffix + dotroot;
440 fFileName = fFileName.ReplaceAll(dotroot,suffixdotroot);
441
442 if (GetDebug())
443 Info("SetDigitsFileNameSuffix"," after : %s",fFileName.Data());
444}
445/*****************************************************************************/
446
447Bool_t AliDataLoader::CheckReload()
448{
449//checks if we have to reload given file
450 if (fFile == 0x0) return kFALSE;
451 TString tmp = SetFileOffset(fFileName);
452 if (tmp.CompareTo(fFile->GetName())) return kTRUE; //file must be reloaded
453 return kFALSE;
454}
455/*****************************************************************************/
456
457const TString AliDataLoader::SetFileOffset(const TString& fname)
458{
459
460//return fname;
461 Long_t offset = (Long_t)GetRunLoader()->GetFileOffset();
462 if (offset < 1) return fname;
463
464 TString soffset;
465 soffset += offset;//automatic conversion to string
466 TString dotroot(".root");
467 const TString& offfsetdotroot = offset + dotroot;
468 TString out = fname;
469 out = out.ReplaceAll(dotroot,offfsetdotroot);
470 if (GetDebug()) Info("SetFileOffset","in=%s out=%s.",fname.Data(),out.Data());
471 return out;
472
473}
474/*****************************************************************************/
475
476void AliDataLoader::SetFileOption(Option_t* newopt)
477{
478 //sets file option
479 if (fFileOption.CompareTo(newopt) == 0) return;
480 fFileOption = newopt;
481 Reload();
482}
483/*****************************************************************************/
484
485void AliDataLoader::SetCompressionLevel(Int_t cl)
486{
487//sets comression level for data defined by di
488 fCompressionLevel = cl;
489 if (fFile) fFile->SetCompressionLevel(cl);
490}
491/*****************************************************************************/
492
493Int_t AliDataLoader::GetDebug() const
494{
495 //it is not inline bacause AliLoader.h includes AliDataLoaer.h
496 //and there is circular depenedence
497 return AliLoader::GetDebug();
498}
499/*****************************************************************************/
500
501void AliDataLoader::MakeTree()
502{
d0d4a6b3 503 // Makes tree for the current data loader
88cb7938 504 AliTreeLoader* tl = dynamic_cast<AliTreeLoader*>(fBaseLoaders->At(0));
505 if (tl == 0x0)
506 {
507 Error("MakeTree","Can not make a tree because main base loader is not a tree loader");
508 return;
509 }
510 tl->MakeTree();
511}
512/*****************************************************************************/
513
514Bool_t AliDataLoader::IsFileWritable() const
515{
516//returns true if file is writable
517 return (fFile)?fFile->IsWritable():kFALSE;
518}
519/*****************************************************************************/
520
521Bool_t AliDataLoader::IsFileOpen() const
522{
523//returns true if file is writable
524 return (fFile)?fFile->IsOpen():kFALSE;
525}
526/*****************************************************************************/
527
528Bool_t AliDataLoader::IsOptionContrary(const TString& option) const
529{
530//Checks if passed option is contrary with file open option
531//which is passed option "writable" and existing option not wriable
532//in reverse case it is no harm so it is NOT contrary
533 if (fFile == 0x0) return kFALSE; //file is not opened - no problem
534
535 if ( ( AliLoader::IsOptionWritable(option) == kTRUE ) && // passed option is writable and
536 ( AliLoader::IsOptionWritable(fFileOption) == kFALSE ) ) // existing one is not writable
537 {
538 return kTRUE;
539 }
540
541 return kFALSE;
542}
543/*****************************************************************************/
544void AliDataLoader::AddBaseLoader(AliBaseLoader* bl)
545{
546//Adds a base loader to lits of base loaders managed by this data loader
547//Managed data/task will be stored in proper root directory,
548//and posted to
549// - in case of tree/object - data folder connected with detector associated with this data loader
550// - in case of task - parental task which defined in this AliTaskLoader
551
552 if (bl == 0x0)
553 {
554 Warning("AddBaseLoader","Pointer is null.");
555 return;
556 }
557
558 TObject* obj = fBaseLoaders->FindObject(bl->GetName());
559 if (obj)
560 {
561 Error("AddBaseLoader","Can not add this base loader.");
562 Error("AddBaseLoader","There exists already base loader which manages data named %s for this detector.");
563 return;
564 }
565
566
567 fBaseLoaders->Add(bl);
568}
569
570/*****************************************************************************/
571
572AliBaseLoader* AliDataLoader::GetBaseLoader(const TString& name) const
573{
574 return dynamic_cast<AliBaseLoader*>(fBaseLoaders->FindObject(name));
575}
576/*****************************************************************************/
577
578AliBaseLoader* AliDataLoader::GetBaseLoader(Int_t n) const
579{
d0d4a6b3 580 // Gets the n-th base loader (what is n?)
88cb7938 581 return dynamic_cast<AliBaseLoader*>(fBaseLoaders->At(n));
582}
583/*****************************************************************************/
584
585TTree* AliDataLoader::Tree() const
586{
587//returns tree from the main base loader
588//it is just shortcut method for comfort of user
589//main storage object does not have to be Tree -
590//that is why first we need to check if it is a TreeLoader
591 AliTreeLoader* tl = dynamic_cast<AliTreeLoader*>(GetBaseLoader(0));
592 if (tl == 0x0) return 0x0;
593 return tl->Tree();
594}
595/*****************************************************************************/
596
597void AliDataLoader::SetDirName(TString& dirname)
598{
d0d4a6b3 599 // Sets the directory name where the files will be stored
88cb7938 600 if (GetDebug()>9) Info("SetDirName","FileName before %s",fFileName.Data());
601
602 Int_t n = fFileName.Last('/');
603
604 if (GetDebug()>9) Info("SetDirName","Slash found on pos %d",n);
605
606 if (n > 0) fFileName = fFileName.Remove(0,n+1);
607
608 if (GetDebug()>9) Info("SetDirName","Core FileName %s",fFileName.Data());
609
610 fFileName = dirname + "/" + fFileName;
611
612 if (GetDebug()>9) Info("SetDirName","FileName after %s",fFileName.Data());
613}
614/*****************************************************************************/
615AliObjectLoader* AliDataLoader::GetBaseDataLoader()
616{
d0d4a6b3 617 // Gets the base data loader
88cb7938 618 return dynamic_cast<AliObjectLoader*>(GetBaseLoader(kData));
619}
620/*****************************************************************************/
621AliTaskLoader* AliDataLoader::GetBaseTaskLoader()
622{
d0d4a6b3 623 // Gets the base task loader
88cb7938 624 return dynamic_cast<AliTaskLoader*>(GetBaseLoader(kTask));
625}
626/*****************************************************************************/
627AliBaseLoader* AliDataLoader::GetBaseQALoader()
628{
d0d4a6b3 629 // Gets the base QA loader
88cb7938 630 return GetBaseLoader(kQA);
631}
632/*****************************************************************************/
633AliTaskLoader* AliDataLoader::GetBaseQATaskLoader()
634{
635//returns pointer to QA base loader
636 return dynamic_cast<AliTaskLoader*>(GetBaseLoader(kQATask));
637}
638/*****************************************************************************/
639void AliDataLoader::SetBaseDataLoader(AliBaseLoader* bl)
640{
641//sets data base loader
642 if (bl == 0x0)
643 {
644 Error("SetBaseDataLoader","Parameter is null");
645 return;
646 }
647 if (GetBaseDataLoader()) delete GetBaseDataLoader();
648 fBaseLoaders->AddAt(bl,kData);
649}
650/*****************************************************************************/
651void AliDataLoader::SetBaseTaskLoader(AliTaskLoader* bl)
652{
653//sets Task base loader
654 if (bl == 0x0)
655 {
656 Error("SetBaseTaskLoader","Parameter is null");
657 return;
658 }
659 if (GetBaseTaskLoader()) delete GetBaseTaskLoader();
660 fBaseLoaders->AddAt(bl,kTask);
661}
662/*****************************************************************************/
663void AliDataLoader::SetBaseQALoader(AliBaseLoader* bl)
664{
665//sets QA base loader
666 if (bl == 0x0)
667 {
668 Error("SetBaseQALoader","Parameter is null");
669 return;
670 }
671 if (GetBaseQALoader()) delete GetBaseQALoader();
672 fBaseLoaders->AddAt(bl,kQA);
673}
674/*****************************************************************************/
675void AliDataLoader::SetBaseQATaskLoader(AliTaskLoader* bl)
676{
677//sets QA Task base loader
678 if (bl == 0x0)
679 {
680 Error("SetBaseQATaskLoader","Parameter is null");
681 return;
682 }
683 if (GetBaseQATaskLoader()) delete GetBaseQATaskLoader();
684 fBaseLoaders->AddAt(bl,kQATask);
685}
f0f6f856 686void AliDataLoader::Synchronize()
687{
688 //synchrinizes all writtable files
504b172d 689 if ( fFile ) fFile->Flush();
f0f6f856 690}
88cb7938 691
692/*****************************************************************************/
693/*****************************************************************************/
694/*****************************************************************************/
695//__________________________________________
696///////////////////////////////////////////////////////////////////////////////
697// //
698// class AliBaseLoader //
699// //
700// //
701///////////////////////////////////////////////////////////////////////////////
702ClassImp(AliBaseLoader)
703
704AliBaseLoader::AliBaseLoader():
705 fIsLoaded(kFALSE),
706 fStoreInTopOfFile(kFALSE),
707 fDoNotReload(kFALSE),
708 fDataLoader(0x0)
709{
d0d4a6b3 710 //default constructor
88cb7938 711}
712/*****************************************************************************/
713
714AliBaseLoader::AliBaseLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop):
715 TNamed(name,name+" Base Loader"),
716 fIsLoaded(kFALSE),
717 fStoreInTopOfFile(storeontop),
718 fDoNotReload(storeontop),//if stored on top of file - this object is loaded ones pe
719 fDataLoader(dl)
720{
d0d4a6b3 721 //constructor
88cb7938 722}
723
d0d4a6b3 724/*****************************************************************************/
725AliBaseLoader::AliBaseLoader(const AliBaseLoader& source):TNamed(source) {
726 // copy constructor
727 Fatal("AliBaseLoader","Copy constructor not implemented");
728}
729/*****************************************************************************/
730AliBaseLoader& AliBaseLoader::operator=(const AliBaseLoader& /*source*/) {
731 // Assignment operator
732 Fatal("AliBaseLoader","Assignment operator not implemented");
733 return *this;
734}
88cb7938 735/*****************************************************************************/
736
737Int_t AliBaseLoader::Load(Option_t* opt)
738{
d0d4a6b3 739 // Loads and posts the data
88cb7938 740 if (GetDebug())
741 Info("Load","data type = %s, option = %s",GetName(),opt);
742
743 if (Get())
744 {
f82d8b8c 745 if (GetDebug())
746 Warning("Load","Data <<%s>> are already loaded. Use ReloadData to force reload. Nothing done",GetName());
747 return 0;
88cb7938 748 }
749
750 Int_t retval;
751
752 if (GetDataLoader()->IsFileOpen() == kTRUE)
753 {
754 if (GetDataLoader()->IsOptionContrary(opt) == kTRUE)
755 {
756 Error("Load","Data Type %s, Container Name %s", GetDataLoader()->GetName(),GetName());
757 Error("Load","File was already opened in READ-ONLY mode, while now WRITEABLE access is requested.");
758 Error("Load","Use AliDataLoader::SetOption to enforce change of access mode OR");
759 Error("Load","Load previosly loaded data with coherent option.");
760 return 10;
761 }
762 }
763 else
764 {
765 retval = GetDataLoader()->OpenFile(opt);
766 if (retval)
767 {
768 Error("Load","Error occured while opening <<%s>> file",GetName());
769 return retval;
770 }
771 }
772 //if file is recreated there is no sense to search for data to post and get Error message
773 if (AliLoader::TestFileOption(opt) == kFALSE)
774 {
775 AliTreeLoader* tl = dynamic_cast<AliTreeLoader*>(this);
776 if (tl) tl->MakeTree();
777 fIsLoaded = kTRUE;
778 return 0;
779 }
780
781 retval = Post();
782 if (retval)
783 {
784 Error("Load","Error occured while posting %s from file to folder.",GetName());
785 return retval;
786 }
787
788 fIsLoaded = kTRUE;
789 return 0;
790}
791/*****************************************************************************/
792
793Int_t AliBaseLoader::Post()
794{
795//Posts data container to proper folders
796
797 if ( GetDirectory() == 0x0)
798 {
799 Error("Post","%s directory is NULL. Load before.",GetDataLoader()->GetName());
800 return 2;
801 }
802
803 TObject* data = GetFromDirectory(fName);
804 if(data)
805 {
806 //if such an obejct already exists - remove it first
807 return Post(data);
808 }
809 else
810 {
811 //check if file is in update mode
812 Int_t fileupdate = GetDataLoader()->GetFileOption().CompareTo("update",TString::kIgnoreCase);
813 if ( fileupdate == 0)
814 { //if it is, it is normal that there is no data yet
815 if (GetDebug())
816 {
817 Info("Post","Can not find %s in file %s (file is opened in UPDATE mode).",
818 GetName(),GetDataLoader()->GetFile()->GetName());
819 }
820 }
821 else
822 {
c3983217 823 Error("Post","Can not find %s in file %s", GetName(),GetDataLoader()->GetFile()->GetName());
824 return 5;
88cb7938 825 }
826 }
827 return 0;
828}
829/*****************************************************************************/
830
831Int_t AliBaseLoader::Post(TObject* data)
832{
833//Posts data container to proper folders
834 if (data == 0x0)
835 {
836 Error("Post","Pointer to object is NULL");
837 return 1;
838 }
3637d19d 839
840 if ( fName.CompareTo(data->GetName()) != 0)
841 {
842 Fatal("Post(TObject*)","Object name is <<%s>> while <<%s>> expected",data->GetName(),GetName());
843 return -1;//pro forma
844 }
845
88cb7938 846 TObject* obj = Get();
847 if (data == obj)
848 {
849 if (GetDebug()) Warning("Post","This object was already posted.");
850 return 0;
851 }
852 if (obj)
853 {
854 Warning("PostData","Object named %s already exitsts in data folder. Removing it",GetName());
855 Clean();
856 }
857 return AddToBoard(data);
858}
859/*****************************************************************************/
860
861Int_t AliBaseLoader::WriteData(Option_t* opt)
862{
863//Writes data defined by di object
864//opt might be "OVERWRITE" in case of forcing overwriting
865 if (GetDebug())
866 Info("WriteData","Writing %s container for %s data. Option is %s.",
867 GetName(),GetDataLoader()->GetName(),opt);
868
869 TObject *data = Get();
870 if(data == 0x0)
871 {//did not get, nothing to write
872 Warning("WriteData","Tree named %s not found in folder. Nothing to write.",GetName());
873 return 0;
874 }
875
876 //check if file is opened
877 if (GetDirectory() == 0x0)
878 {
879 //if not try to open
880 GetDataLoader()->SetFileOption("UPDATE");
881 if (GetDataLoader()->OpenFile("UPDATE"))
882 {
883 //oops, can not open the file, give an error message and return error code
884 Error("WriteData","Can not open hits file. %s ARE NOT WRITTEN",GetName());
885 return 1;
886 }
887 }
888
889 if (GetDataLoader()->IsFileWritable() == kFALSE)
890 {
891 Error("WriteData","File %s is not writable",GetDataLoader()->GetFileName().Data());
892 return 2;
893 }
894
895 GetDirectory()->cd(); //set the proper directory active
896
897 //see if hits container already exists in this (root) directory
898 TObject* obj = GetFromDirectory(GetName());
899 if (obj)
900 { //if they exist, see if option OVERWRITE is used
901 const char *oOverWrite = strstr(opt,"OVERWRITE");
902 if(!oOverWrite)
903 {//if it is not used - give an error message and return an error code
904 Error("WriteData","Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data");
905 return 3;
906 }
907 }
908
909 if (GetDebug()) Info("WriteData","DataName = %s, opt = %s, data object name = %s",
910 GetName(),opt,data->GetName());
911 if (GetDebug()) Info("WriteData","File Name = %s, Directory Name = %s Directory's File Name = %s",
912 GetDataLoader()->GetFile()->GetName(),GetDirectory()->GetName(),
913 GetDirectory()->GetFile()->GetName());
914
915 if (GetDebug()) Info("WriteData","Writing data");
916 data->Write(0,TObject::kOverwrite);
917
918 fIsLoaded = kTRUE; // Just to ensure flag is on. Object can be posted manually to folder structure, not using loader.
919
920 return 0;
921
922}
923/*****************************************************************************/
924
925Int_t AliBaseLoader::Reload()
926{
927//Unloads and loads datat again - if loaded before
928 if (IsLoaded())
929 {
930 Unload();
931 return Load(GetDataLoader()->GetFileOption());
932 }
933 return 0;
934}
935/*****************************************************************************/
936
937void AliBaseLoader::Clean()
938{
939//removes objects from folder/task
940 if (GetDebug()) Info("Clean","%s %s",GetName(),GetDataLoader()->GetName());
941 TObject* obj = Get();
942 if(obj)
943 {
944 if (GetDebug())
945 Info("Clean","cleaning %s.",GetName());
946 RemoveFromBoard(obj);
947 delete obj;
948 }
949}
950/*****************************************************************************/
951
952void AliBaseLoader::Unload()
953{
d0d4a6b3 954 // Unloads data and closes the files
88cb7938 955 Clean();
956 fIsLoaded = kFALSE;
957 GetDataLoader()->CloseFile();
958}
959/*****************************************************************************/
960AliDataLoader* AliBaseLoader::GetDataLoader() const
961{
d0d4a6b3 962 // Returns pointer to the data loader
88cb7938 963 if (fDataLoader == 0x0)
964 {
965 Fatal("GetDataLoader","Pointer to Data Loader is NULL");
966 }
967 return fDataLoader;
968}
969/*****************************************************************************/
970
971Int_t AliBaseLoader::GetDebug() const
972{
d0d4a6b3 973 // Returns debug level
974 return (Int_t)AliLoader::GetDebug();
88cb7938 975}
976
d0d4a6b3 977TDirectory* AliBaseLoader::GetDirectory() const
88cb7938 978{
979 // returnd TDirectory where data are to be saved
980 //if fStoreInTopOfFile flag is true - returns pointer to file
981 return (fStoreInTopOfFile)?GetDataLoader()->GetFile():GetDataLoader()->GetDirectory();
982}
983/*****************************************************************************/
984/*****************************************************************************/
985/*****************************************************************************/
986//__________________________________________
987///////////////////////////////////////////////////////////////////////////////
988// //
989// class AliObjectLoader //
990// //
991// //
992///////////////////////////////////////////////////////////////////////////////
993
994ClassImp(AliObjectLoader)
995
996AliObjectLoader::AliObjectLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop):
997 AliBaseLoader(name,dl,storeontop)
998{
999//constructor
1000}
1001/*****************************************************************************/
1002
1003TFolder* AliObjectLoader::GetFolder() const
1004{
d0d4a6b3 1005 // Returns pointer to the object folder
88cb7938 1006 TFolder* df = GetDataLoader()->GetFolder();
1007 if (df == 0x0)
1008 {
1009 Fatal("GetFolder","Data Folder is NULL");
1010 }
1011 return df;
1012}
1013/*****************************************************************************/
d0d4a6b3 1014AliObjectLoader::AliObjectLoader(const AliObjectLoader& source):
1015 AliBaseLoader(source) {
1016 // copy constructor
1017 Fatal("AliObjectLoader","Copy constructor not implemented");
1018}
1019/*****************************************************************************/
1020AliObjectLoader& AliObjectLoader::operator=(const AliObjectLoader& /*source*/) {
1021 // Assignment operator
1022 Fatal("AliObjectLoader","Assignment operator not implemented");
1023 return *this;
1024}
1025/*****************************************************************************/
88cb7938 1026
1027void AliObjectLoader::RemoveFromBoard(TObject* obj)
1028{
d0d4a6b3 1029 // Removes "obj" from the board
88cb7938 1030 GetFolder()->Remove(obj);
1031}
1032/*****************************************************************************/
1033Int_t AliObjectLoader::AddToBoard(TObject* obj)
1034{
d0d4a6b3 1035 // Adds "obj" to the board
88cb7938 1036 GetFolder()->Add(obj);
1037 return 0;
1038}
1039/*****************************************************************************/
1040
1041TObject* AliObjectLoader::Get() const
1042{
d0d4a6b3 1043 // Returns pointer to the object loader
88cb7938 1044 return (GetFolder()) ? GetFolder()->FindObject(GetName()) : 0x0;
1045}
1046
1047/*****************************************************************************/
1048/*****************************************************************************/
1049/*****************************************************************************/
1050//__________________________________________
1051///////////////////////////////////////////////////////////////////////////////
1052// //
1053// class AliTreeLoader //
1054// //
1055// //
1056///////////////////////////////////////////////////////////////////////////////
1057
1058ClassImp(AliTreeLoader)
1059
1060AliTreeLoader::AliTreeLoader(const TString& name, AliDataLoader* dl,Bool_t storeontop):
1061 AliObjectLoader(name,dl,storeontop)
1062{
1063//constructor
1064}
d0d4a6b3 1065/*****************************************************************************/
1066AliTreeLoader::AliTreeLoader(const AliTreeLoader& source):
1067 AliObjectLoader(source) {
1068 // copy constructor
1069 Fatal("AliTreeLoader","Copy constructor not implemented");
1070}
1071/*****************************************************************************/
1072AliTreeLoader& AliTreeLoader::operator=(const AliTreeLoader& /*source*/) {
1073 // Assignment operator
1074 Fatal("AliTreeLoader","Assignment operator not implemented");
1075 return *this;
1076}
88cb7938 1077
1078/*****************************************************************************/
1079
1080Int_t AliTreeLoader::WriteData(Option_t* opt)
1081{
1082//Writes data defined by di object
1083//opt might be "OVERWRITE" in case of forcing overwriting
1084
1085 if (GetDebug())
1086 Info("WriteData","Writing %s container for %s data. Option is %s.",
1087 GetName(),GetDataLoader()->GetName(),opt);
1088
1089 TObject *data = Get();
1090 if(data == 0x0)
1091 {//did not get, nothing to write
1092 Warning("WriteData","Tree named %s not found in folder. Nothing to write.",GetName());
1093 return 0;
1094 }
1095
1096 //check if file is opened
1097 if (GetDirectory() == 0x0)
1098 {
1099 //if not try to open
1100 GetDataLoader()->SetFileOption("UPDATE");
1101 if (GetDataLoader()->OpenFile("UPDATE"))
1102 {
1103 //oops, can not open the file, give an error message and return error code
1104 Error("WriteData","Can not open hits file. %s ARE NOT WRITTEN",GetName());
1105 return 1;
1106 }
1107 }
1108
1109 if (GetDataLoader()->IsFileWritable() == kFALSE)
1110 {
1111 Error("WriteData","File %s is not writable",GetDataLoader()->GetFileName().Data());
1112 return 2;
1113 }
1114
1115 GetDirectory()->cd(); //set the proper directory active
1116
1117 //see if hits container already exists in this (root) directory
1118 TObject* obj = GetFromDirectory(GetName());
1119 if (obj)
1120 { //if they exist, see if option OVERWRITE is used
1121 const char *oOverWrite = strstr(opt,"OVERWRITE");
1122 if(!oOverWrite)
1123 {//if it is not used - give an error message and return an error code
1124 Error("WriteData","Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data");
1125 return 3;
1126 }
1127 }
1128
1129 if (GetDebug()) Info("WriteData","DataName = %s, opt = %s, data object name = %s",
1130 GetName(),opt,data->GetName());
1131 if (GetDebug()) Info("WriteData","File Name = %s, Directory Name = %s Directory's File Name = %s",
1132 GetDataLoader()->GetFile()->GetName(),GetDirectory()->GetName(),
1133 GetDirectory()->GetFile()->GetName());
1134
1135 //if a data object is a tree set the directory
1136 TTree* tree = dynamic_cast<TTree*>(data);
1137 if (tree) tree->SetDirectory(GetDirectory()); //forces setting the directory to this directory (we changed dir few lines above)
1138
1139 if (GetDebug()) Info("WriteData","Writing tree");
1140 data->Write(0,TObject::kOverwrite);
1141
1142 fIsLoaded = kTRUE; // Just to ensure flag is on. Object can be posted manually to folder structure, not using loader.
1143
1144 return 0;
1145
1146}
1147/*****************************************************************************/
1148
1149void AliTreeLoader::MakeTree()
1150{
f2a509af 1151//this virtual method creates the tree in the file
88cb7938 1152 if (Tree())
1153 {
1154 if (GetDebug())
1155 Info("MakeTree","name = %s, Data Name = %s Tree already exists.",
1156 GetName(),GetDataLoader()->GetName());
1157 return;//tree already made
1158 }
1159 if (GetDebug())
1160 Info("MakeTree","Making Tree named %s.",GetName());
1161
1162 TString dtypename(GetDataLoader()->GetName());
1163 TTree* tree = new TTree(GetName(), dtypename + " Container"); //make a tree
1164 if (tree == 0x0)
1165 {
1166 Error("MakeTree","Can not create %s tree.",GetName());
1167 return;
1168 }
1169 tree->SetAutoSave(1000000000); //no autosave
1170 GetFolder()->Add(tree);
1171 WriteData("OVERWRITE");//write tree to the file
1172}
1173
1174
1175/*****************************************************************************/
1176/*****************************************************************************/
1177/*****************************************************************************/
1178//__________________________________________
1179///////////////////////////////////////////////////////////////////////////////
1180// //
1181// class AliTaskLoader //
1182// //
1183// //
1184///////////////////////////////////////////////////////////////////////////////
1185
1186ClassImp(AliTaskLoader)
1187
1188AliTaskLoader::AliTaskLoader(const TString& name, AliDataLoader* dl, TTask* parentaltask, Bool_t storeontop):
1189 AliBaseLoader(name,dl,storeontop),
1190 fParentalTask(parentaltask)
1191{
1192//constructor
1193}
1194
d0d4a6b3 1195/*****************************************************************************/
1196AliTaskLoader::AliTaskLoader(const AliTaskLoader& source):
1197 AliBaseLoader(source) {
1198 // copy constructor
1199 Fatal("AliTaskLoader","Copy constructor not implemented");
1200}
1201/*****************************************************************************/
1202AliTaskLoader& AliTaskLoader::operator=(const AliTaskLoader& /*source*/) {
1203 // Assignment operator
1204 Fatal("AliTaskLoader","Assignment operator not implemented");
1205 return *this;
1206}
88cb7938 1207/*****************************************************************************/
3637d19d 1208void AliTaskLoader::Clean()
1209{
1210//removes tasl from parental task
1211// DO NOT DELETE OBJECT contrary to BaseLoader
1212//
1213 if (GetDebug()) Info("Clean","%s %s",GetName(),GetDataLoader()->GetName());
1214 TObject* obj = Get();
1215 if(obj)
1216 {
1217 if (GetDebug())
1218 Info("Clean","cleaning %s.",GetName());
1219 RemoveFromBoard(obj);
1220 }
1221}
1222/*****************************************************************************/
88cb7938 1223
1224void AliTaskLoader::RemoveFromBoard(TObject* obj)
1225{
d0d4a6b3 1226 // Removes the task "obj" from the board
88cb7938 1227 GetParentalTask()->GetListOfTasks()->Remove(obj);
1228}
1229/*****************************************************************************/
1230
1231Int_t AliTaskLoader::AddToBoard(TObject* obj)
1232{
d0d4a6b3 1233 // Adds task "obj" to the board
88cb7938 1234 TTask* task = dynamic_cast<TTask*>(obj);
1235 if (task == 0x0)
1236 {
1237 Error("AddToBoard","To TTask board can be added only tasks.");
1238 return 1;
1239 }
1240 GetParentalTask()->Add(task);
1241 return 0;
1242}
1243/*****************************************************************************/
1244
1245TObject* AliTaskLoader::Get() const
1246{
d0d4a6b3 1247 // Returns pointer to the current task
88cb7938 1248 return (GetParentalTask()) ? GetParentalTask()->GetListOfTasks()->FindObject(GetName()) : 0x0;
1249}
1250/*****************************************************************************/
1251
1252TTask* AliTaskLoader::GetParentalTask() const
1253{
1254//returns parental tasks for this task
1255 return fParentalTask;
1256}
1257
1258/*****************************************************************************/
1259
1260/*****************************************************************************/
1261/*****************************************************************************/
1262/*****************************************************************************/
1263
1264