1 #include <AliDataLoader.h>
2 //__________________________________________
3 /////////////////////////////////////////////////////////////////////////////////////////////
5 // class AliDataLoader //
7 // Container of all data needed for full //
8 // description of each data type //
9 // (Hits, Kine, ...) //
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 //
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 //
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 //
29 /////////////////////////////////////////////////////////////////////////////////////////////
36 #include "AliRunLoader.h"
38 ClassImp(AliDataLoader)
40 AliDataLoader::AliDataLoader():
55 /*****************************************************************************/
57 AliDataLoader::AliDataLoader(const char* filename, const char* contname, const char* name, Option_t* opt):
64 fBaseLoaders(new TObjArray(4)),
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
76 Info("AliDataLoader","File name is %s",fFileName.Data());
80 if (option.CompareTo("T",TString::kIgnoreCase) == 0)
81 bl = new AliTreeLoader(contname,this);
83 bl = new AliObjectLoader(contname,this);
84 fBaseLoaders->AddAt(bl,kData);
87 /*****************************************************************************/
88 AliDataLoader::AliDataLoader(const AliDataLoader& source):TNamed(source) {
90 Fatal("AliDataLoader","Copy constructor not implemented");
92 /*****************************************************************************/
93 AliDataLoader& AliDataLoader::operator=(const AliDataLoader& /*source*/) {
94 // Assignment operator
95 Fatal("AliDataLoader","Assignment operator not implemented");
98 /*****************************************************************************/
100 AliDataLoader::~AliDataLoader()
105 /*****************************************************************************/
107 Int_t AliDataLoader::SetEvent()
109 //basically the same that GetEvent but do not post data to folders
110 AliRunLoader* rl = GetRunLoader();
113 Error("SetEvent","Can not get RunGettr");
117 Int_t evno = rl->GetEventNumber();
119 TIter next(fBaseLoaders);
121 while ((bl = (AliBaseLoader*)next()))
123 if (bl->DoNotReload() == kFALSE) bl->Clean();
132 if (GetDebug()) Info("SetEvent","Reloading new file. File opt is %s",fFileOption.Data());
133 OpenFile(fFileOption);
136 fDirectory = AliLoader::ChangeDir(fFile,evno);
137 if (fDirectory == 0x0)
139 Error("SetEvent","Can not chage directory in file %s",fFile->GetName());
145 /*****************************************************************************/
147 Int_t AliDataLoader::GetEvent()
149 // posts all loaded data from files to White Board
150 // event number is defined in RunLoader
153 // 0 - in case of no error
154 // 1 - event not found
156 //for each base laoder post, if was loaded before GetEvent
158 //call set event to switch to new directory in file
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
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);
169 while ((bl = (AliBaseLoader*)nextbl()))
173 if (bl->DoNotReload() == kFALSE) bl->Post();
179 /*****************************************************************************/
181 Int_t AliDataLoader::OpenFile(Option_t* opt)
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
188 if(fFile->IsOpen() == kTRUE)
190 Warning("OpenFile"," File %s already opened. First close it.",fFile->GetName());
195 Warning("OpenFile","Pointer to file %s is not null, but file is not opened",
202 TString fname(SetFileOffset(fFileName));
204 fFile = (TFile *)(gROOT->GetListOfFiles()->FindObject(fname));
207 if(fFile->IsOpen() == kTRUE)
209 Warning("OpenFile","File %s already opened by sombody else. First close it.",
216 fFile = TFile::Open(fname,fFileOption);//open the file
219 Error("OpenFile","Can not open file %s",fname.Data());
222 if (fFile->IsOpen() == kFALSE)
224 Error("OpenFile","Can not open file %s",fname.Data());
228 fFile->SetCompressionLevel(fCompressionLevel);
230 AliRunLoader* rg = GetRunLoader();
233 Error("OpenFile","Can not find Run-Loader in folder.");
236 Int_t evno = rg->GetEventNumber();
238 fDirectory = AliLoader::ChangeDir(fFile,evno);
239 if (fDirectory == 0x0)
241 Error("OpenFile","Can not chage fDirectory in file %s.",fFile->GetName());
246 /*****************************************************************************/
248 void AliDataLoader::Unload()
250 //unloads main data - shortcut method
251 GetBaseLoader(0)->Unload();
253 /*****************************************************************************/
255 void AliDataLoader::UnloadAll()
257 //Unloads all data and tasks
258 if ( fFile == 0x0 ) return; //nothing loaded
260 TIter next(fBaseLoaders);
262 while ((bl = (AliBaseLoader*)next()))
267 /*****************************************************************************/
269 Int_t AliDataLoader::Reload()
271 //Unloads and loads data again
272 if ( fFile == 0x0 ) return 0;
274 TBits loaded(fBaseLoaders->GetEntries());
275 TIter next(fBaseLoaders);
279 while ((bl = (AliBaseLoader*)next()))
283 loaded.SetBitNumber(i++,kTRUE);
291 while ((bl = (AliBaseLoader*)next()))
293 if (loaded.TestBitNumber(i++))
295 retval = bl->Load(fFileOption);
298 Error("Reload","Error occur while loading %s",bl->GetName());
307 /*****************************************************************************/
308 Int_t AliDataLoader::WriteData(Option_t* opt)
310 //Writes primary data == first BaseLoader
312 Info("WriteData","Writing %s container for %s data. Option is %s.",
313 GetBaseLoader(0)->GetName(),GetName(),opt);
314 return GetBaseLoader(0)->WriteData(opt);
316 /*****************************************************************************/
318 Int_t AliDataLoader::Load(Option_t* opt)
320 //Writes primary data == first BaseLoader
321 return GetBaseLoader(0)->Load(opt);
323 /*****************************************************************************/
325 Int_t AliDataLoader::SetEventFolder(TFolder* eventfolder)
327 //sets the event folder
328 if (eventfolder == 0x0)
330 Error("SetEventFolder","Stupid joke. Argument is NULL");
334 Info("SetFolder","name = %s Setting Event Folder named %s.",
335 GetName(),eventfolder->GetName());
337 fEventFolder = eventfolder;
340 /*****************************************************************************/
342 Int_t AliDataLoader::SetFolder(TFolder* folder)
344 // Sets the folder and the data loaders
347 Error("SetFolder","Stupid joke. Argument is NULL");
351 if (GetDebug()) Info("SetFolder","name = %s Setting folder named %s.",GetName(),folder->GetName());
354 TIter next(fBaseLoaders);
357 while ((bl = (AliBaseLoader*)next()))
359 bl->SetDataLoader(this);
364 /******************************************************************/
366 TFolder* AliDataLoader::GetEventFolder()
368 //get EVENT folder (data that are changing from event to event, even in single run)
369 if (GetDebug()) Info("GetEventFolder","EF = %#x");
372 /*****************************************************************************/
374 AliRunLoader* AliDataLoader::GetRunLoader()
376 //gets the run-loader from event folder
377 AliRunLoader* rg = 0x0;
378 TFolder* ef = GetEventFolder();
381 Error("GetRunLoader","Can not get event folder.");
384 rg = dynamic_cast<AliRunLoader*>(ef->FindObject(AliRunLoader::GetRunLoaderName()));
388 /*****************************************************************************/
389 void AliDataLoader::CloseFile()
392 TIter next(fBaseLoaders);
394 while ((bl = (AliBaseLoader*)next()))
396 if (bl->IsLoaded()) return;
400 Info("CloseFile","Closing and deleting (object) file.");
406 /*****************************************************************************/
408 void AliDataLoader::Clean()
411 GetBaseLoader(0)->Clean();
413 /*****************************************************************************/
415 void AliDataLoader::CleanAll()
417 //Cleans all folders and tasks
418 TIter next(fBaseLoaders);
420 while ((bl = (AliBaseLoader*)next()))
425 /*****************************************************************************/
427 void AliDataLoader::SetFileNameSuffix(const TString& suffix)
429 //adds the suffix before ".root",
430 //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
431 //made on Jiri Chudoba demand
434 Info("SetFileNameSuffix","suffix=%s",suffix.Data());
435 Info("SetFileNameSuffix"," Digits File Name before: %s",fFileName.Data());
438 static TString dotroot(".root");
439 const TString& suffixdotroot = suffix + dotroot;
440 fFileName = fFileName.ReplaceAll(dotroot,suffixdotroot);
443 Info("SetDigitsFileNameSuffix"," after : %s",fFileName.Data());
445 /*****************************************************************************/
447 Bool_t AliDataLoader::CheckReload()
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
455 /*****************************************************************************/
457 const TString AliDataLoader::SetFileOffset(const TString& fname)
461 Long_t offset = (Long_t)GetRunLoader()->GetFileOffset();
462 if (offset < 1) return fname;
465 soffset += offset;//automatic conversion to string
466 TString dotroot(".root");
467 const TString& offfsetdotroot = offset + dotroot;
469 out = out.ReplaceAll(dotroot,offfsetdotroot);
470 if (GetDebug()) Info("SetFileOffset","in=%s out=%s.",fname.Data(),out.Data());
474 /*****************************************************************************/
476 void AliDataLoader::SetFileOption(Option_t* newopt)
479 if (fFileOption.CompareTo(newopt) == 0) return;
480 fFileOption = newopt;
483 /*****************************************************************************/
485 void AliDataLoader::SetCompressionLevel(Int_t cl)
487 //sets comression level for data defined by di
488 fCompressionLevel = cl;
489 if (fFile) fFile->SetCompressionLevel(cl);
491 /*****************************************************************************/
493 Int_t AliDataLoader::GetDebug() const
495 //it is not inline bacause AliLoader.h includes AliDataLoaer.h
496 //and there is circular depenedence
497 return AliLoader::GetDebug();
499 /*****************************************************************************/
501 void AliDataLoader::MakeTree()
503 // Makes tree for the current data loader
504 AliTreeLoader* tl = dynamic_cast<AliTreeLoader*>(fBaseLoaders->At(0));
507 Error("MakeTree","Can not make a tree because main base loader is not a tree loader");
512 /*****************************************************************************/
514 Bool_t AliDataLoader::IsFileWritable() const
516 //returns true if file is writable
517 return (fFile)?fFile->IsWritable():kFALSE;
519 /*****************************************************************************/
521 Bool_t AliDataLoader::IsFileOpen() const
523 //returns true if file is writable
524 return (fFile)?fFile->IsOpen():kFALSE;
526 /*****************************************************************************/
528 Bool_t AliDataLoader::IsOptionContrary(const TString& option) const
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
535 if ( ( AliLoader::IsOptionWritable(option) == kTRUE ) && // passed option is writable and
536 ( AliLoader::IsOptionWritable(fFileOption) == kFALSE ) ) // existing one is not writable
543 /*****************************************************************************/
544 void AliDataLoader::AddBaseLoader(AliBaseLoader* bl)
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,
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
554 Warning("AddBaseLoader","Pointer is null.");
558 TObject* obj = fBaseLoaders->FindObject(bl->GetName());
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.");
567 fBaseLoaders->Add(bl);
570 /*****************************************************************************/
572 AliBaseLoader* AliDataLoader::GetBaseLoader(const TString& name) const
574 return dynamic_cast<AliBaseLoader*>(fBaseLoaders->FindObject(name));
576 /*****************************************************************************/
578 AliBaseLoader* AliDataLoader::GetBaseLoader(Int_t n) const
580 // Gets the n-th base loader (what is n?)
581 return dynamic_cast<AliBaseLoader*>(fBaseLoaders->At(n));
583 /*****************************************************************************/
585 TTree* AliDataLoader::Tree() const
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;
595 /*****************************************************************************/
597 void AliDataLoader::SetDirName(TString& dirname)
599 // Sets the directory name where the files will be stored
600 if (GetDebug()>9) Info("SetDirName","FileName before %s",fFileName.Data());
602 Int_t n = fFileName.Last('/');
604 if (GetDebug()>9) Info("SetDirName","Slash found on pos %d",n);
606 if (n > 0) fFileName = fFileName.Remove(0,n+1);
608 if (GetDebug()>9) Info("SetDirName","Core FileName %s",fFileName.Data());
610 fFileName = dirname + "/" + fFileName;
612 if (GetDebug()>9) Info("SetDirName","FileName after %s",fFileName.Data());
614 /*****************************************************************************/
615 AliObjectLoader* AliDataLoader::GetBaseDataLoader()
617 // Gets the base data loader
618 return dynamic_cast<AliObjectLoader*>(GetBaseLoader(kData));
620 /*****************************************************************************/
621 AliTaskLoader* AliDataLoader::GetBaseTaskLoader()
623 // Gets the base task loader
624 return dynamic_cast<AliTaskLoader*>(GetBaseLoader(kTask));
626 /*****************************************************************************/
627 AliBaseLoader* AliDataLoader::GetBaseQALoader()
629 // Gets the base QA loader
630 return GetBaseLoader(kQA);
632 /*****************************************************************************/
633 AliTaskLoader* AliDataLoader::GetBaseQATaskLoader()
635 //returns pointer to QA base loader
636 return dynamic_cast<AliTaskLoader*>(GetBaseLoader(kQATask));
638 /*****************************************************************************/
639 void AliDataLoader::SetBaseDataLoader(AliBaseLoader* bl)
641 //sets data base loader
644 Error("SetBaseDataLoader","Parameter is null");
647 if (GetBaseDataLoader()) delete GetBaseDataLoader();
648 fBaseLoaders->AddAt(bl,kData);
650 /*****************************************************************************/
651 void AliDataLoader::SetBaseTaskLoader(AliTaskLoader* bl)
653 //sets Task base loader
656 Error("SetBaseTaskLoader","Parameter is null");
659 if (GetBaseTaskLoader()) delete GetBaseTaskLoader();
660 fBaseLoaders->AddAt(bl,kTask);
662 /*****************************************************************************/
663 void AliDataLoader::SetBaseQALoader(AliBaseLoader* bl)
665 //sets QA base loader
668 Error("SetBaseQALoader","Parameter is null");
671 if (GetBaseQALoader()) delete GetBaseQALoader();
672 fBaseLoaders->AddAt(bl,kQA);
674 /*****************************************************************************/
675 void AliDataLoader::SetBaseQATaskLoader(AliTaskLoader* bl)
677 //sets QA Task base loader
680 Error("SetBaseQATaskLoader","Parameter is null");
683 if (GetBaseQATaskLoader()) delete GetBaseQATaskLoader();
684 fBaseLoaders->AddAt(bl,kQATask);
686 void AliDataLoader::Synchronize()
688 //synchrinizes all writtable files
689 if ( fFile ) fFile->Flush();
692 /*****************************************************************************/
693 /*****************************************************************************/
694 /*****************************************************************************/
695 //__________________________________________
696 ///////////////////////////////////////////////////////////////////////////////
698 // class AliBaseLoader //
701 ///////////////////////////////////////////////////////////////////////////////
702 ClassImp(AliBaseLoader)
704 AliBaseLoader::AliBaseLoader():
706 fStoreInTopOfFile(kFALSE),
707 fDoNotReload(kFALSE),
710 //default constructor
712 /*****************************************************************************/
714 AliBaseLoader::AliBaseLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop):
715 TNamed(name,name+" Base Loader"),
717 fStoreInTopOfFile(storeontop),
718 fDoNotReload(storeontop),//if stored on top of file - this object is loaded ones pe
724 /*****************************************************************************/
725 AliBaseLoader::AliBaseLoader(const AliBaseLoader& source):TNamed(source) {
727 Fatal("AliBaseLoader","Copy constructor not implemented");
729 /*****************************************************************************/
730 AliBaseLoader& AliBaseLoader::operator=(const AliBaseLoader& /*source*/) {
731 // Assignment operator
732 Fatal("AliBaseLoader","Assignment operator not implemented");
735 /*****************************************************************************/
737 Int_t AliBaseLoader::Load(Option_t* opt)
739 // Loads and posts the data
741 Info("Load","data type = %s, option = %s",GetName(),opt);
745 Warning("Load","Data <<%s>> are already loaded. Use ReloadData to force reload. Nothing done",GetName());
751 if (GetDataLoader()->IsFileOpen() == kTRUE)
753 if (GetDataLoader()->IsOptionContrary(opt) == kTRUE)
755 Error("Load","Data Type %s, Container Name %s", GetDataLoader()->GetName(),GetName());
756 Error("Load","File was already opened in READ-ONLY mode, while now WRITEABLE access is requested.");
757 Error("Load","Use AliDataLoader::SetOption to enforce change of access mode OR");
758 Error("Load","Load previosly loaded data with coherent option.");
764 retval = GetDataLoader()->OpenFile(opt);
767 Error("Load","Error occured while opening <<%s>> file",GetName());
771 //if file is recreated there is no sense to search for data to post and get Error message
772 if (AliLoader::TestFileOption(opt) == kFALSE)
774 AliTreeLoader* tl = dynamic_cast<AliTreeLoader*>(this);
775 if (tl) tl->MakeTree();
783 Error("Load","Error occured while posting %s from file to folder.",GetName());
790 /*****************************************************************************/
792 Int_t AliBaseLoader::Post()
794 //Posts data container to proper folders
796 if ( GetDirectory() == 0x0)
798 Error("Post","%s directory is NULL. Load before.",GetDataLoader()->GetName());
802 TObject* data = GetFromDirectory(fName);
805 //if such an obejct already exists - remove it first
810 //check if file is in update mode
811 Int_t fileupdate = GetDataLoader()->GetFileOption().CompareTo("update",TString::kIgnoreCase);
812 if ( fileupdate == 0)
813 { //if it is, it is normal that there is no data yet
816 Info("Post","Can not find %s in file %s (file is opened in UPDATE mode).",
817 GetName(),GetDataLoader()->GetFile()->GetName());
822 Error("Post","Can not find %s in file %s", GetName(),GetDataLoader()->GetFile()->GetName());
828 /*****************************************************************************/
830 Int_t AliBaseLoader::Post(TObject* data)
832 //Posts data container to proper folders
835 Error("Post","Pointer to object is NULL");
839 if ( fName.CompareTo(data->GetName()) != 0)
841 Fatal("Post(TObject*)","Object name is <<%s>> while <<%s>> expected",data->GetName(),GetName());
842 return -1;//pro forma
845 TObject* obj = Get();
848 if (GetDebug()) Warning("Post","This object was already posted.");
853 Warning("PostData","Object named %s already exitsts in data folder. Removing it",GetName());
856 return AddToBoard(data);
858 /*****************************************************************************/
860 Int_t AliBaseLoader::WriteData(Option_t* opt)
862 //Writes data defined by di object
863 //opt might be "OVERWRITE" in case of forcing overwriting
865 Info("WriteData","Writing %s container for %s data. Option is %s.",
866 GetName(),GetDataLoader()->GetName(),opt);
868 TObject *data = Get();
870 {//did not get, nothing to write
871 Warning("WriteData","Tree named %s not found in folder. Nothing to write.",GetName());
875 //check if file is opened
876 if (GetDirectory() == 0x0)
879 GetDataLoader()->SetFileOption("UPDATE");
880 if (GetDataLoader()->OpenFile("UPDATE"))
882 //oops, can not open the file, give an error message and return error code
883 Error("WriteData","Can not open hits file. %s ARE NOT WRITTEN",GetName());
888 if (GetDataLoader()->IsFileWritable() == kFALSE)
890 Error("WriteData","File %s is not writable",GetDataLoader()->GetFileName().Data());
894 GetDirectory()->cd(); //set the proper directory active
896 //see if hits container already exists in this (root) directory
897 TObject* obj = GetFromDirectory(GetName());
899 { //if they exist, see if option OVERWRITE is used
900 const char *oOverWrite = strstr(opt,"OVERWRITE");
902 {//if it is not used - give an error message and return an error code
903 Error("WriteData","Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data");
908 if (GetDebug()) Info("WriteData","DataName = %s, opt = %s, data object name = %s",
909 GetName(),opt,data->GetName());
910 if (GetDebug()) Info("WriteData","File Name = %s, Directory Name = %s Directory's File Name = %s",
911 GetDataLoader()->GetFile()->GetName(),GetDirectory()->GetName(),
912 GetDirectory()->GetFile()->GetName());
914 if (GetDebug()) Info("WriteData","Writing data");
915 data->Write(0,TObject::kOverwrite);
917 fIsLoaded = kTRUE; // Just to ensure flag is on. Object can be posted manually to folder structure, not using loader.
922 /*****************************************************************************/
924 Int_t AliBaseLoader::Reload()
926 //Unloads and loads datat again - if loaded before
930 return Load(GetDataLoader()->GetFileOption());
934 /*****************************************************************************/
936 void AliBaseLoader::Clean()
938 //removes objects from folder/task
939 if (GetDebug()) Info("Clean","%s %s",GetName(),GetDataLoader()->GetName());
940 TObject* obj = Get();
944 Info("Clean","cleaning %s.",GetName());
945 RemoveFromBoard(obj);
949 /*****************************************************************************/
951 void AliBaseLoader::Unload()
953 // Unloads data and closes the files
956 GetDataLoader()->CloseFile();
958 /*****************************************************************************/
959 AliDataLoader* AliBaseLoader::GetDataLoader() const
961 // Returns pointer to the data loader
962 if (fDataLoader == 0x0)
964 Fatal("GetDataLoader","Pointer to Data Loader is NULL");
968 /*****************************************************************************/
970 Int_t AliBaseLoader::GetDebug() const
972 // Returns debug level
973 return (Int_t)AliLoader::GetDebug();
976 TDirectory* AliBaseLoader::GetDirectory() const
978 // returnd TDirectory where data are to be saved
979 //if fStoreInTopOfFile flag is true - returns pointer to file
980 return (fStoreInTopOfFile)?GetDataLoader()->GetFile():GetDataLoader()->GetDirectory();
982 /*****************************************************************************/
983 /*****************************************************************************/
984 /*****************************************************************************/
985 //__________________________________________
986 ///////////////////////////////////////////////////////////////////////////////
988 // class AliObjectLoader //
991 ///////////////////////////////////////////////////////////////////////////////
993 ClassImp(AliObjectLoader)
995 AliObjectLoader::AliObjectLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop):
996 AliBaseLoader(name,dl,storeontop)
1000 /*****************************************************************************/
1002 TFolder* AliObjectLoader::GetFolder() const
1004 // Returns pointer to the object folder
1005 TFolder* df = GetDataLoader()->GetFolder();
1008 Fatal("GetFolder","Data Folder is NULL");
1012 /*****************************************************************************/
1013 AliObjectLoader::AliObjectLoader(const AliObjectLoader& source):
1014 AliBaseLoader(source) {
1016 Fatal("AliObjectLoader","Copy constructor not implemented");
1018 /*****************************************************************************/
1019 AliObjectLoader& AliObjectLoader::operator=(const AliObjectLoader& /*source*/) {
1020 // Assignment operator
1021 Fatal("AliObjectLoader","Assignment operator not implemented");
1024 /*****************************************************************************/
1026 void AliObjectLoader::RemoveFromBoard(TObject* obj)
1028 // Removes "obj" from the board
1029 GetFolder()->Remove(obj);
1031 /*****************************************************************************/
1032 Int_t AliObjectLoader::AddToBoard(TObject* obj)
1034 // Adds "obj" to the board
1035 GetFolder()->Add(obj);
1038 /*****************************************************************************/
1040 TObject* AliObjectLoader::Get() const
1042 // Returns pointer to the object loader
1043 return (GetFolder()) ? GetFolder()->FindObject(GetName()) : 0x0;
1046 /*****************************************************************************/
1047 /*****************************************************************************/
1048 /*****************************************************************************/
1049 //__________________________________________
1050 ///////////////////////////////////////////////////////////////////////////////
1052 // class AliTreeLoader //
1055 ///////////////////////////////////////////////////////////////////////////////
1057 ClassImp(AliTreeLoader)
1059 AliTreeLoader::AliTreeLoader(const TString& name, AliDataLoader* dl,Bool_t storeontop):
1060 AliObjectLoader(name,dl,storeontop)
1064 /*****************************************************************************/
1065 AliTreeLoader::AliTreeLoader(const AliTreeLoader& source):
1066 AliObjectLoader(source) {
1068 Fatal("AliTreeLoader","Copy constructor not implemented");
1070 /*****************************************************************************/
1071 AliTreeLoader& AliTreeLoader::operator=(const AliTreeLoader& /*source*/) {
1072 // Assignment operator
1073 Fatal("AliTreeLoader","Assignment operator not implemented");
1077 /*****************************************************************************/
1079 Int_t AliTreeLoader::WriteData(Option_t* opt)
1081 //Writes data defined by di object
1082 //opt might be "OVERWRITE" in case of forcing overwriting
1085 Info("WriteData","Writing %s container for %s data. Option is %s.",
1086 GetName(),GetDataLoader()->GetName(),opt);
1088 TObject *data = Get();
1090 {//did not get, nothing to write
1091 Warning("WriteData","Tree named %s not found in folder. Nothing to write.",GetName());
1095 //check if file is opened
1096 if (GetDirectory() == 0x0)
1098 //if not try to open
1099 GetDataLoader()->SetFileOption("UPDATE");
1100 if (GetDataLoader()->OpenFile("UPDATE"))
1102 //oops, can not open the file, give an error message and return error code
1103 Error("WriteData","Can not open hits file. %s ARE NOT WRITTEN",GetName());
1108 if (GetDataLoader()->IsFileWritable() == kFALSE)
1110 Error("WriteData","File %s is not writable",GetDataLoader()->GetFileName().Data());
1114 GetDirectory()->cd(); //set the proper directory active
1116 //see if hits container already exists in this (root) directory
1117 TObject* obj = GetFromDirectory(GetName());
1119 { //if they exist, see if option OVERWRITE is used
1120 const char *oOverWrite = strstr(opt,"OVERWRITE");
1122 {//if it is not used - give an error message and return an error code
1123 Error("WriteData","Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data");
1128 if (GetDebug()) Info("WriteData","DataName = %s, opt = %s, data object name = %s",
1129 GetName(),opt,data->GetName());
1130 if (GetDebug()) Info("WriteData","File Name = %s, Directory Name = %s Directory's File Name = %s",
1131 GetDataLoader()->GetFile()->GetName(),GetDirectory()->GetName(),
1132 GetDirectory()->GetFile()->GetName());
1134 //if a data object is a tree set the directory
1135 TTree* tree = dynamic_cast<TTree*>(data);
1136 if (tree) tree->SetDirectory(GetDirectory()); //forces setting the directory to this directory (we changed dir few lines above)
1138 if (GetDebug()) Info("WriteData","Writing tree");
1139 data->Write(0,TObject::kOverwrite);
1141 fIsLoaded = kTRUE; // Just to ensure flag is on. Object can be posted manually to folder structure, not using loader.
1146 /*****************************************************************************/
1148 void AliTreeLoader::MakeTree()
1150 //this virtual method creates the tree in the file
1154 Info("MakeTree","name = %s, Data Name = %s Tree already exists.",
1155 GetName(),GetDataLoader()->GetName());
1156 return;//tree already made
1159 Info("MakeTree","Making Tree named %s.",GetName());
1161 TString dtypename(GetDataLoader()->GetName());
1162 TTree* tree = new TTree(GetName(), dtypename + " Container"); //make a tree
1165 Error("MakeTree","Can not create %s tree.",GetName());
1168 tree->SetAutoSave(1000000000); //no autosave
1169 GetFolder()->Add(tree);
1170 WriteData("OVERWRITE");//write tree to the file
1174 /*****************************************************************************/
1175 /*****************************************************************************/
1176 /*****************************************************************************/
1177 //__________________________________________
1178 ///////////////////////////////////////////////////////////////////////////////
1180 // class AliTaskLoader //
1183 ///////////////////////////////////////////////////////////////////////////////
1185 ClassImp(AliTaskLoader)
1187 AliTaskLoader::AliTaskLoader(const TString& name, AliDataLoader* dl, TTask* parentaltask, Bool_t storeontop):
1188 AliBaseLoader(name,dl,storeontop),
1189 fParentalTask(parentaltask)
1194 /*****************************************************************************/
1195 AliTaskLoader::AliTaskLoader(const AliTaskLoader& source):
1196 AliBaseLoader(source) {
1198 Fatal("AliTaskLoader","Copy constructor not implemented");
1200 /*****************************************************************************/
1201 AliTaskLoader& AliTaskLoader::operator=(const AliTaskLoader& /*source*/) {
1202 // Assignment operator
1203 Fatal("AliTaskLoader","Assignment operator not implemented");
1206 /*****************************************************************************/
1207 void AliTaskLoader::Clean()
1209 //removes tasl from parental task
1210 // DO NOT DELETE OBJECT contrary to BaseLoader
1212 if (GetDebug()) Info("Clean","%s %s",GetName(),GetDataLoader()->GetName());
1213 TObject* obj = Get();
1217 Info("Clean","cleaning %s.",GetName());
1218 RemoveFromBoard(obj);
1221 /*****************************************************************************/
1223 void AliTaskLoader::RemoveFromBoard(TObject* obj)
1225 // Removes the task "obj" from the board
1226 GetParentalTask()->GetListOfTasks()->Remove(obj);
1228 /*****************************************************************************/
1230 Int_t AliTaskLoader::AddToBoard(TObject* obj)
1232 // Adds task "obj" to the board
1233 TTask* task = dynamic_cast<TTask*>(obj);
1236 Error("AddToBoard","To TTask board can be added only tasks.");
1239 GetParentalTask()->Add(task);
1242 /*****************************************************************************/
1244 TObject* AliTaskLoader::Get() const
1246 // Returns pointer to the current task
1247 return (GetParentalTask()) ? GetParentalTask()->GetListOfTasks()->FindObject(GetName()) : 0x0;
1249 /*****************************************************************************/
1251 TTask* AliTaskLoader::GetParentalTask() const
1253 //returns parental tasks for this task
1254 return fParentalTask;
1257 /*****************************************************************************/
1259 /*****************************************************************************/
1260 /*****************************************************************************/
1261 /*****************************************************************************/