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