STEER/AliLoader.cxx

   1 //
   2 //Class (base) responsible for management of data:
   3 //    - opening and closing proper files
   4 //    - posting data to folders
   5 //    - writing data from folders to proper files
   6 //
   7 //Author: Alice Offline Group http://alisoft.cern.ch
   8 //Responsible: Piotr.Skowronski@cern.ch
   9 //
  10 #include <AliLoader.h>
  11
  12 //Root includes
  13 #include <TROOT.h>
  14 #include <TFolder.h>
  15 #include <TFile.h>
  16 #include <TTree.h>
  17 #include <TTask.h>
  18 #include <TString.h>
  19 #include <TError.h>
  20
  21 //AliRoot includes
  22 #include <AliRun.h>
  23 #include <AliRunLoader.h>
  24 #include <AliRunDigitizer.h>
  25 #include <AliDigitizer.h>
  26 #include <AliDetector.h>
  27
  28 Int_t  AliLoader::fgDebug = 0;
  29
  30 const TString AliLoader::fgkDefaultHitsContainerName("TreeH");
  31 const TString AliLoader::fgkDefaultDigitsContainerName = "TreeD";
  32 const TString AliLoader::fgkDefaultSDigitsContainerName = "TreeS";
  33 const TString AliLoader::fgkDefaultRecPointsContainerName = "TreeR";
  34 const TString AliLoader::fgkDefaultTracksContainerName = "TreeT";
  35 const TString AliLoader::fgkDefaultRecParticlesContainerName = "TreeP";
  36 const TString AliLoader::fgkLoaderBaseName("Loader");
  37
  38 ClassImp(AliLoader)
  39 //___________________________________________________________________
  40 /////////////////////////////////////////////////////////////////////
  41 //                                                                 //
  42 //  class AliLoader                                                //
  43 //                                                                 //
  44 //  Base class for Loaders.                                        //
  45 //  Loader provides base I/O fascilities for "standard" data.      //
  46 //  Each detector has a laoder data member                         //
  47 //  loader is accessible via folder structure as well              //
  48 //                                                                 //
  49 /////////////////////////////////////////////////////////////////////
  50
  51 /*****************************************************************************/
  52
  53 AliLoader::AliLoader():
  54  fDataLoaders(0x0),
  55  fDetectorName(""),
  56  fEventFolder(0x0),
  57  fDataFolder(0x0),
  58  fDetectorDataFolder(0x0),
  59  fModuleFolder(0x0),
  60  fTasksFolder(0x0),
  61  fQAFolder(0x0)
  62  {
  63 //default constructor
  64
  65  }
  66 /******************************************************************/
  67
  68 AliLoader::AliLoader(const Char_t* detname,const Char_t* eventfoldername):
  69  fDataLoaders(new TObjArray(kNDataTypes)),
  70  fDetectorName(""),
  71  fEventFolder(0x0),
  72  fDataFolder(0x0),
  73  fDetectorDataFolder(0x0),
  74  fModuleFolder(0x0),
  75  fTasksFolder(0x0),
  76  fQAFolder(0x0)
  77 {
  78   //ctor
  79    if (GetDebug()) Info("AliLoader(const Char_t* detname,const Char_t* eventfoldername)",
  80         "detname = %s eventfoldername = %s",detname,eventfoldername);
  81
  82    //try to find folder eventfoldername in top alice folder
  83    //safe because GetTopFolder will abort in case of failure
  84
  85    fDetectorName = detname;
  86    fName = fDetectorName+"Loader";
  87    InitDefaults();
  88
  89    TObject* fobj = GetTopFolder()->FindObject(eventfoldername);
  90    fEventFolder = (fobj)?dynamic_cast<TFolder*>(fobj):0x0;//in case FindObject returns NULL dynamic cast cause seg. fault
  91    SetEventFolder(fEventFolder);
  92
  93  }
  94 /*****************************************************************************/
  95
  96 AliLoader::AliLoader(const Char_t * detname,TFolder* eventfolder):
  97  fDataLoaders(new TObjArray(kNDataTypes)),
  98  fDetectorName(detname),
  99  fEventFolder(0x0),
 100  fDataFolder(0x0),
 101  fDetectorDataFolder(0x0),
 102  fModuleFolder(0x0),
 103  fTasksFolder(0x0),
 104  fQAFolder(0x0)
 105 {
 106 //constructor
 107    fDetectorName = detname;
 108    fName = fDetectorName+"Loader";
 109    InitDefaults();
 110    SetEventFolder(eventfolder);
 111    //fileoption's don't need to initialized because default TString ctor does it correctly
 112 }
 113 /*****************************************************************************/
 114
 115 AliLoader::~AliLoader()
 116 {
 117 //detructor
 118   if (fDataLoaders) fDataLoaders->SetOwner();
 119   delete fDataLoaders;
 120 }
 121 /*****************************************************************************/
 122
 123 void AliLoader::InitDefaults()
 124 {
 125   // H I T S
 126   AliDataLoader* dl;
 127   dl = new AliDataLoader(fDetectorName + ".Hits.root",fgkDefaultHitsContainerName, "Hits" );
 128   fDataLoaders->AddAt(dl,kHits);
 129
 130
 131   // S U M M A B L E   D I G I T S
 132   dl = new AliDataLoader(fDetectorName + ".SDigits.root",fgkDefaultSDigitsContainerName, "Summable Digits");
 133   AliTaskLoader* tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetSDigitizerTaskName(),
 134                                         dl,AliRunLoader::GetRunSDigitizer(),kTRUE);
 135   dl->SetBaseTaskLoader(tl);
 136   fDataLoaders->AddAt(dl,kSDigits);
 137
 138   // D I G I T S
 139   dl = new AliDataLoader(fDetectorName + ".Digits.root",fgkDefaultDigitsContainerName, "Digits");
 140   tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetDigitizerTaskName(),
 141                                         dl,AliRunLoader::GetRunDigitizer(),kTRUE);
 142   dl->SetBaseTaskLoader(tl);
 143   fDataLoaders->AddAt(dl,kDigits);
 144
 145   // R E C O N S T R U C T E D   P O I N T S aka C L U S T E R S
 146   dl = new AliDataLoader(fDetectorName + ".RecPoints.root",fgkDefaultRecPointsContainerName, "Reconstructed Points");
 147   tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetReconstructionerTaskName(),
 148                                         dl,AliRunLoader::GetRunReconstructioner(),kTRUE);
 149   dl->SetBaseTaskLoader(tl);
 150   fDataLoaders->AddAt(dl,kRecPoints);
 151
 152   // T R A C K S
 153   dl = new AliDataLoader(fDetectorName + ".Tracks.root",fgkDefaultTracksContainerName, "Tracks");
 154   tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetTrackerTaskName(),
 155                                         dl,AliRunLoader::GetRunTracker(),kTRUE);
 156   dl->SetBaseTaskLoader(tl);
 157   fDataLoaders->AddAt(dl,kTracks);
 158
 159   // R E C O N S T R U C T E D   P O I N T S aka C L U S T E R S
 160   dl = new AliDataLoader(fDetectorName + ".RecParticles.root",fgkDefaultRecParticlesContainerName, "Reconstructed Particles");
 161   tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetPIDTaskName(),
 162                                         dl,AliRunLoader::GetRunPIDTask(),kTRUE);
 163   dl->SetBaseTaskLoader(tl);
 164   fDataLoaders->AddAt(dl,kRecParticles);
 165
 166  }
 167 /*****************************************************************************/
 168
 169 AliDataLoader* AliLoader::GetDataLoader(const char* name)
 170 {
 171 //returns Data Loader with specified name
 172   return dynamic_cast<AliDataLoader*>(fDataLoaders->FindObject(name));
 173 }
 174 /*****************************************************************************/
 175
 176 Int_t AliLoader::SetEvent()
 177 {
 178  //basically the same that GetEvent but do not post data to folders
 179  TIter next(fDataLoaders);
 180  AliDataLoader* dl;
 181  while ((dl = (AliDataLoader*)next()))
 182   {
 183     dl->SetEvent();
 184   }
 185  return 0;
 186 }
 187 /******************************************************************/
 188
 189 Int_t AliLoader::GetEvent()
 190 {
 191  //changes to proper root  directory and tries to load data from files to folders
 192  // event number is defined in RunLoader
 193  //
 194  //returns:
 195  //     0  - in case of no error
 196  //     1  - event not found
 197  //
 198
 199  Int_t retval;
 200  TIter next(fDataLoaders);
 201  AliDataLoader* dl;
 202  while ((dl = (AliDataLoader*)next()))
 203   {
 204     retval = dl->GetEvent();
 205     if (retval)
 206      {
 207        Error("GetEvent","Error occured while GetEvent for %s",dl->GetName());
 208        return retval;
 209      }
 210   }
 211
 212  return 0;
 213 }
 214
 215 /******************************************************************/
 216
 217 TFolder* AliLoader::GetTopFolder()
 218 {
 219 //returns TOP aliroot folder, just a simple interface to AliConfig (gives shorter notation)
 220  return AliConfig::Instance()->GetTopFolder();
 221 }
 222
 223 /******************************************************************/
 224
 225 TFolder* AliLoader::GetEventFolder()
 226 {
 227 //get EVENT folder (data that are changing from event to event, even in single run)
 228   return fEventFolder;
 229 }
 230 /******************************************************************/
 231 TFolder* AliLoader::GetDataFolder()
 232 {
 233 //returns the folder speciofic to given detector e.g. /Folders/Event/Data/
 234  if (!fDataFolder)
 235   {
 236    fDataFolder =  dynamic_cast<TFolder*>(GetEventFolder()->FindObject(AliConfig::fgkDataFolderName));
 237
 238    if (!fDataFolder)
 239     {
 240      Fatal("GetDataFolder","Can not find AliRoot data folder. Aborting");
 241      return 0x0;
 242     }
 243   }
 244   return fDataFolder;
 245 }
 246
 247 /*****************************************************************************/
 248
 249 TFolder* AliLoader::GetTasksFolder()
 250 {
 251 //Returns pointer to Folder with Alice Tasks
 252  if (!fTasksFolder)
 253   {
 254    fTasksFolder =  dynamic_cast<TFolder*>(GetTopFolder()->FindObject(AliConfig::fgkTasksFolderName));
 255
 256    if (!fTasksFolder)
 257     {
 258      Fatal("GetTasksFolder","Can not find tasks folder. Aborting");
 259      return 0x0;
 260     }
 261   }
 262   return fTasksFolder;
 263
 264 }
 265 /*****************************************************************************/
 266
 267 TFolder* AliLoader::GetModulesFolder()
 268 {
 269  if (!fModuleFolder)
 270   {
 271    fModuleFolder =  dynamic_cast<TFolder*>(GetEventFolder()->FindObjectAny(AliConfig::GetModulesFolderName()));
 272
 273    if (!fModuleFolder)
 274     {
 275      Fatal("GetModulesFolder","Can not find modules folder. Aborting");
 276      return 0x0;
 277     }
 278   }
 279  return fModuleFolder;
 280
 281 }
 282 /*****************************************************************************/
 283
 284 TFolder* AliLoader::GetQAFolder()
 285 {
 286   //returns folder with Quality assurance
 287   if (fQAFolder == 0x0)
 288    {
 289      TObject *obj = GetEventFolder()->FindObjectAny(AliConfig::Instance()->GetQAFolderName());
 290      fQAFolder = (obj)?dynamic_cast<TFolder*>(obj):0x0;
 291
 292      if (fQAFolder == 0x0)
 293       {
 294        Fatal("GetQAFolder","Can not find Quality Assurance folder. Aborting");
 295        return 0x0;
 296       }
 297    }
 298   return fQAFolder;
 299
 300 }
 301 /*****************************************************************************/
 302 TTask* AliLoader::SDigitizer()
 303 {
 304 //returns SDigitizer task for this detector
 305   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Task();
 306
 307 }
 308 /*****************************************************************************/
 309
 310 AliDigitizer* AliLoader::Digitizer()
 311 {
 312 //returns Digitizer task for this detector
 313   return dynamic_cast<AliDigitizer*>(GetDigitsDataLoader()->GetBaseTaskLoader()->Task());
 314 }
 315 /*****************************************************************************/
 316
 317 TTask* AliLoader::Reconstructioner()
 318 {
 319 //returns Recontructioner (Cluster Finder, Cluster Maker,
 320 //or whatever you want to call it) task for this detector
 321   return GetRecPointsDataLoader()->GetBaseTaskLoader()->Task();
 322 }
 323 /*****************************************************************************/
 324
 325 TTask* AliLoader::Tracker()
 326 {
 327 //returns tracker
 328   return dynamic_cast<TTask*>(GetTracksDataLoader()->GetBaseTaskLoader()->Task());
 329 }
 330
 331 /*****************************************************************************/
 332 TTask* AliLoader::PIDTask()
 333 {
 334 //returns tracker
 335   return dynamic_cast<TTask*>(GetRecParticlesDataLoader()->GetBaseTaskLoader()->Task());
 336 }
 337
 338 /*****************************************************************************/
 339
 340 TTask* AliLoader::QAtask(const char* name)
 341 {
 342   TTask* qat = AliRunLoader::GetRunQATask();
 343   if ( qat == 0x0 )
 344    {
 345     Error("QAtask","Can not get RunQATask. (Name:%s)",GetName());
 346     return 0x0;
 347    }
 348
 349   TString dqatname(fDetectorName + AliConfig::Instance()->GetQATaskName());
 350   TTask* dqat = dynamic_cast<TTask*>(qat->GetListOfTasks()->FindObject(dqatname));
 351
 352   if ( dqat == 0x0 )
 353    {
 354     Error("QAtask","Can not find QATask in RunQATask for %s",GetDetectorName().Data());
 355     return 0x0;
 356    }
 357
 358   if (strlen(name) == 0) return dqat;
 359
 360   TList* list = dqat->GetListOfTasks();
 361
 362   TIter it(list) ;
 363   TTask * task = 0 ;
 364   while((task = static_cast<TTask *>(it.Next()) ))
 365    {
 366     TString taskname(task->GetName()) ;
 367     if(taskname.BeginsWith(name))
 368       return task ;
 369    }
 370   Error("QAtask","Can not find sub-task with name starting with %s in task %s",name,dqat->GetName());
 371   return 0x0;
 372 }
 373 /*****************************************************************************/
 374
 375 TDirectory* AliLoader::ChangeDir(TFile* file, Int_t eventno)
 376 {
 377 //changes the root directory in "file" to "dirname" which corresponds to event 'eventno'
 378 //in case of success returns the pointer to directory
 379 //else NULL
 380
 381  if (file == 0x0)
 382   {
 383     ::Error("AliLoader::ChangeDir","File is null");
 384     return 0x0;
 385   }
 386  if (file->IsOpen() == kFALSE)
 387   {
 388     ::Error("AliLoader::ChangeDir","File is not opened");
 389     return 0x0;
 390   }
 391
 392  TString dirname("Event");
 393  dirname+=eventno;
 394  if (AliLoader::fgDebug > 1)
 395    ::Info("AliLoader::ChangeDir","Changing Dir to %s in file %s.",dirname.Data(),file->GetName());
 396
 397  Bool_t result;
 398
 399  TDirectory* dir = dynamic_cast<TDirectory*>(file->Get(dirname));
 400
 401  if (dir == 0x0)
 402   {
 403     if (AliLoader::fgDebug > 1)
 404      ::Info("AliLoader::ChangeDir","Can not find directory %s in file %s, creating...",
 405             dirname.Data(),file->GetName());
 406
 407     if (file->IsWritable() == kFALSE)
 408      {
 409        ::Error("AliLoader::ChangeDir","Can not create directory. File %s in not writable.",
 410                 file->GetName());
 411        return 0x0;
 412      }
 413
 414     TDirectory* newdir = file->mkdir(dirname);
 415     if (newdir == 0x0)
 416      {
 417        ::Error("AliLoader::ChangeDir","Failed to create new directory in file %s.",
 418                file->GetName());
 419        return 0x0;
 420      }
 421     result = file->cd(dirname);
 422     if (result == kFALSE)
 423      {
 424        return 0x0;
 425      }
 426   }
 427  else
 428   {
 429    file->cd();//make a file active
 430    file->cd(dirname);//cd event dir
 431   }
 432
 433  return gDirectory;
 434 }
 435 /*****************************************************************************/
 436
 437 TString AliLoader::GetUnixDir()
 438  {
 439  //This Method will manage jumping through unix directories in case of
 440  //run with more events per run than defined in gAlice
 441
 442    TString dir;
 443
 444    return dir;
 445  }
 446 /*****************************************************************************/
 447 /************************************************************/
 448
 449 void AliLoader::MakeTree(Option_t *option)
 450  {
 451 //Makes a tree depending on option
 452 //   H: - Hits
 453 //   D: - Digits
 454 //   S: - Summable Digits
 455 //   R: - Reconstructed Points (clusters)
 456 //   T: - Tracks (tracklets)
 457
 458   const char *oH = strstr(option,"H");
 459   const char *oD = strstr(option,"D");
 460   const char *oS = strstr(option,"S");
 461   const char *oR = strstr(option,"R");
 462   const char *oT = strstr(option,"T");
 463   const char *oP = strstr(option,"P");
 464
 465   if (oH) MakeHitsContainer();
 466   if (oD) MakeDigitsContainer();
 467   if (oS) MakeSDigitsContainer();
 468   if (oR) MakeRecPointsContainer();
 469   if (oT) MakeTracksContainer();
 470   if (oP) MakeRecParticlesContainer();
 471  }
 472
 473 /*****************************************************************************/
 474 Int_t  AliLoader::WriteHits(Option_t* opt)
 475  {
 476    AliDataLoader* dl = GetHitsDataLoader();
 477    Int_t ret = dl->WriteData(opt);
 478    return ret;
 479  }
 480 /*****************************************************************************/
 481
 482 Int_t AliLoader::WriteSDigits(Option_t* opt)
 483  {
 484    AliDataLoader* dl = GetSDigitsDataLoader();
 485    Int_t ret = dl->WriteData(opt);
 486    return ret;
 487  }
 488
 489 /*****************************************************************************/
 490
 491 Int_t AliLoader::PostSDigitizer(TTask* sdzer)
 492 {
 493   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Post(sdzer);
 494 }
 495 /*****************************************************************************/
 496
 497 Int_t AliLoader::PostDigitizer(AliDigitizer* task)
 498  {
 499   return GetDigitsDataLoader()->GetBaseTaskLoader()->Post(task);
 500  }
 501 /*****************************************************************************/
 502
 503 Int_t AliLoader::PostReconstructioner(TTask* task)
 504  {
 505   return GetRecPointsDataLoader()->GetBaseTaskLoader()->Post(task);
 506  }
 507 /*****************************************************************************/
 508
 509 Int_t AliLoader::PostTracker(TTask* task)
 510  {
 511   return GetTracksDataLoader()->GetBaseTaskLoader()->Post(task);
 512  }
 513 /*****************************************************************************/
 514
 515 Int_t AliLoader::PostPIDTask(TTask* task)
 516  {
 517   return GetRecParticlesDataLoader()->GetBaseTaskLoader()->Post(task);
 518  }
 519 /*****************************************************************************/
 520
 521 TObject** AliLoader::GetDetectorDataRef(TObject *obj)
 522 {
 523  if (obj == 0x0)
 524   {
 525     return 0x0;
 526   }
 527  return GetDetectorDataFolder()->GetListOfFolders()->GetObjectRef(obj) ;
 528 }
 529 /*****************************************************************************/
 530
 531 TObject** AliLoader::SDigitizerRef()
 532 {
 533   TTask* rsd = AliRunLoader::GetRunSDigitizer();
 534   if (rsd == 0x0)
 535    {
 536      return 0x0;
 537    }
 538   return rsd->GetListOfTasks()->GetObjectRef(SDigitizer());
 539 }
 540 /*****************************************************************************/
 541
 542 TObject** AliLoader::DigitizerRef()
 543 {
 544  TTask* rd = AliRunLoader::GetRunDigitizer();
 545  if (rd == 0x0)
 546   {
 547     return 0x0;
 548   }
 549  return rd->GetListOfTasks()->GetObjectRef(Digitizer()) ;
 550 }
 551 /*****************************************************************************/
 552
 553 TObject** AliLoader::ReconstructionerRef()
 554 {
 555   TTask* rrec = AliRunLoader::GetRunReconstructioner();
 556   if (rrec == 0x0)
 557    {
 558      return 0x0;
 559    }
 560   return rrec->GetListOfTasks()->GetObjectRef(Reconstructioner());
 561 }
 562 /*****************************************************************************/
 563
 564 TObject** AliLoader::TrackerRef()
 565 {
 566    TTask* rrec = AliRunLoader::GetRunTracker();
 567    if (rrec == 0x0)
 568     {
 569       return 0x0;
 570     }
 571    return rrec->GetListOfTasks()->GetObjectRef(Tracker());
 572 }
 573 /*****************************************************************************/
 574
 575 TObject** AliLoader::PIDTaskRef()
 576 {
 577   TTask* rrec = AliRunLoader::GetRunPIDTask();
 578   if (rrec == 0x0)
 579    {
 580      return 0x0;
 581    }
 582   return rrec->GetListOfTasks()->GetObjectRef(PIDTask());
 583 }
 584
 585 /*****************************************************************************/
 586 void AliLoader::CleanFolders()
 587  {
 588  //Cleans all posted objects == removes from folders and deletes them
 589    TIter next(fDataLoaders);
 590    AliDataLoader* dl;
 591    while ((dl = (AliDataLoader*)next()))
 592     {
 593       if (GetDebug()) Info("CleanFolders","name = %s cleaning",dl->GetName());
 594       dl->Clean();
 595     }
 596  }
 597 /*****************************************************************************/
 598
 599 /*****************************************************************************/
 600
 601 void AliLoader::CleanSDigitizer()
 602 {
 603 //removes and deletes detector task from Run Task
 604   TTask* task = AliRunLoader::GetRunSDigitizer();
 605   if (task == 0x0)
 606    {
 607      Error("CleanSDigitizer","Can not get RunSDigitizer from folder. Can not clean");
 608      return;
 609    }
 610
 611   if (GetDebug()) Info("CleanSDigitizer","Attempting to delete S Digitizer");
 612   delete task->GetListOfTasks()->Remove(SDigitizer()); //TTList::Remove does not delete object
 613 }
 614 /*****************************************************************************/
 615
 616 void AliLoader::CleanDigitizer()
 617 {
 618 //removes and deletes detector task from Run Task
 619   TTask* task = AliRunLoader::GetRunDigitizer();
 620   if (task == 0x0)
 621    {
 622      Error("CleanDigitizer","Can not get RunDigitizer from folder. Can not clean");
 623      return;
 624    }
 625
 626   if (GetDebug())
 627    Info("CleanDigitizer","Attempting to delete Digitizer %X",
 628          task->GetListOfTasks()->Remove(Digitizer()));
 629   delete task->GetListOfTasks()->Remove(Digitizer()); //TTList::Remove does not delete object
 630 }
 631 /*****************************************************************************/
 632
 633 void AliLoader::CleanReconstructioner()
 634 {
 635 //removes and deletes detector Reconstructioner from Run Reconstructioner
 636   TTask* task = AliRunLoader::GetRunReconstructioner();
 637   if (task == 0x0)
 638    {
 639      Error("CleanReconstructioner","Can not get RunReconstructioner from folder. Can not clean");
 640      return;
 641    }
 642
 643   if (GetDebug())
 644    Info("CleanReconstructioner","Attempting to delete Reconstructioner");
 645   delete task->GetListOfTasks()->Remove(Reconstructioner()); //TTList::Remove does not delete object
 646 }
 647 /*****************************************************************************/
 648
 649 void AliLoader::CleanTracker()
 650 {
 651 //removes and deletes detector tracker from Run Tracker
 652   TTask* task = AliRunLoader::GetRunTracker();
 653   if (task == 0x0)
 654    {
 655      Error("CleanTracker","Can not get RunTracker from folder. Can not clean");
 656      return;
 657    }
 658
 659   if (GetDebug())
 660    Info("CleanTracker","Attempting to delete Tracker %X",
 661          task->GetListOfTasks()->Remove(Tracker()));
 662   delete task->GetListOfTasks()->Remove(Tracker()); //TTList::Remove does not delete object
 663 }
 664 /*****************************************************************************/
 665
 666 void AliLoader::CleanPIDTask()
 667 {
 668 //removes and deletes detector Reconstructioner from Run Reconstructioner
 669   TTask* task = AliRunLoader::GetRunPIDTask();
 670   if (task == 0x0)
 671    {
 672      Error("CleanPIDTask","Can not get Run PID Task from folder. Can not clean");
 673      return;
 674    }
 675
 676   if (GetDebug())
 677    Info("CleanPIDTask","Attempting to delete PID Task");
 678   delete task->GetListOfTasks()->Remove(PIDTask()); //TTList::Remove does not delete object
 679 }
 680 /*****************************************************************************/
 681
 682 Int_t AliLoader::ReloadAll()
 683 {
 684  TIter next(fDataLoaders);
 685  AliDataLoader* dl;
 686
 687  while((dl = (AliDataLoader*)next()))
 688   {
 689    Int_t err = dl->Reload();
 690    if (err)
 691     {
 692       Error("ReloadAll","Reload returned error for %s",dl->GetName());
 693       return err;
 694     }
 695   }
 696  return 0;
 697 }
 698 /*****************************************************************************/
 699
 700 void AliLoader::CloseFiles()
 701 {
 702 //close files for data loaders
 703  TIter next(fDataLoaders);
 704  AliDataLoader* dl;
 705  while((dl = (AliDataLoader*)next()))
 706   {
 707    dl->CloseFile();
 708   }
 709 }
 710 /*****************************************************************************/
 711
 712 Int_t  AliLoader::SetEventFolder(TFolder* eventfolder)
 713 {
 714  if (eventfolder == 0x0)
 715   {
 716     Error("SetEventFolder","Stupid joke. Argument is NULL");
 717     return 1;
 718   }
 719
 720  fEventFolder = eventfolder;
 721  TIter next(fDataLoaders);
 722  AliDataLoader* dl;
 723
 724  while((dl = (AliDataLoader*)next()))
 725   {
 726     dl->SetEventFolder(fEventFolder);
 727     dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
 728   }
 729
 730  return 0;
 731 }//sets the event folder
 732 /*****************************************************************************/
 733
 734 Int_t AliLoader::Register(TFolder* eventFolder)
 735 {
 736 //triggers creation of subfolders for a given detector
 737 //this method is called when session is read from disk
 738 //
 739 //warning: AliDetector in constructor (not default) calls
 740 //creation of folder structure as well (some detectors needs folders
 741 //alrady in constructors)
 742
 743  if (GetDebug()) Info("Register","Name is %s.",GetName());
 744  if (eventFolder == 0x0)
 745   {
 746     Error("Register","Event folder is not set.");
 747     return 1;
 748   }
 749  Int_t retval = AliConfig::Instance()->AddDetector(eventFolder,fDetectorName,fDetectorName);
 750  if(retval)
 751   {
 752     Error("SetEventFolder","Can not create tasks and/or folders for %s. Event folder name is %s",
 753           fDetectorName.Data(),eventFolder->GetName());
 754     return retval;
 755   }
 756  SetEventFolder(eventFolder);
 757  return 0;
 758 }
 759 /*****************************************************************************/
 760 AliRunLoader* AliLoader::GetRunLoader()
 761 {
 762 //gets the run-loader from event folder
 763   AliRunLoader* rg = 0x0;
 764   TObject * obj = GetEventFolder()->FindObject(AliRunLoader::fgkRunLoaderName);
 765   if (obj) rg = dynamic_cast<AliRunLoader*>(obj);
 766   return rg;
 767 }
 768 /*****************************************************************************/
 769 Bool_t  AliLoader::TestFileOption(Option_t* opt)
 770 {
 771 //tests the TFile::Option
 772 //if file is truncated at opening moment ("recreate", "new" or "create") returns kFALSE;
 773 //else kTRUE (means opened with "read" or "update" mode)
 774   TString option(opt);
 775   if (option.CompareTo("recreate",TString::kIgnoreCase) == 0) return kFALSE;
 776   if (option.CompareTo("new",TString::kIgnoreCase) == 0) return kFALSE;
 777   if (option.CompareTo("create",TString::kIgnoreCase) == 0) return kFALSE;
 778   return kTRUE;
 779 }
 780 /*****************************************************************************/
 781 void  AliLoader::SetDirName(TString& dirname)
 782 {
 783 //adds "dirname/" to each file
 784   TIter next(fDataLoaders);
 785   AliDataLoader* dl;
 786   while((dl = (AliDataLoader*)next()))
 787    {
 788     dl->SetDirName(dirname);
 789    }
 790 }
 791
 792 /*****************************************************************************/
 793
 794 void AliLoader::SetDigitsFileNameSuffix(const TString& suffix)
 795 {
 796   //adds the suffix before ".root",
 797   //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
 798   //made on Jiri Chudoba demand
 799   GetDigitsDataLoader()->SetFileNameSuffix(suffix);
 800 }
 801 /*****************************************************************************/
 802
 803 void AliLoader::SetCompressionLevel(Int_t cl)
 804 {
 805 //sets comression level for data defined by di
 806   TIter next(fDataLoaders);
 807   AliDataLoader* dl;
 808   while((dl = (AliDataLoader*)next()))
 809    {
 810      dl->SetCompressionLevel(cl);
 811    }
 812 }
 813 /*****************************************************************************/
 814
 815 void AliLoader::Clean()
 816 {
 817 //Cleans all data loaders
 818   TIter next(fDataLoaders);
 819   AliDataLoader* dl;
 820   while((dl = (AliDataLoader*)next()))
 821    {
 822      dl->Clean();
 823    }
 824 }
 825 /*****************************************************************************/
 826
 827 void AliLoader::Clean(const TString& name)
 828 {
 829   TObject* obj = GetDetectorDataFolder()->FindObject(name);
 830   if(obj)
 831    {
 832      if (GetDebug())
 833        Info("Clean(const TString&)","name=%s, cleaning %s.",GetName(),name.Data());
 834      GetDetectorDataFolder()->Remove(obj);
 835      delete obj;
 836    }
 837 }
 838
 839 /*****************************************************************************/
 840
 841 Bool_t AliLoader::IsOptionWritable(const TString& opt)
 842 {
 843   if (opt.CompareTo("recreate",TString::kIgnoreCase)) return kTRUE;
 844   if (opt.CompareTo("new",TString::kIgnoreCase)) return kTRUE;
 845   if (opt.CompareTo("create",TString::kIgnoreCase)) return kTRUE;
 846   if (opt.CompareTo("update",TString::kIgnoreCase)) return kTRUE;
 847   return kFALSE;
 848 }
 849 /*****************************************************************************/
 850
 851 void AliLoader::SetTAddrInDet()
 852 {
 853   //calls SetTreeAddress for corresponding detector
 854   AliRunLoader* rl = GetRunLoader();
 855   if (rl == 0x0) return;
 856   AliRun* ar = rl->GetAliRun();
 857   if (ar == 0x0) return;
 858   AliDetector* det = ar->GetDetector(fDetectorName);
 859   if (det == 0x0) return;
 860   det->SetTreeAddress();
 861 }
 862 /*****************************************************************************/
 863
 864 void AliLoader::Synchronize()
 865 {
 866   //synchrinizes all writtable files
 867  TIter next(fDataLoaders);
 868  AliDataLoader* dl;
 869  while ((dl = (AliDataLoader*)next()))
 870   {
 871     dl->Synchronize();
 872   }
 873
 874 }
 875 /*****************************************************************************/
 876 /*****************************************************************************/
 877 /*****************************************************************************/
 878