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 <TFile.h>
  15 #include <TFolder.h>
  16 #include <TString.h>
  17 #include <TTask.h>
  18
  19 //AliRoot includes
  20 #include "AliConfig.h"
  21 #include "AliDetector.h"
  22 #include "AliDigitizer.h"
  23 #include "AliLog.h"
  24 #include "AliRun.h"
  25 #include "AliRunLoader.h"
  26
  27 const TString AliLoader::fgkDefaultHitsContainerName("TreeH");
  28 const TString AliLoader::fgkDefaultDigitsContainerName = "TreeD";
  29 const TString AliLoader::fgkDefaultSDigitsContainerName = "TreeS";
  30 const TString AliLoader::fgkDefaultRecPointsContainerName = "TreeR";
  31 const TString AliLoader::fgkDefaultTracksContainerName = "TreeT";
  32 const TString AliLoader::fgkDefaultRecParticlesContainerName = "TreeP";
  33 const TString AliLoader::fgkLoaderBaseName("Loader");
  34
  35 ClassImp(AliLoader)
  36 //___________________________________________________________________
  37 /////////////////////////////////////////////////////////////////////
  38 //                                                                 //
  39 //  class AliLoader                                                //
  40 //                                                                 //
  41 //  Base class for Loaders.                                        //
  42 //  Loader provides base I/O fascilities for "standard" data.      //
  43 //  Each detector has a laoder data member                         //
  44 //  loader is accessible via folder structure as well              //
  45 //                                                                 //
  46 /////////////////////////////////////////////////////////////////////
  47
  48 /*****************************************************************************/
  49
  50 AliLoader::AliLoader():
  51  fDataLoaders(0x0),
  52  fDetectorName(""),
  53  fEventFolder(0x0),
  54  fDataFolder(0x0),
  55  fDetectorDataFolder(0x0),
  56  fModuleFolder(0x0),
  57  fTasksFolder(0x0),
  58  fQAFolder(0x0)
  59 {
  60 //default constructor
  61
  62  }
  63 /******************************************************************/
  64
  65 AliLoader::AliLoader(const Char_t* detname,const Char_t* eventfoldername):
  66  fDataLoaders(new TObjArray(kNDataTypes)),
  67  fDetectorName(""),
  68  fEventFolder(0x0),
  69  fDataFolder(0x0),
  70  fDetectorDataFolder(0x0),
  71  fModuleFolder(0x0),
  72  fTasksFolder(0x0),
  73  fQAFolder(0x0)
  74 {
  75   //ctor
  76    AliDebug(1, Form("detname = %s eventfoldername = %s",detname,eventfoldername));
  77
  78    //try to find folder eventfoldername in top alice folder
  79    //safe because GetTopFolder will abort in case of failure
  80
  81    fDetectorName = detname;
  82    fName = fDetectorName+"Loader";
  83    InitDefaults();
  84
  85    TObject* fobj = GetTopFolder()->FindObject(eventfoldername);
  86    fEventFolder = (fobj)?dynamic_cast<TFolder*>(fobj):0x0;//in case FindObject returns NULL dynamic cast cause seg. fault
  87    SetEventFolder(fEventFolder);
  88
  89  }
  90 /*****************************************************************************/
  91
  92 AliLoader::AliLoader(const Char_t * detname,TFolder* eventfolder):
  93  fDataLoaders(new TObjArray(kNDataTypes)),
  94  fDetectorName(detname),
  95  fEventFolder(0x0),
  96  fDataFolder(0x0),
  97  fDetectorDataFolder(0x0),
  98  fModuleFolder(0x0),
  99  fTasksFolder(0x0),
 100  fQAFolder(0x0)
 101 {
 102 //constructor
 103    fDetectorName = detname;
 104    fName = fDetectorName+"Loader";
 105    InitDefaults();
 106    SetEventFolder(eventfolder);
 107    //fileoption's don't need to initialized because default TString ctor does it correctly
 108 }
 109 /*****************************************************************************/
 110 AliLoader::AliLoader(const AliLoader& source) :
 111   TNamed(source),
 112   fDataLoaders(source.fDataLoaders),
 113   fDetectorName(source.fDetectorName),
 114   fEventFolder(source.fEventFolder),
 115   fDataFolder(source.fDataFolder),
 116   fDetectorDataFolder(source.fDetectorDataFolder),
 117   fModuleFolder(source.fModuleFolder),
 118   fTasksFolder(source.fTasksFolder),
 119   fQAFolder(source.fQAFolder)
 120 {
 121   // dummy copy constructor
 122   if(&source==this)return;
 123
 124   AliFatal("Copy constructor not implemented. Aborting");
 125   return;
 126 }
 127
 128 /*****************************************************************************/
 129 AliLoader& AliLoader::operator=(const AliLoader& source) {
 130   // dummy assignment operator
 131   if(&source==this) return *this;
 132
 133   AliFatal("Assignment operator not implemented. Aborting");
 134   return *this;
 135 }
 136
 137 /*****************************************************************************/
 138 AliLoader::~AliLoader()
 139 {
 140 //detructor
 141   if (fDataLoaders) fDataLoaders->SetOwner();
 142   delete fDataLoaders;
 143 }
 144 /*****************************************************************************/
 145
 146 void AliLoader::InitDefaults()
 147 {
 148   // H I T S
 149   AliDataLoader* dl;
 150   dl = new AliDataLoader(fDetectorName + ".Hits.root",fgkDefaultHitsContainerName, "Hits" );
 151   fDataLoaders->AddAt(dl,kHits);
 152
 153
 154   // S U M M A B L E   D I G I T S
 155   dl = new AliDataLoader(fDetectorName + ".SDigits.root",fgkDefaultSDigitsContainerName, "Summable Digits");
 156   AliTaskLoader* tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetSDigitizerTaskName(),
 157                                         dl,AliRunLoader::GetRunSDigitizer(),kTRUE);
 158   dl->SetBaseTaskLoader(tl);
 159   fDataLoaders->AddAt(dl,kSDigits);
 160
 161   // D I G I T S
 162   dl = new AliDataLoader(fDetectorName + ".Digits.root",fgkDefaultDigitsContainerName, "Digits");
 163   tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetDigitizerTaskName(),
 164                                         dl,AliRunLoader::GetRunDigitizer(),kTRUE);
 165   dl->SetBaseTaskLoader(tl);
 166   fDataLoaders->AddAt(dl,kDigits);
 167
 168   // 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
 169   dl = new AliDataLoader(fDetectorName + ".RecPoints.root",fgkDefaultRecPointsContainerName, "Reconstructed Points");
 170   tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetReconstructionerTaskName(),
 171                                         dl,AliRunLoader::GetRunReconstructioner(),kTRUE);
 172   dl->SetBaseTaskLoader(tl);
 173   fDataLoaders->AddAt(dl,kRecPoints);
 174
 175   // T R A C K S
 176   dl = new AliDataLoader(fDetectorName + ".Tracks.root",fgkDefaultTracksContainerName, "Tracks");
 177   tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetTrackerTaskName(),
 178                                         dl,AliRunLoader::GetRunTracker(),kTRUE);
 179   dl->SetBaseTaskLoader(tl);
 180   fDataLoaders->AddAt(dl,kTracks);
 181
 182   // 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
 183   dl = new AliDataLoader(fDetectorName + ".RecParticles.root",fgkDefaultRecParticlesContainerName, "Reconstructed Particles");
 184   tl = new AliTaskLoader(fDetectorName + AliConfig::Instance()->GetPIDTaskName(),
 185                                         dl,AliRunLoader::GetRunPIDTask(),kTRUE);
 186   dl->SetBaseTaskLoader(tl);
 187   fDataLoaders->AddAt(dl,kRecParticles);
 188
 189  }
 190 /*****************************************************************************/
 191
 192 AliDataLoader* AliLoader::GetDataLoader(const char* name)
 193 {
 194 //returns Data Loader with specified name
 195   return dynamic_cast<AliDataLoader*>(fDataLoaders->FindObject(name));
 196 }
 197 /*****************************************************************************/
 198 void AliLoader::AddDataLoader(AliDataLoader* dl)
 199 {
 200   //
 201   // Adds a data loader
 202   //
 203   if (dl == 0x0)
 204    {
 205      AliError("Pointer is NULL");
 206      return;
 207    }
 208   if (fDataLoaders->FindObject(dl->GetName()))
 209    {
 210      AliError("Such a loader exists");
 211      return;
 212    }
 213   fDataLoaders->AddLast(dl);
 214   dl->SetEventFolder(fEventFolder);
 215   dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
 216 }
 217 /*****************************************************************************/
 218
 219 Int_t AliLoader::SetEvent()
 220 {
 221  //basically the same that GetEvent but do not post data to folders
 222  TIter next(fDataLoaders);
 223  AliDataLoader* dl;
 224  while ((dl = (AliDataLoader*)next()))
 225   {
 226     dl->SetEvent();
 227   }
 228  return 0;
 229 }
 230 /******************************************************************/
 231
 232 void AliLoader::UnloadAll()
 233 {
 234  //calls UnloadAll for all base laoders
 235  //Unloads everything
 236  TIter next(fDataLoaders);
 237  AliDataLoader* dl;
 238  while ((dl = (AliDataLoader*)next()))
 239   {
 240     dl->UnloadAll();
 241   }
 242 }
 243 /******************************************************************/
 244
 245 Int_t AliLoader::GetEvent()
 246 {
 247  //changes to proper root  directory and tries to load data from files to folders
 248  // event number is defined in RunLoader
 249  //
 250  //returns:
 251  //     0  - in case of no error
 252  //     1  - event not found
 253  //
 254
 255  Int_t retval;
 256  TIter next(fDataLoaders);
 257  AliDataLoader* dl;
 258  while ((dl = (AliDataLoader*)next()))
 259   {
 260     retval = dl->GetEvent();
 261     if (retval)
 262      {
 263        AliError(Form("Error occured while GetEvent for %s",dl->GetName()));
 264        return retval;
 265      }
 266   }
 267
 268  return 0;
 269 }
 270
 271 /******************************************************************/
 272
 273 TFolder* AliLoader::GetTopFolder()
 274 {
 275 //returns TOP aliroot folder, just a simple interface to AliConfig (gives shorter notation)
 276  return AliConfig::Instance()->GetTopFolder();
 277 }
 278
 279 /******************************************************************/
 280
 281 TFolder* AliLoader::GetEventFolder()
 282 {
 283 //get EVENT folder (data that are changing from event to event, even in single run)
 284   return fEventFolder;
 285 }
 286 /******************************************************************/
 287 TFolder* AliLoader::GetDataFolder()
 288 {
 289 //returns the folder speciofic to given detector e.g. /Folders/Event/Data/
 290  if (!fDataFolder)
 291   {
 292    fDataFolder =  dynamic_cast<TFolder*>(GetEventFolder()->FindObject(AliConfig::Instance()->GetDataFolderName()));
 293
 294    if (!fDataFolder)
 295     {
 296      AliFatal("Can not find AliRoot data folder. Aborting");
 297      return 0x0;
 298     }
 299   }
 300   return fDataFolder;
 301 }
 302
 303 /*****************************************************************************/
 304
 305 TFolder* AliLoader::GetTasksFolder()
 306 {
 307 //Returns pointer to Folder with Alice Tasks
 308  if (!fTasksFolder)
 309   {
 310    fTasksFolder =  dynamic_cast<TFolder*>(GetTopFolder()->FindObject(AliConfig::GetTasksFolderName()));
 311
 312    if (!fTasksFolder)
 313     {
 314      AliFatal("Can not find tasks folder. Aborting");
 315      return 0x0;
 316     }
 317   }
 318   return fTasksFolder;
 319
 320 }
 321 /*****************************************************************************/
 322
 323 TFolder* AliLoader::GetModulesFolder()
 324 {
 325   //returns pointer to the folder containing modules
 326  if (!fModuleFolder)
 327   {
 328    fModuleFolder =  dynamic_cast<TFolder*>(GetEventFolder()->FindObjectAny(AliConfig::GetModulesFolderName()));
 329
 330    if (!fModuleFolder)
 331     {
 332      AliFatal("Can not find modules folder. Aborting");
 333      return 0x0;
 334     }
 335   }
 336  return fModuleFolder;
 337
 338 }
 339 /*****************************************************************************/
 340
 341 TFolder* AliLoader::GetQAFolder()
 342 {
 343   //returns folder with Quality assurance
 344   if (fQAFolder == 0x0)
 345    {
 346      TObject *obj = GetEventFolder()->FindObjectAny(AliConfig::Instance()->GetQAFolderName());
 347      fQAFolder = (obj)?dynamic_cast<TFolder*>(obj):0x0;
 348
 349      if (fQAFolder == 0x0)
 350       {
 351        AliFatal("Can not find Quality Assurance folder. Aborting");
 352        return 0x0;
 353       }
 354    }
 355   return fQAFolder;
 356
 357 }
 358 /*****************************************************************************/
 359 TTask* AliLoader::SDigitizer() const
 360 {
 361 //returns SDigitizer task for this detector
 362   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Task();
 363
 364 }
 365 /*****************************************************************************/
 366
 367 AliDigitizer* AliLoader::Digitizer() const
 368 {
 369 //returns Digitizer task for this detector
 370   return dynamic_cast<AliDigitizer*>(GetDigitsDataLoader()->GetBaseTaskLoader()->Task());
 371 }
 372 /*****************************************************************************/
 373
 374 TTask* AliLoader::Reconstructioner() const
 375 {
 376 //returns Recontructioner (Cluster Finder, Cluster Maker,
 377 //or whatever you want to call it) task for this detector
 378   return GetRecPointsDataLoader()->GetBaseTaskLoader()->Task();
 379 }
 380 /*****************************************************************************/
 381
 382 TTask* AliLoader::Tracker() const
 383 {
 384 //returns tracker
 385   return dynamic_cast<TTask*>(GetTracksDataLoader()->GetBaseTaskLoader()->Task());
 386 }
 387
 388 /*****************************************************************************/
 389 TTask* AliLoader::PIDTask() const
 390 {
 391 //returns tracker
 392   return dynamic_cast<TTask*>(GetRecParticlesDataLoader()->GetBaseTaskLoader()->Task());
 393 }
 394
 395 /*****************************************************************************/
 396
 397 TTask* AliLoader::QAtask(const char* name) const
 398 {
 399   // Returns pointer to the quality assurance task
 400   TTask* qat = AliRunLoader::GetRunQATask();
 401   if ( qat == 0x0 )
 402    {
 403     AliError(Form("Can not get RunQATask. (Name:%s)",GetName()));
 404     return 0x0;
 405    }
 406
 407   TString dqatname(fDetectorName + AliConfig::Instance()->GetQATaskName());
 408   TTask* dqat = dynamic_cast<TTask*>(qat->GetListOfTasks()->FindObject(dqatname));
 409
 410   if ( dqat == 0x0 )
 411    {
 412     AliError(Form("Can not find QATask in RunQATask for %s",GetDetectorName().Data()));
 413     return 0x0;
 414    }
 415
 416   if (strlen(name) == 0) return dqat;
 417
 418   TList* list = dqat->GetListOfTasks();
 419
 420   TIter it(list) ;
 421   TTask * task = 0 ;
 422   while((task = static_cast<TTask *>(it.Next()) ))
 423    {
 424     TString taskname(task->GetName()) ;
 425     if(taskname.BeginsWith(name))
 426       return task ;
 427    }
 428   AliError(Form("Can not find sub-task with name starting with %s in task %s",name,dqat->GetName()));
 429   return 0x0;
 430 }
 431 /*****************************************************************************/
 432
 433 TDirectory* AliLoader::ChangeDir(TFile* file, Int_t eventno)
 434 {
 435 //changes the root directory in "file" to "dirname" which corresponds to event 'eventno'
 436 //in case of success returns the pointer to directory
 437 //else NULL
 438
 439  if (file == 0x0)
 440   {
 441     AliErrorClass("File is null");
 442     return 0x0;
 443   }
 444  if (file->IsOpen() == kFALSE)
 445   {
 446     AliErrorClass("File is not opened");
 447     return 0x0;
 448   }
 449
 450  TString dirname("Event");
 451  dirname+=eventno;
 452  AliDebugClass(1, Form("Changing Dir to %s in file %s.",dirname.Data(),file->GetName()));
 453
 454  Bool_t result;
 455
 456  TDirectory* dir = dynamic_cast<TDirectory*>(file->Get(dirname));
 457
 458  if (dir == 0x0)
 459   {
 460     AliDebugClass(1, Form("Can not find directory %s in file %s, creating...",
 461                      dirname.Data(),file->GetName()));
 462
 463     if (file->IsWritable() == kFALSE)
 464      {
 465        AliErrorClass(Form("Can not create directory. File %s in not writable.",
 466                      file->GetName()));
 467        return 0x0;
 468      }
 469
 470     TDirectory* newdir = file->mkdir(dirname);
 471     if (newdir == 0x0)
 472      {
 473        AliErrorClass(Form("Failed to create new directory in file %s.",
 474                      file->GetName()));
 475        return 0x0;
 476      }
 477     result = file->cd(dirname);
 478     if (result == kFALSE)
 479      {
 480        return 0x0;
 481      }
 482   }
 483  else
 484   {
 485    file->cd();//make a file active
 486    file->cd(dirname);//cd event dir
 487   }
 488
 489  return gDirectory;
 490 }
 491 /*****************************************************************************/
 492
 493 TString AliLoader::GetUnixDir() const
 494  {
 495  //This Method will manage jumping through unix directories in case of
 496  //run with more events per run than defined in gAlice
 497
 498    TString dir;
 499
 500    return dir;
 501  }
 502 /*****************************************************************************/
 503 /************************************************************/
 504
 505 void AliLoader::MakeTree(Option_t *option)
 506  {
 507 //Makes a tree depending on option
 508 //   H: - Hits
 509 //   D: - Digits
 510 //   S: - Summable Digits
 511 //   R: - Reconstructed Points (clusters)
 512 //   T: - Tracks (tracklets)
 513 //   GG: - Trigger
 514
 515   const char *oH = strstr(option,"H");
 516   const char *oD = strstr(option,"D");
 517   const char *oS = strstr(option,"S");
 518   const char *oR = strstr(option,"R");
 519   const char *oT = strstr(option,"T");
 520   const char *oP = strstr(option,"P");
 521   const char *oGG = strstr(option,"GG");
 522
 523   if (oH) MakeHitsContainer();
 524   if (oD) MakeDigitsContainer();
 525   if (oS) MakeSDigitsContainer();
 526   if (oR) MakeRecPointsContainer();
 527   if (oT) MakeTracksContainer();
 528   if (oP) MakeRecParticlesContainer();
 529   if (oGG) AliError("Don't know how to create a trigger tree");
 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. Dirname should end with "#","/", or ":"
 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
 908 void AliLoader::SetDebug(Int_t deb)
 909 {
 910   // Sets debug level
 911   AliLog::SetClassDebugLevel("AliRunLoader", deb);
 912   AliLog::SetClassDebugLevel("AliLoader", deb);
 913   AliLog::SetClassDebugLevel("AliDataLoader", deb);
 914   AliLog::SetClassDebugLevel("AliBaseLoader", deb);
 915   AliLog::SetClassDebugLevel("AliObjectLoader", deb);
 916   AliLog::SetClassDebugLevel("AliTreeLoader", deb);
 917   AliLog::SetClassDebugLevel("AliTaskLoader", deb);
 918   AliLog::SetClassDebugLevel("AliConfig", deb);
 919 }
 920 /*****************************************************************************/
 921
 922 void AliLoader::SetTAddrInDet()
 923 {
 924   //calls SetTreeAddress for corresponding detector
 925   AliRunLoader* rl = GetRunLoader();
 926   if (rl == 0x0) return;
 927   AliRun* ar = rl->GetAliRun();
 928   if (ar == 0x0) return;
 929   AliDetector* det = ar->GetDetector(fDetectorName);
 930   if (det == 0x0) return;
 931   det->SetTreeAddress();
 932 }
 933 /*****************************************************************************/
 934
 935 void AliLoader::Synchronize()
 936 {
 937   //synchrinizes all writtable files
 938  TIter next(fDataLoaders);
 939  AliDataLoader* dl;
 940  while ((dl = (AliDataLoader*)next()))
 941   {
 942     dl->Synchronize();
 943   }
 944
 945 }
 946 /*****************************************************************************/
 947 /*****************************************************************************/
 948 /*****************************************************************************/
 949