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 void AliLoader::UnloadAll()
 190 {
 191  //calls UnloadAll for all base laoders
 192  //Unloads everything
 193  TIter next(fDataLoaders);
 194  AliDataLoader* dl;
 195  while ((dl = (AliDataLoader*)next()))
 196   {
 197     dl->UnloadAll();
 198   }
 199 }
 200 /******************************************************************/
 201
 202 Int_t AliLoader::GetEvent()
 203 {
 204  //changes to proper root  directory and tries to load data from files to folders
 205  // event number is defined in RunLoader
 206  //
 207  //returns:
 208  //     0  - in case of no error
 209  //     1  - event not found
 210  //
 211
 212  Int_t retval;
 213  TIter next(fDataLoaders);
 214  AliDataLoader* dl;
 215  while ((dl = (AliDataLoader*)next()))
 216   {
 217     retval = dl->GetEvent();
 218     if (retval)
 219      {
 220        Error("GetEvent","Error occured while GetEvent for %s",dl->GetName());
 221        return retval;
 222      }
 223   }
 224
 225  return 0;
 226 }
 227
 228 /******************************************************************/
 229
 230 TFolder* AliLoader::GetTopFolder()
 231 {
 232 //returns TOP aliroot folder, just a simple interface to AliConfig (gives shorter notation)
 233  return AliConfig::Instance()->GetTopFolder();
 234 }
 235
 236 /******************************************************************/
 237
 238 TFolder* AliLoader::GetEventFolder()
 239 {
 240 //get EVENT folder (data that are changing from event to event, even in single run)
 241   return fEventFolder;
 242 }
 243 /******************************************************************/
 244 TFolder* AliLoader::GetDataFolder()
 245 {
 246 //returns the folder speciofic to given detector e.g. /Folders/Event/Data/
 247  if (!fDataFolder)
 248   {
 249    fDataFolder =  dynamic_cast<TFolder*>(GetEventFolder()->FindObject(AliConfig::fgkDataFolderName));
 250
 251    if (!fDataFolder)
 252     {
 253      Fatal("GetDataFolder","Can not find AliRoot data folder. Aborting");
 254      return 0x0;
 255     }
 256   }
 257   return fDataFolder;
 258 }
 259
 260 /*****************************************************************************/
 261
 262 TFolder* AliLoader::GetTasksFolder()
 263 {
 264 //Returns pointer to Folder with Alice Tasks
 265  if (!fTasksFolder)
 266   {
 267    fTasksFolder =  dynamic_cast<TFolder*>(GetTopFolder()->FindObject(AliConfig::fgkTasksFolderName));
 268
 269    if (!fTasksFolder)
 270     {
 271      Fatal("GetTasksFolder","Can not find tasks folder. Aborting");
 272      return 0x0;
 273     }
 274   }
 275   return fTasksFolder;
 276
 277 }
 278 /*****************************************************************************/
 279
 280 TFolder* AliLoader::GetModulesFolder()
 281 {
 282  if (!fModuleFolder)
 283   {
 284    fModuleFolder =  dynamic_cast<TFolder*>(GetEventFolder()->FindObjectAny(AliConfig::GetModulesFolderName()));
 285
 286    if (!fModuleFolder)
 287     {
 288      Fatal("GetModulesFolder","Can not find modules folder. Aborting");
 289      return 0x0;
 290     }
 291   }
 292  return fModuleFolder;
 293
 294 }
 295 /*****************************************************************************/
 296
 297 TFolder* AliLoader::GetQAFolder()
 298 {
 299   //returns folder with Quality assurance
 300   if (fQAFolder == 0x0)
 301    {
 302      TObject *obj = GetEventFolder()->FindObjectAny(AliConfig::Instance()->GetQAFolderName());
 303      fQAFolder = (obj)?dynamic_cast<TFolder*>(obj):0x0;
 304
 305      if (fQAFolder == 0x0)
 306       {
 307        Fatal("GetQAFolder","Can not find Quality Assurance folder. Aborting");
 308        return 0x0;
 309       }
 310    }
 311   return fQAFolder;
 312
 313 }
 314 /*****************************************************************************/
 315 TTask* AliLoader::SDigitizer()
 316 {
 317 //returns SDigitizer task for this detector
 318   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Task();
 319
 320 }
 321 /*****************************************************************************/
 322
 323 AliDigitizer* AliLoader::Digitizer()
 324 {
 325 //returns Digitizer task for this detector
 326   return dynamic_cast<AliDigitizer*>(GetDigitsDataLoader()->GetBaseTaskLoader()->Task());
 327 }
 328 /*****************************************************************************/
 329
 330 TTask* AliLoader::Reconstructioner()
 331 {
 332 //returns Recontructioner (Cluster Finder, Cluster Maker,
 333 //or whatever you want to call it) task for this detector
 334   return GetRecPointsDataLoader()->GetBaseTaskLoader()->Task();
 335 }
 336 /*****************************************************************************/
 337
 338 TTask* AliLoader::Tracker()
 339 {
 340 //returns tracker
 341   return dynamic_cast<TTask*>(GetTracksDataLoader()->GetBaseTaskLoader()->Task());
 342 }
 343
 344 /*****************************************************************************/
 345 TTask* AliLoader::PIDTask()
 346 {
 347 //returns tracker
 348   return dynamic_cast<TTask*>(GetRecParticlesDataLoader()->GetBaseTaskLoader()->Task());
 349 }
 350
 351 /*****************************************************************************/
 352
 353 TTask* AliLoader::QAtask(const char* name)
 354 {
 355   TTask* qat = AliRunLoader::GetRunQATask();
 356   if ( qat == 0x0 )
 357    {
 358     Error("QAtask","Can not get RunQATask. (Name:%s)",GetName());
 359     return 0x0;
 360    }
 361
 362   TString dqatname(fDetectorName + AliConfig::Instance()->GetQATaskName());
 363   TTask* dqat = dynamic_cast<TTask*>(qat->GetListOfTasks()->FindObject(dqatname));
 364
 365   if ( dqat == 0x0 )
 366    {
 367     Error("QAtask","Can not find QATask in RunQATask for %s",GetDetectorName().Data());
 368     return 0x0;
 369    }
 370
 371   if (strlen(name) == 0) return dqat;
 372
 373   TList* list = dqat->GetListOfTasks();
 374
 375   TIter it(list) ;
 376   TTask * task = 0 ;
 377   while((task = static_cast<TTask *>(it.Next()) ))
 378    {
 379     TString taskname(task->GetName()) ;
 380     if(taskname.BeginsWith(name))
 381       return task ;
 382    }
 383   Error("QAtask","Can not find sub-task with name starting with %s in task %s",name,dqat->GetName());
 384   return 0x0;
 385 }
 386 /*****************************************************************************/
 387
 388 TDirectory* AliLoader::ChangeDir(TFile* file, Int_t eventno)
 389 {
 390 //changes the root directory in "file" to "dirname" which corresponds to event 'eventno'
 391 //in case of success returns the pointer to directory
 392 //else NULL
 393
 394  if (file == 0x0)
 395   {
 396     ::Error("AliLoader::ChangeDir","File is null");
 397     return 0x0;
 398   }
 399  if (file->IsOpen() == kFALSE)
 400   {
 401     ::Error("AliLoader::ChangeDir","File is not opened");
 402     return 0x0;
 403   }
 404
 405  TString dirname("Event");
 406  dirname+=eventno;
 407  if (AliLoader::fgDebug > 1)
 408    ::Info("AliLoader::ChangeDir","Changing Dir to %s in file %s.",dirname.Data(),file->GetName());
 409
 410  Bool_t result;
 411
 412  TDirectory* dir = dynamic_cast<TDirectory*>(file->Get(dirname));
 413
 414  if (dir == 0x0)
 415   {
 416     if (AliLoader::fgDebug > 1)
 417      ::Info("AliLoader::ChangeDir","Can not find directory %s in file %s, creating...",
 418             dirname.Data(),file->GetName());
 419
 420     if (file->IsWritable() == kFALSE)
 421      {
 422        ::Error("AliLoader::ChangeDir","Can not create directory. File %s in not writable.",
 423                 file->GetName());
 424        return 0x0;
 425      }
 426
 427     TDirectory* newdir = file->mkdir(dirname);
 428     if (newdir == 0x0)
 429      {
 430        ::Error("AliLoader::ChangeDir","Failed to create new directory in file %s.",
 431                file->GetName());
 432        return 0x0;
 433      }
 434     result = file->cd(dirname);
 435     if (result == kFALSE)
 436      {
 437        return 0x0;
 438      }
 439   }
 440  else
 441   {
 442    file->cd();//make a file active
 443    file->cd(dirname);//cd event dir
 444   }
 445
 446  return gDirectory;
 447 }
 448 /*****************************************************************************/
 449
 450 TString AliLoader::GetUnixDir()
 451  {
 452  //This Method will manage jumping through unix directories in case of
 453  //run with more events per run than defined in gAlice
 454
 455    TString dir;
 456
 457    return dir;
 458  }
 459 /*****************************************************************************/
 460 /************************************************************/
 461
 462 void AliLoader::MakeTree(Option_t *option)
 463  {
 464 //Makes a tree depending on option
 465 //   H: - Hits
 466 //   D: - Digits
 467 //   S: - Summable Digits
 468 //   R: - Reconstructed Points (clusters)
 469 //   T: - Tracks (tracklets)
 470
 471   const char *oH = strstr(option,"H");
 472   const char *oD = strstr(option,"D");
 473   const char *oS = strstr(option,"S");
 474   const char *oR = strstr(option,"R");
 475   const char *oT = strstr(option,"T");
 476   const char *oP = strstr(option,"P");
 477
 478   if (oH) MakeHitsContainer();
 479   if (oD) MakeDigitsContainer();
 480   if (oS) MakeSDigitsContainer();
 481   if (oR) MakeRecPointsContainer();
 482   if (oT) MakeTracksContainer();
 483   if (oP) MakeRecParticlesContainer();
 484  }
 485
 486 /*****************************************************************************/
 487 Int_t  AliLoader::WriteHits(Option_t* opt)
 488  {
 489    AliDataLoader* dl = GetHitsDataLoader();
 490    Int_t ret = dl->WriteData(opt);
 491    return ret;
 492  }
 493 /*****************************************************************************/
 494
 495 Int_t AliLoader::WriteSDigits(Option_t* opt)
 496  {
 497    AliDataLoader* dl = GetSDigitsDataLoader();
 498    Int_t ret = dl->WriteData(opt);
 499    return ret;
 500  }
 501
 502 /*****************************************************************************/
 503
 504 Int_t AliLoader::PostSDigitizer(TTask* sdzer)
 505 {
 506   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Post(sdzer);
 507 }
 508 /*****************************************************************************/
 509
 510 Int_t AliLoader::PostDigitizer(AliDigitizer* task)
 511  {
 512   return GetDigitsDataLoader()->GetBaseTaskLoader()->Post(task);
 513  }
 514 /*****************************************************************************/
 515
 516 Int_t AliLoader::PostReconstructioner(TTask* task)
 517  {
 518   return GetRecPointsDataLoader()->GetBaseTaskLoader()->Post(task);
 519  }
 520 /*****************************************************************************/
 521
 522 Int_t AliLoader::PostTracker(TTask* task)
 523  {
 524   return GetTracksDataLoader()->GetBaseTaskLoader()->Post(task);
 525  }
 526 /*****************************************************************************/
 527
 528 Int_t AliLoader::PostPIDTask(TTask* task)
 529  {
 530   return GetRecParticlesDataLoader()->GetBaseTaskLoader()->Post(task);
 531  }
 532 /*****************************************************************************/
 533
 534 TObject** AliLoader::GetDetectorDataRef(TObject *obj)
 535 {
 536  if (obj == 0x0)
 537   {
 538     return 0x0;
 539   }
 540  return GetDetectorDataFolder()->GetListOfFolders()->GetObjectRef(obj) ;
 541 }
 542 /*****************************************************************************/
 543
 544 TObject** AliLoader::SDigitizerRef()
 545 {
 546   TTask* rsd = AliRunLoader::GetRunSDigitizer();
 547   if (rsd == 0x0)
 548    {
 549      return 0x0;
 550    }
 551   return rsd->GetListOfTasks()->GetObjectRef(SDigitizer());
 552 }
 553 /*****************************************************************************/
 554
 555 TObject** AliLoader::DigitizerRef()
 556 {
 557  TTask* rd = AliRunLoader::GetRunDigitizer();
 558  if (rd == 0x0)
 559   {
 560     return 0x0;
 561   }
 562  return rd->GetListOfTasks()->GetObjectRef(Digitizer()) ;
 563 }
 564 /*****************************************************************************/
 565
 566 TObject** AliLoader::ReconstructionerRef()
 567 {
 568   TTask* rrec = AliRunLoader::GetRunReconstructioner();
 569   if (rrec == 0x0)
 570    {
 571      return 0x0;
 572    }
 573   return rrec->GetListOfTasks()->GetObjectRef(Reconstructioner());
 574 }
 575 /*****************************************************************************/
 576
 577 TObject** AliLoader::TrackerRef()
 578 {
 579    TTask* rrec = AliRunLoader::GetRunTracker();
 580    if (rrec == 0x0)
 581     {
 582       return 0x0;
 583     }
 584    return rrec->GetListOfTasks()->GetObjectRef(Tracker());
 585 }
 586 /*****************************************************************************/
 587
 588 TObject** AliLoader::PIDTaskRef()
 589 {
 590   TTask* rrec = AliRunLoader::GetRunPIDTask();
 591   if (rrec == 0x0)
 592    {
 593      return 0x0;
 594    }
 595   return rrec->GetListOfTasks()->GetObjectRef(PIDTask());
 596 }
 597
 598 /*****************************************************************************/
 599 void AliLoader::CleanFolders()
 600  {
 601  //Cleans all posted objects == removes from folders and deletes them
 602    TIter next(fDataLoaders);
 603    AliDataLoader* dl;
 604    while ((dl = (AliDataLoader*)next()))
 605     {
 606       if (GetDebug()) Info("CleanFolders","name = %s cleaning",dl->GetName());
 607       dl->Clean();
 608     }
 609  }
 610 /*****************************************************************************/
 611
 612 /*****************************************************************************/
 613
 614 void AliLoader::CleanSDigitizer()
 615 {
 616 //removes and deletes detector task from Run Task
 617   TTask* task = AliRunLoader::GetRunSDigitizer();
 618   if (task == 0x0)
 619    {
 620      Error("CleanSDigitizer","Can not get RunSDigitizer from folder. Can not clean");
 621      return;
 622    }
 623
 624   if (GetDebug()) Info("CleanSDigitizer","Attempting to delete S Digitizer");
 625   delete task->GetListOfTasks()->Remove(SDigitizer()); //TTList::Remove does not delete object
 626 }
 627 /*****************************************************************************/
 628
 629 void AliLoader::CleanDigitizer()
 630 {
 631 //removes and deletes detector task from Run Task
 632   TTask* task = AliRunLoader::GetRunDigitizer();
 633   if (task == 0x0)
 634    {
 635      Error("CleanDigitizer","Can not get RunDigitizer from folder. Can not clean");
 636      return;
 637    }
 638
 639   if (GetDebug())
 640    Info("CleanDigitizer","Attempting to delete Digitizer %X",
 641          task->GetListOfTasks()->Remove(Digitizer()));
 642   delete task->GetListOfTasks()->Remove(Digitizer()); //TTList::Remove does not delete object
 643 }
 644 /*****************************************************************************/
 645
 646 void AliLoader::CleanReconstructioner()
 647 {
 648 //removes and deletes detector Reconstructioner from Run Reconstructioner
 649   TTask* task = AliRunLoader::GetRunReconstructioner();
 650   if (task == 0x0)
 651    {
 652      Error("CleanReconstructioner","Can not get RunReconstructioner from folder. Can not clean");
 653      return;
 654    }
 655
 656   if (GetDebug())
 657    Info("CleanReconstructioner","Attempting to delete Reconstructioner");
 658   delete task->GetListOfTasks()->Remove(Reconstructioner()); //TTList::Remove does not delete object
 659 }
 660 /*****************************************************************************/
 661
 662 void AliLoader::CleanTracker()
 663 {
 664 //removes and deletes detector tracker from Run Tracker
 665   TTask* task = AliRunLoader::GetRunTracker();
 666   if (task == 0x0)
 667    {
 668      Error("CleanTracker","Can not get RunTracker from folder. Can not clean");
 669      return;
 670    }
 671
 672   if (GetDebug())
 673    Info("CleanTracker","Attempting to delete Tracker %X",
 674          task->GetListOfTasks()->Remove(Tracker()));
 675   delete task->GetListOfTasks()->Remove(Tracker()); //TTList::Remove does not delete object
 676 }
 677 /*****************************************************************************/
 678
 679 void AliLoader::CleanPIDTask()
 680 {
 681 //removes and deletes detector Reconstructioner from Run Reconstructioner
 682   TTask* task = AliRunLoader::GetRunPIDTask();
 683   if (task == 0x0)
 684    {
 685      Error("CleanPIDTask","Can not get Run PID Task from folder. Can not clean");
 686      return;
 687    }
 688
 689   if (GetDebug())
 690    Info("CleanPIDTask","Attempting to delete PID Task");
 691   delete task->GetListOfTasks()->Remove(PIDTask()); //TTList::Remove does not delete object
 692 }
 693 /*****************************************************************************/
 694
 695 Int_t AliLoader::ReloadAll()
 696 {
 697  TIter next(fDataLoaders);
 698  AliDataLoader* dl;
 699
 700  while((dl = (AliDataLoader*)next()))
 701   {
 702    Int_t err = dl->Reload();
 703    if (err)
 704     {
 705       Error("ReloadAll","Reload returned error for %s",dl->GetName());
 706       return err;
 707     }
 708   }
 709  return 0;
 710 }
 711 /*****************************************************************************/
 712
 713 void AliLoader::CloseFiles()
 714 {
 715 //close files for data loaders
 716  TIter next(fDataLoaders);
 717  AliDataLoader* dl;
 718  while((dl = (AliDataLoader*)next()))
 719   {
 720    dl->CloseFile();
 721   }
 722 }
 723 /*****************************************************************************/
 724
 725 Int_t  AliLoader::SetEventFolder(TFolder* eventfolder)
 726 {
 727  if (eventfolder == 0x0)
 728   {
 729     Error("SetEventFolder","Stupid joke. Argument is NULL");
 730     return 1;
 731   }
 732
 733  fEventFolder = eventfolder;
 734  TIter next(fDataLoaders);
 735  AliDataLoader* dl;
 736
 737  while((dl = (AliDataLoader*)next()))
 738   {
 739     dl->SetEventFolder(fEventFolder);
 740     dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
 741   }
 742
 743  return 0;
 744 }//sets the event folder
 745 /*****************************************************************************/
 746
 747 Int_t AliLoader::Register(TFolder* eventFolder)
 748 {
 749 //triggers creation of subfolders for a given detector
 750 //this method is called when session is read from disk
 751 //
 752 //warning: AliDetector in constructor (not default) calls
 753 //creation of folder structure as well (some detectors needs folders
 754 //alrady in constructors)
 755
 756  if (GetDebug()) Info("Register","Name is %s.",GetName());
 757  if (eventFolder == 0x0)
 758   {
 759     Error("Register","Event folder is not set.");
 760     return 1;
 761   }
 762  Int_t retval = AliConfig::Instance()->AddDetector(eventFolder,fDetectorName,fDetectorName);
 763  if(retval)
 764   {
 765     Error("SetEventFolder","Can not create tasks and/or folders for %s. Event folder name is %s",
 766           fDetectorName.Data(),eventFolder->GetName());
 767     return retval;
 768   }
 769  SetEventFolder(eventFolder);
 770  return 0;
 771 }
 772 /*****************************************************************************/
 773 AliRunLoader* AliLoader::GetRunLoader()
 774 {
 775 //gets the run-loader from event folder
 776   AliRunLoader* rg = 0x0;
 777   TObject * obj = GetEventFolder()->FindObject(AliRunLoader::fgkRunLoaderName);
 778   if (obj) rg = dynamic_cast<AliRunLoader*>(obj);
 779   return rg;
 780 }
 781 /*****************************************************************************/
 782 Bool_t  AliLoader::TestFileOption(Option_t* opt)
 783 {
 784 //tests the TFile::Option
 785 //if file is truncated at opening moment ("recreate", "new" or "create") returns kFALSE;
 786 //else kTRUE (means opened with "read" or "update" mode)
 787   TString option(opt);
 788   if (option.CompareTo("recreate",TString::kIgnoreCase) == 0) return kFALSE;
 789   if (option.CompareTo("new",TString::kIgnoreCase) == 0) return kFALSE;
 790   if (option.CompareTo("create",TString::kIgnoreCase) == 0) return kFALSE;
 791   return kTRUE;
 792 }
 793 /*****************************************************************************/
 794 void  AliLoader::SetDirName(TString& dirname)
 795 {
 796 //adds "dirname/" to each file
 797   TIter next(fDataLoaders);
 798   AliDataLoader* dl;
 799   while((dl = (AliDataLoader*)next()))
 800    {
 801     dl->SetDirName(dirname);
 802    }
 803 }
 804
 805 /*****************************************************************************/
 806
 807 void AliLoader::SetDigitsFileNameSuffix(const TString& suffix)
 808 {
 809   //adds the suffix before ".root",
 810   //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
 811   //made on Jiri Chudoba demand
 812   GetDigitsDataLoader()->SetFileNameSuffix(suffix);
 813 }
 814 /*****************************************************************************/
 815
 816 void AliLoader::SetCompressionLevel(Int_t cl)
 817 {
 818 //sets comression level for data defined by di
 819   TIter next(fDataLoaders);
 820   AliDataLoader* dl;
 821   while((dl = (AliDataLoader*)next()))
 822    {
 823      dl->SetCompressionLevel(cl);
 824    }
 825 }
 826 /*****************************************************************************/
 827
 828 void AliLoader::Clean()
 829 {
 830 //Cleans all data loaders
 831   TIter next(fDataLoaders);
 832   AliDataLoader* dl;
 833   while((dl = (AliDataLoader*)next()))
 834    {
 835      dl->Clean();
 836    }
 837 }
 838 /*****************************************************************************/
 839
 840 void AliLoader::Clean(const TString& name)
 841 {
 842   TObject* obj = GetDetectorDataFolder()->FindObject(name);
 843   if(obj)
 844    {
 845      if (GetDebug())
 846        Info("Clean(const TString&)","name=%s, cleaning %s.",GetName(),name.Data());
 847      GetDetectorDataFolder()->Remove(obj);
 848      delete obj;
 849    }
 850 }
 851
 852 /*****************************************************************************/
 853
 854 Bool_t AliLoader::IsOptionWritable(const TString& opt)
 855 {
 856   if (opt.CompareTo("recreate",TString::kIgnoreCase)) return kTRUE;
 857   if (opt.CompareTo("new",TString::kIgnoreCase)) return kTRUE;
 858   if (opt.CompareTo("create",TString::kIgnoreCase)) return kTRUE;
 859   if (opt.CompareTo("update",TString::kIgnoreCase)) return kTRUE;
 860   return kFALSE;
 861 }
 862 /*****************************************************************************/
 863
 864 void AliLoader::SetTAddrInDet()
 865 {
 866   //calls SetTreeAddress for corresponding detector
 867   AliRunLoader* rl = GetRunLoader();
 868   if (rl == 0x0) return;
 869   AliRun* ar = rl->GetAliRun();
 870   if (ar == 0x0) return;
 871   AliDetector* det = ar->GetDetector(fDetectorName);
 872   if (det == 0x0) return;
 873   det->SetTreeAddress();
 874 }
 875 /*****************************************************************************/
 876
 877 void AliLoader::Synchronize()
 878 {
 879   //synchrinizes all writtable files
 880  TIter next(fDataLoaders);
 881  AliDataLoader* dl;
 882  while ((dl = (AliDataLoader*)next()))
 883   {
 884     dl->Synchronize();
 885   }
 886
 887 }
 888 /*****************************************************************************/
 889 /*****************************************************************************/
 890 /*****************************************************************************/
 891