STEER/AliDataLoader.cxx

   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>
  35
  36 #include "AliRunLoader.h"
  37
  38 ClassImp(AliDataLoader)
  39
  40 AliDataLoader::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
  57 AliDataLoader::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 /*****************************************************************************/
  88 AliDataLoader::AliDataLoader(const AliDataLoader& source):TNamed(source) {
  89   // copy constructor
  90   Fatal("AliDataLoader","Copy constructor not implemented");
  91 }
  92 /*****************************************************************************/
  93 AliDataLoader& AliDataLoader::operator=(const AliDataLoader& /*source*/) {
  94   // Assignment operator
  95   Fatal("AliDataLoader","Assignment operator not implemented");
  96   return *this;
  97 }
  98 /*****************************************************************************/
  99
 100 AliDataLoader::~AliDataLoader()
 101 {
 102 //dtor
 103  UnloadAll();
 104 }
 105 /*****************************************************************************/
 106
 107 Int_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
 147 Int_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
 181 Int_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
 248 void AliDataLoader::Unload()
 249 {
 250  //unloads main data -  shortcut method
 251   GetBaseLoader(0)->Unload();
 252 }
 253 /*****************************************************************************/
 254
 255 void AliDataLoader::UnloadAll()
 256 {
 257 //Unloads all data and tasks
 258  if ( fFile == 0x0 ) return; //nothing loaded
 259
 260  TIter next(fBaseLoaders);
 261  AliBaseLoader* bl;
 262  while ((bl = (AliBaseLoader*)next()))
 263   {
 264     bl->Unload();
 265   }
 266 }
 267 /*****************************************************************************/
 268
 269 Int_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 /*****************************************************************************/
 308 Int_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
 318 Int_t AliDataLoader::Load(Option_t* opt)
 319 {
 320 //Writes primary data ==  first BaseLoader
 321   return GetBaseLoader(0)->Load(opt);
 322 }
 323 /*****************************************************************************/
 324
 325 Int_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
 342 Int_t  AliDataLoader::SetFolder(TFolder* folder)
 343 {
 344   // Sets the folder and the data loaders
 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
 366 TFolder* 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
 374 AliRunLoader* 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    }
 384   rg = dynamic_cast<AliRunLoader*>(ef->FindObject(AliRunLoader::GetRunLoaderName()));
 385   return rg;
 386 }
 387
 388 /*****************************************************************************/
 389 void 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
 408 void AliDataLoader::Clean()
 409 {
 410   //Cleans main data
 411   GetBaseLoader(0)->Clean();
 412 }
 413 /*****************************************************************************/
 414
 415 void 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
 427 void 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
 447 Bool_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
 457 const 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
 476 void 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
 485 void 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
 493 Int_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
 501 void AliDataLoader::MakeTree()
 502 {
 503   // Makes tree for the current data loader
 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
 514 Bool_t AliDataLoader::IsFileWritable() const
 515 {
 516 //returns true if file is writable
 517  return (fFile)?fFile->IsWritable():kFALSE;
 518 }
 519 /*****************************************************************************/
 520
 521 Bool_t AliDataLoader::IsFileOpen() const
 522 {
 523 //returns true if file is writable
 524  return (fFile)?fFile->IsOpen():kFALSE;
 525 }
 526 /*****************************************************************************/
 527
 528 Bool_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 /*****************************************************************************/
 544 void 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
 572 AliBaseLoader* AliDataLoader::GetBaseLoader(const TString& name) const
 573 {
 574   return dynamic_cast<AliBaseLoader*>(fBaseLoaders->FindObject(name));
 575 }
 576 /*****************************************************************************/
 577
 578 AliBaseLoader* AliDataLoader::GetBaseLoader(Int_t n) const
 579 {
 580   // Gets the n-th base loader (what is n?)
 581  return dynamic_cast<AliBaseLoader*>(fBaseLoaders->At(n));
 582 }
 583 /*****************************************************************************/
 584
 585 TTree* 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
 597 void  AliDataLoader::SetDirName(TString& dirname)
 598 {
 599   // Sets the directory name where the files will be stored
 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 /*****************************************************************************/
 615 AliObjectLoader* AliDataLoader::GetBaseDataLoader()
 616 {
 617   // Gets the base data loader
 618  return dynamic_cast<AliObjectLoader*>(GetBaseLoader(kData));
 619 }
 620 /*****************************************************************************/
 621 AliTaskLoader* AliDataLoader::GetBaseTaskLoader()
 622 {
 623   // Gets the base task loader
 624  return dynamic_cast<AliTaskLoader*>(GetBaseLoader(kTask));
 625 }
 626 /*****************************************************************************/
 627 AliBaseLoader* AliDataLoader::GetBaseQALoader()
 628 {
 629   // Gets the base QA loader
 630   return GetBaseLoader(kQA);
 631 }
 632 /*****************************************************************************/
 633 AliTaskLoader* AliDataLoader::GetBaseQATaskLoader()
 634 {
 635 //returns pointer to QA base loader
 636  return dynamic_cast<AliTaskLoader*>(GetBaseLoader(kQATask));
 637 }
 638 /*****************************************************************************/
 639 void 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 /*****************************************************************************/
 651 void 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 /*****************************************************************************/
 663 void 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 /*****************************************************************************/
 675 void 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 }
 686 void AliDataLoader::Synchronize()
 687 {
 688   //synchrinizes all writtable files
 689   if ( fFile ) fFile->Flush();
 690 }
 691
 692 /*****************************************************************************/
 693 /*****************************************************************************/
 694 /*****************************************************************************/
 695 //__________________________________________
 696 ///////////////////////////////////////////////////////////////////////////////
 697 //                                                                           //
 698 //  class AliBaseLoader                                                      //
 699 //                                                                           //
 700 //                                                                           //
 701 ///////////////////////////////////////////////////////////////////////////////
 702 ClassImp(AliBaseLoader)
 703
 704 AliBaseLoader::AliBaseLoader():
 705  fIsLoaded(kFALSE),
 706  fStoreInTopOfFile(kFALSE),
 707  fDoNotReload(kFALSE),
 708  fDataLoader(0x0)
 709 {
 710   //default constructor
 711 }
 712 /*****************************************************************************/
 713
 714 AliBaseLoader::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 {
 721   //constructor
 722 }
 723
 724 /*****************************************************************************/
 725 AliBaseLoader::AliBaseLoader(const AliBaseLoader& source):TNamed(source) {
 726   // copy constructor
 727   Fatal("AliBaseLoader","Copy constructor not implemented");
 728 }
 729 /*****************************************************************************/
 730 AliBaseLoader& AliBaseLoader::operator=(const AliBaseLoader& /*source*/) {
 731   // Assignment operator
 732   Fatal("AliBaseLoader","Assignment operator not implemented");
 733   return *this;
 734 }
 735 /*****************************************************************************/
 736
 737 Int_t AliBaseLoader::Load(Option_t* opt)
 738 {
 739   // Loads and posts the data
 740   if (GetDebug())
 741     Info("Load","data type = %s, option = %s",GetName(),opt);
 742
 743   if (Get())
 744    {
 745      if (GetDebug())
 746        Warning("Load","Data <<%s>> are already loaded. Use ReloadData to force reload. Nothing done",GetName());
 747      return 0;
 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
 793 Int_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      {
 823         Error("Post","Can not find %s in file %s", GetName(),GetDataLoader()->GetFile()->GetName());
 824         return 5;
 825      }
 826    }
 827   return 0;
 828 }
 829 /*****************************************************************************/
 830
 831 Int_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   }
 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
 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
 861 Int_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
 925 Int_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
 937 void 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
 952 void AliBaseLoader::Unload()
 953 {
 954   // Unloads data and closes the files
 955   Clean();
 956   fIsLoaded = kFALSE;
 957   GetDataLoader()->CloseFile();
 958 }
 959 /*****************************************************************************/
 960 AliDataLoader* AliBaseLoader::GetDataLoader() const
 961 {
 962   // Returns pointer to the data loader
 963  if (fDataLoader == 0x0)
 964   {
 965     Fatal("GetDataLoader","Pointer to Data Loader is NULL");
 966   }
 967  return fDataLoader;
 968 }
 969 /*****************************************************************************/
 970
 971 Int_t AliBaseLoader::GetDebug() const
 972 {
 973   // Returns debug level
 974  return (Int_t)AliLoader::GetDebug();
 975 }
 976
 977 TDirectory* AliBaseLoader::GetDirectory() const
 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
 994 ClassImp(AliObjectLoader)
 995
 996 AliObjectLoader::AliObjectLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop):
 997  AliBaseLoader(name,dl,storeontop)
 998 {
 999 //constructor
1000 }
1001 /*****************************************************************************/
1002
1003 TFolder* AliObjectLoader::GetFolder() const
1004 {
1005   // Returns pointer to the object folder
1006   TFolder* df = GetDataLoader()->GetFolder();
1007   if (df == 0x0)
1008    {
1009      Fatal("GetFolder","Data Folder is NULL");
1010    }
1011   return df;
1012 }
1013 /*****************************************************************************/
1014 AliObjectLoader::AliObjectLoader(const AliObjectLoader& source):
1015   AliBaseLoader(source) {
1016   // copy constructor
1017   Fatal("AliObjectLoader","Copy constructor not implemented");
1018 }
1019 /*****************************************************************************/
1020 AliObjectLoader& AliObjectLoader::operator=(const AliObjectLoader& /*source*/) {
1021   // Assignment operator
1022   Fatal("AliObjectLoader","Assignment operator not implemented");
1023   return *this;
1024 }
1025 /*****************************************************************************/
1026
1027 void AliObjectLoader::RemoveFromBoard(TObject* obj)
1028 {
1029   // Removes "obj" from the board
1030   GetFolder()->Remove(obj);
1031 }
1032 /*****************************************************************************/
1033 Int_t AliObjectLoader::AddToBoard(TObject* obj)
1034 {
1035   // Adds "obj" to the board
1036   GetFolder()->Add(obj);
1037   return 0;
1038 }
1039 /*****************************************************************************/
1040
1041 TObject* AliObjectLoader::Get() const
1042 {
1043   // Returns pointer to the object loader
1044   return (GetFolder()) ? GetFolder()->FindObject(GetName()) : 0x0;
1045 }
1046
1047 /*****************************************************************************/
1048 /*****************************************************************************/
1049 /*****************************************************************************/
1050 //__________________________________________
1051 ///////////////////////////////////////////////////////////////////////////////
1052 //                                                                           //
1053 //  class AliTreeLoader                                                      //
1054 //                                                                           //
1055 //                                                                           //
1056 ///////////////////////////////////////////////////////////////////////////////
1057
1058 ClassImp(AliTreeLoader)
1059
1060 AliTreeLoader::AliTreeLoader(const TString& name, AliDataLoader* dl,Bool_t storeontop):
1061  AliObjectLoader(name,dl,storeontop)
1062 {
1063 //constructor
1064 }
1065 /*****************************************************************************/
1066 AliTreeLoader::AliTreeLoader(const AliTreeLoader& source):
1067   AliObjectLoader(source) {
1068   // copy constructor
1069   Fatal("AliTreeLoader","Copy constructor not implemented");
1070 }
1071 /*****************************************************************************/
1072 AliTreeLoader& AliTreeLoader::operator=(const AliTreeLoader& /*source*/) {
1073   // Assignment operator
1074   Fatal("AliTreeLoader","Assignment operator not implemented");
1075   return *this;
1076 }
1077
1078 /*****************************************************************************/
1079
1080 Int_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
1149 void AliTreeLoader::MakeTree()
1150 {
1151 //this virtual method creates the tree in the file
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
1186 ClassImp(AliTaskLoader)
1187
1188 AliTaskLoader::AliTaskLoader(const TString& name, AliDataLoader* dl, TTask* parentaltask, Bool_t storeontop):
1189  AliBaseLoader(name,dl,storeontop),
1190  fParentalTask(parentaltask)
1191 {
1192 //constructor
1193 }
1194
1195 /*****************************************************************************/
1196 AliTaskLoader::AliTaskLoader(const AliTaskLoader& source):
1197   AliBaseLoader(source) {
1198   // copy constructor
1199   Fatal("AliTaskLoader","Copy constructor not implemented");
1200 }
1201 /*****************************************************************************/
1202 AliTaskLoader& AliTaskLoader::operator=(const AliTaskLoader& /*source*/) {
1203   // Assignment operator
1204   Fatal("AliTaskLoader","Assignment operator not implemented");
1205   return *this;
1206 }
1207 /*****************************************************************************/
1208 void 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 /*****************************************************************************/
1223
1224 void AliTaskLoader::RemoveFromBoard(TObject* obj)
1225 {
1226   // Removes the task "obj" from the board
1227   GetParentalTask()->GetListOfTasks()->Remove(obj);
1228 }
1229 /*****************************************************************************/
1230
1231 Int_t AliTaskLoader::AddToBoard(TObject* obj)
1232 {
1233   // Adds task "obj" to the board
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
1245 TObject* AliTaskLoader::Get() const
1246 {
1247   // Returns pointer to the current task
1248   return (GetParentalTask()) ? GetParentalTask()->GetListOfTasks()->FindObject(GetName()) : 0x0;
1249 }
1250 /*****************************************************************************/
1251
1252 TTask* AliTaskLoader::GetParentalTask() const
1253 {
1254 //returns parental tasks for this task
1255   return fParentalTask;
1256 }
1257
1258 /*****************************************************************************/
1259
1260 /*****************************************************************************/
1261 /*****************************************************************************/
1262 /*****************************************************************************/
1263
1264