STEER/AliRunLoader.cxx

   1 #include "AliRunLoader.h"
   2 //_____________________________________
   3 /////////////////////////////////////////////////////////////////////////////////////
   4 //
   5 // class AliRunLoader
   6 //
   7 //This class aims to be the only one interface for manging data
   8 //It stores Loaders for all modules which knows the filenames
   9 //of the data files to be stored.
  10 //It aims to substitude AliRun in automatic maging of data positioning
  11 //thus there won't be necessity of loading gAlice from file in order to
  12 //get fast ccess to the data
  13 //
  14 //logical place for putting the Loader specific to the given detector is detector itself
  15 // but, to load detector one need to load gAlice, and by the way all other detectors
  16 // with their geometries and so on.
  17 // So, if one need to open TPC clusters there is no principal need to read everything
  18 //
  19 // When RunLoader is read from the file it does not connect to the folder structure
  20 // it must be connected (mounted) manualy in the macro or class code.
  21 // Default event folder is defined by AliConfig::fgkDefaultEventFolderName
  22 // but can be mounted elsewhere. Usefull specially in merging, when more than session
  23 // needs to be loaded
  24 //
  25 //////////////////////////////////////////////////////////////////////////////////////
  26 /**************************************************************************/
  27
  28 #include <TROOT.h>
  29 #include <TString.h>
  30 #include <TFolder.h>
  31 #include <TTask.h>
  32 #include <TFile.h>
  33 #include <TTree.h>
  34 #include <TBranch.h>
  35 #include <TGeometry.h>
  36 #include <TError.h>
  37 #include <TObjArray.h>
  38
  39 #include "AliRun.h"
  40 #include "AliConfig.h"
  41 #include "AliLoader.h"
  42 #include "AliHeader.h"
  43 #include "AliStack.h"
  44 #include "AliDetector.h"
  45 #include "AliRunDigitizer.h"
  46
  47 ClassImp(AliRunLoader)
  48
  49 AliRunLoader* AliRunLoader::fgRunLoader = 0x0;
  50
  51 const TString AliRunLoader::fgkRunLoaderName("RunLoader");
  52
  53 const TString AliRunLoader::fgkHeaderBranchName("Header");
  54 const TString AliRunLoader::fgkHeaderContainerName("TE");
  55 const TString AliRunLoader::fgkKineContainerName("TreeK");
  56 const TString AliRunLoader::fgkTrackRefsContainerName("TreeTR");
  57 const TString AliRunLoader::fgkKineBranchName("Particles");
  58 const TString AliRunLoader::fgkDefaultKineFileName("Kinematics.root");
  59 const TString AliRunLoader::fgkDefaultTrackRefsFileName("TrackRefs.root");
  60 const TString AliRunLoader::fgkGAliceName("gAlice");
  61 /**************************************************************************/
  62
  63 AliRunLoader::AliRunLoader():
  64  fLoaders(0x0),
  65  fEventFolder(0x0),
  66  fCurrentEvent(0),
  67  fGAFile(0x0),
  68  fHeader(0x0),
  69  fStack(0x0),
  70  fKineDataLoader(0x0),
  71  fTrackRefsDataLoader(0x0),
  72  fNEventsPerFile(1),
  73  fUnixDirName(".")
  74 {
  75   AliConfig::Instance();//force to build the folder structure
  76 }
  77 /**************************************************************************/
  78
  79 AliRunLoader::AliRunLoader(const char* eventfoldername):
  80  TNamed(fgkRunLoaderName,fgkRunLoaderName),
  81  fLoaders(new TObjArray()),
  82  fEventFolder(0x0),
  83  fCurrentEvent(0),
  84  fGAFile(0x0),
  85  fHeader(0x0),
  86  fStack(0x0),
  87  fKineDataLoader(new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics")),
  88  fTrackRefsDataLoader(new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References")),
  89  fNEventsPerFile(1),
  90  fUnixDirName(".")
  91 {
  92 //ctor
  93   SetEventFolderName(eventfoldername);
  94 }
  95 /**************************************************************************/
  96
  97 AliRunLoader::~AliRunLoader()
  98 {
  99 //dtor
 100   if (fgRunLoader == this) fgRunLoader = 0x0;
 101
 102   UnloadHeader();
 103   UnloadgAlice();
 104
 105   if(fLoaders) {
 106     fLoaders->SetOwner();
 107     delete fLoaders;
 108   }
 109
 110   delete fKineDataLoader;
 111   delete fTrackRefsDataLoader;
 112
 113
 114   RemoveEventFolder();
 115
 116   //fEventFolder is deleted by the way of removing - TopAliceFolder owns it
 117   delete fHeader;
 118   delete fStack;
 119   delete fGAFile;
 120 }
 121 /**************************************************************************/
 122
 123 AliRunLoader::AliRunLoader(TFolder* topfolder):TNamed(fgkRunLoaderName,fgkRunLoaderName)
 124 {
 125 //ctor
 126  if(topfolder == 0x0)
 127   {
 128     Fatal("AliRunLoader(TFolder*)","Parameter is NULL");
 129     return;
 130   }
 131  fEventFolder = topfolder;
 132
 133  TObject* obj = fEventFolder->FindObject(fgkRunLoaderName);
 134  if (obj)
 135   { //if it is, then sth. is going wrong... exits aliroot session
 136     Fatal("AliRunLoader(const char*)",
 137           "In Event Folder Named %s object named %s already exists. I am confused ...",
 138            fEventFolder->GetName(),fgkRunLoaderName.Data());
 139     return;//never reached
 140   }
 141
 142  fLoaders = new TObjArray();
 143  fEventFolder->Add(this);//put myself to the folder to accessible for all
 144
 145 }
 146 /**************************************************************************/
 147
 148 Int_t AliRunLoader::GetEvent(Int_t evno)
 149 {
 150 //Gets event number evno
 151 //Reloads all data properly
 152   if (fCurrentEvent == evno) return 0;
 153
 154   if (evno < 0)
 155    {
 156      Error("GetEvent","Can not give the event with negative number");
 157      return 4;
 158    }
 159
 160   if (evno >= GetNumberOfEvents())
 161    {
 162      Error("GetEvent","There is no event with number %d",evno);
 163      return 3;
 164    }
 165
 166   if (GetDebug())
 167    {
 168      Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
 169      Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
 170      Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
 171      Info("GetEvent","          GETTING EVENT  %d",evno);
 172      Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
 173      Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
 174      Info("GetEvent",">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
 175    }
 176
 177   fCurrentEvent = evno;
 178
 179   Int_t retval;
 180
 181   //Reload header (If header was loaded)
 182   if (GetHeader())
 183    {
 184      retval = TreeE()->GetEvent(fCurrentEvent);
 185      if ( retval == 0)
 186       {
 187         Error("GetEvent","Cannot find event: %d\n ",fCurrentEvent);
 188         return 5;
 189       }
 190    }
 191   //Reload stack (If header was loaded)
 192   if (TreeE()) fStack = GetHeader()->Stack();
 193   //Set event folder in stack (it does not mean that we read kinematics from file)
 194   if (fStack)
 195    {
 196      fStack->SetEventFolderName(fEventFolder->GetName());
 197    }
 198   else
 199    {
 200      Warning("GetEvent","Stack not found in header");
 201    }
 202
 203   retval = SetEvent();
 204   if (retval)
 205    {
 206      Error("GetEvent","Error occured while setting event %d",evno);
 207      return 1;
 208    }
 209
 210   //Post Track References
 211   retval = fTrackRefsDataLoader->GetEvent();
 212   if (retval)
 213    {
 214      Error("GetEvent","Error occured while GetEvent for Track References. Event %d",evno);
 215      return 2;
 216    }
 217
 218   //Read Kinematics if loaded
 219   fKineDataLoader->GetEvent();
 220   if (retval)
 221    {
 222      Error("GetEvent","Error occured while GetEvent for Kinematics. Event %d",evno);
 223      return 2;
 224    }
 225
 226   if (fStack && fKineDataLoader->GetBaseLoader(0)->IsLoaded()) fStack->GetEvent();
 227
 228   //Trigger data reloading in all loaders
 229   TIter next(fLoaders);
 230   AliLoader *loader;
 231   while((loader = (AliLoader*)next()))
 232    {
 233      retval = loader->GetEvent();
 234      if (retval)
 235       {
 236        Error("GetEvent","Error occured while getting event for %s. Event %d.",
 237               loader->GetDetectorName().Data(), evno);
 238        return 3;
 239       }
 240    }
 241
 242   SetDetectorAddresses();
 243
 244   return 0;
 245 }
 246 /**************************************************************************/
 247 Int_t AliRunLoader::SetEvent()
 248 {
 249 //if kinematics was loaded Cleans folder data
 250
 251   Int_t retval;
 252
 253   retval = fKineDataLoader->SetEvent();
 254   if (retval)
 255    {
 256      Error("SetEvent","SetEvent for Kinamtics Data Loader retutned error.");
 257      return retval;
 258    }
 259   retval = fTrackRefsDataLoader->SetEvent();
 260   if (retval)
 261    {
 262      Error("SetEvent","SetEvent for Track References Data Loader retutned error.");
 263      return retval;
 264    }
 265
 266   TIter next(fLoaders);
 267   AliLoader *loader;
 268   while((loader = (AliLoader*)next()))
 269    {
 270      retval = loader->SetEvent();
 271      if (retval)
 272       {
 273         Error("SetEvent","SetEvent for %s Data Loader retutned error.",loader->GetName());
 274         return retval;
 275       }
 276    }
 277
 278   return 0;
 279 }
 280 /**************************************************************************/
 281
 282 Int_t AliRunLoader::SetEventNumber(Int_t evno)
 283 {
 284   //cleans folders and sets the root dirs in files
 285   if (fCurrentEvent == evno) return 0;
 286   fCurrentEvent = evno;
 287   return SetEvent();
 288 }
 289
 290 /**************************************************************************/
 291 AliRunLoader* AliRunLoader::Open
 292   (const char* filename, const char* eventfoldername, Option_t* option)
 293 {
 294 //Opens a desired file 'filename'
 295 //gets the the run-Loader and mounts it desired folder
 296 //returns the pointer to run Loader which can be further used for accessing data
 297 //in case of error returns NULL
 298
 299  static const TString webaddress("http://alisoft.cern.ch/people/skowron/codedoc/split/index.html");
 300  if (AliLoader::fgDebug)
 301   ::Info("AliRunLoader::Open",
 302          "\n\n\nNew I/O strcture: See more info:\n %s\n\n\n",webaddress.Data());
 303
 304  AliRunLoader* result = 0x0;
 305
 306  /* ************************************************ */
 307  /* Chceck if folder with given name already exists  */
 308  /* ************************************************ */
 309
 310  TObject* obj = AliConfig::Instance()->GetTopFolder()->FindObject(eventfoldername);
 311  if(obj)
 312   {
 313     TFolder* fold = dynamic_cast<TFolder*>(obj);
 314     if (fold == 0x0)
 315      {
 316       ::Error("AliRunLoader::Open","Such a obejct already exists in top alice folder and it is not a folder.");
 317       return 0x0;
 318      }
 319
 320     //check if we can get RL from that folder
 321     result = AliRunLoader::GetRunLoader(eventfoldername);
 322     if (result == 0x0)
 323      {
 324        ::Error("AliRunLoader::Open",
 325                "Folder %s already exists, and can not find session there. Can not mount.",eventfoldername);
 326        return 0x0;
 327      }
 328
 329     if (result->GetFileName().CompareTo(filename) != 0)
 330      {
 331        ::Error("AliRunLoader::Open","Other file is mounted in demanded folder. Can not mount.");
 332        return 0x0;
 333      }
 334
 335     //check if now is demanded (re)creation
 336     if ( AliLoader::TestFileOption(option) == kFALSE)
 337      {
 338        ::Error("AliRunLoader::Open",
 339                "Session already exists in folder %s and this session option is %s. Unable to proceed.",
 340                 eventfoldername,option);
 341        return 0x0;
 342      }
 343
 344     //check if demanded option is update and existing one
 345     TString tmpstr(option);
 346     if ( (tmpstr.CompareTo("update",TString::kIgnoreCase) == 0) &&
 347          (result->fGAFile->IsWritable() == kFALSE) )
 348      {
 349        ::Error("AliRunLoader::Open",
 350                "Session already exists in folder %s and is not writable while this session option is %s. Unable to proceed.",
 351                 eventfoldername,option);
 352        return 0x0;
 353      }
 354
 355     ::Warning("AliRunLoader::Open","Session is already opened and mounted in demanded folder");
 356     return result;
 357   } //end of checking in case of existance of object named identically that folder session is being opened
 358
 359
 360  TFile * gAliceFile = TFile::Open(filename,option);//open a file
 361  if (!gAliceFile)
 362   {//null pointer returned
 363     ::Error("AliRunLoader::Open","Can not open file %s.",filename);
 364     return 0x0;
 365   }
 366
 367  if (gAliceFile->IsOpen() == kFALSE)
 368   {//pointer to valid object returned but file is not opened
 369     ::Error("AliRunLoader::Open","Can not open file %s.",filename);
 370     return 0x0;
 371   }
 372
 373  //if file is "read" or "update" than we try to find AliRunLoader there - if not found cry and exit
 374  //else create new AliRunLoader
 375  if ( AliLoader::TestFileOption(option) )
 376   {
 377     if (AliLoader::fgDebug)
 378      ::Info("AliRunLoader::Open","Reading RL from file");
 379
 380     result = dynamic_cast<AliRunLoader*>(gAliceFile->Get(fgkRunLoaderName));//get the run Loader from the file
 381     if (result == 0x0)
 382      {//didn't get
 383        ::Error("AliRunLoader::Open","Can not find run-Loader in file %s.",filename);
 384        delete gAliceFile;//close the file
 385        return 0x0;
 386      }
 387     Int_t tmp = result->SetEventFolderName(eventfoldername);//mount a event folder
 388     if (tmp)//if SetEvent  returned error
 389      {
 390        ::Error("AliRunLoader::Open","Can not mount event in folder %s.",eventfoldername);
 391        delete result; //delete run-Loader
 392        delete gAliceFile;//close the file
 393        return 0x0;
 394      }
 395   }
 396  else
 397   {
 398     if (AliLoader::fgDebug)
 399       ::Info("AliRunLoader::Open","Creating new AliRunLoader. Folder name is %s",eventfoldername);
 400     result = new AliRunLoader(eventfoldername);
 401   }
 402
 403 //procedure for extracting dir name from the file name
 404  TString fname(filename);
 405  Int_t  nsl = fname.Last('/');//look for slash in file name
 406  TString dirname;
 407  if (nsl < 0)
 408   {//slash not found
 409     Int_t  nsl = fname.Last(':');//look for colon e.g. rfio:galice.root
 410     if (nsl < 0) dirname = ".";//not found
 411     else dirname = fname.Remove(nsl);//found
 412   }
 413  else dirname = fname.Remove(nsl);//slash found
 414
 415  if (AliLoader::fgDebug)
 416   ::Info("AliRunLoader::Open","Dir name is : %s",dirname.Data());
 417
 418  result->SetDirName(dirname);
 419  result->SetGAliceFile(gAliceFile);//set the pointer to gAliceFile
 420  fgRunLoader = result; //PH get access from any place
 421  return result;
 422 }
 423 /**************************************************************************/
 424 Int_t AliRunLoader::GetNumberOfEvents()
 425 {
 426  //returns number of events in Run
 427  Int_t retval;
 428  if( TreeE() == 0x0 )
 429   {
 430     retval = LoadHeader();
 431     if (retval)
 432      {
 433        Error("GetNumberOfEvents","Error occured while loading header");
 434        return -1;
 435      }
 436   }
 437  return (Int_t)TreeE()->GetEntries();
 438 }
 439 /**************************************************************************/
 440
 441 void AliRunLoader::MakeHeader()
 442 {
 443  //Makes header and connects it to header tree (if it exists)
 444   if (GetDebug()) Info("MakeHeader","");
 445   if(fHeader == 0x0)
 446    {
 447      if (GetDebug()) Info("MakeHeader","Creating new Header Object");
 448      fHeader= new AliHeader();
 449    }
 450   TTree* tree = TreeE();
 451   if (tree)
 452    {
 453      if (GetDebug()) Info("MakeHeader","Got Tree from folder.");
 454      TBranch* branch = tree->GetBranch(fgkHeaderBranchName);
 455      if (branch == 0x0)
 456       {
 457         if (GetDebug()) Info("MakeHeader","Creating new branch");
 458         branch = tree->Branch(fgkHeaderBranchName, "AliHeader", &fHeader, 4000, 0);
 459         branch->SetAutoDelete(kFALSE);
 460       }
 461      else
 462       {
 463         if (GetDebug()) Info("MakeHeader","Got Branch from Tree");
 464         branch->SetAddress(&fHeader);
 465         tree->GetEvent(fCurrentEvent);
 466         fStack = fHeader->Stack(); //should be safe - if we created Stack, header returns pointer to the same object
 467         if (fStack)
 468          {
 469            fStack->SetEventFolderName(fEventFolder->GetName());
 470            if (TreeK()) fStack->GetEvent();
 471          }
 472         else
 473         {
 474           if (GetDebug()) Info("MakeHeader","Haeder do not have a stack.");
 475         }
 476       }
 477    }
 478   if (GetDebug()) Info("MakeHeader","Exiting MakeHeader method");
 479 }
 480 /**************************************************************************/
 481
 482 void AliRunLoader::MakeStack()
 483 {
 484 //Creates the stack object -  do not connect the tree
 485   if(fStack == 0x0)
 486    {
 487      fStack = new AliStack(10000);
 488      fStack->SetEventFolderName(fEventFolder->GetName());
 489    }
 490 }
 491
 492 /**************************************************************************/
 493
 494 void AliRunLoader::MakeTree(Option_t *option)
 495 {
 496 //Creates trees
 497   const char *oK = strstr(option,"K"); //Kine
 498   const char *oE = strstr(option,"E"); //Header
 499
 500   if(oK && !TreeK())
 501    {
 502      if (fKineDataLoader->GetBaseLoader(0)->IsLoaded() == kFALSE)
 503       {
 504         Error("MakeTree(\"K\")","Load Kinematics first");
 505       }
 506      else
 507       {
 508         fKineDataLoader->MakeTree();
 509         MakeStack();
 510         fStack->ConnectTree();
 511         WriteKinematics("OVERWRITE");
 512      }
 513    }
 514
 515   if(oE && !TreeE())
 516    {
 517      fGAFile->cd();
 518      TTree* tree = new TTree(fgkHeaderContainerName,"Tree with Headers");
 519      GetEventFolder()->Add(tree);
 520      MakeHeader();
 521      WriteHeader("OVERWRITE");
 522    }
 523
 524   TIter next(fLoaders);
 525   AliLoader *loader;
 526   while((loader = (AliLoader*)next()))
 527    {
 528     loader->MakeTree(option);
 529    }
 530
 531 }
 532 /**************************************************************************/
 533
 534 Int_t AliRunLoader::LoadgAlice()
 535 {
 536 //Loads gAlice from file
 537  if (GetAliRun())
 538   {
 539     Warning("LoadgAlice","AliRun is already in folder. Unload first.");
 540     return 0;
 541   }
 542  AliRun* alirun = dynamic_cast<AliRun*>(fGAFile->Get(fgkGAliceName));
 543  if (alirun == 0x0)
 544   {
 545     Error("LoadgAlice"," Can not find gAlice in file %s",fGAFile->GetName());
 546     return 2;
 547   }
 548  alirun->SetRunLoader(this);
 549  if (gAlice)
 550   {
 551     Warning("LoadgAlice","gAlice already exists. Putting retrived object in folder named %s",
 552              GetEventFolder()->GetName());
 553   }
 554  else
 555   {
 556     gAlice = alirun;
 557   }
 558  SetDetectorAddresses();//calls SetTreeAddress for all detectors
 559  return 0;
 560 }
 561 /**************************************************************************/
 562
 563 Int_t AliRunLoader::LoadHeader()
 564 {
 565 //loads treeE and reads header object for current event
 566  if (TreeE())
 567   {
 568      Warning("LoadHeader","Header is already loaded. Use ReloadHeader to force reload. Nothing done");
 569      return 0;
 570   }
 571
 572  if (GetEventFolder() == 0x0)
 573   {
 574     Error("LoadHaeder","Event folder not specified yet");
 575     return 1;
 576   }
 577
 578  if (fGAFile == 0x0)
 579   {
 580     Error("LoadHaeder","Session not opened. Use AliRunLoader::Open");
 581     return 2;
 582   }
 583
 584  if (fGAFile->IsOpen() == kFALSE)
 585   {
 586     Error("LoadHaeder","Session not opened. Use AliRunLoader::Open");
 587     return 2;
 588   }
 589
 590  TTree* tree = dynamic_cast<TTree*>(fGAFile->Get(fgkHeaderContainerName));
 591  if (tree == 0x0)
 592   {
 593     Fatal("LoadHaeder","Can not find header tree named %s in file %s",
 594            fgkHeaderContainerName.Data(),fGAFile->GetName());
 595     return 2;
 596   }
 597
 598  if (tree == TreeE()) return 0;
 599
 600  CleanHeader();
 601  GetEventFolder()->Add(tree);
 602  MakeHeader();//creates header object and connects to tree
 603  return 0;
 604
 605 }
 606 /**************************************************************************/
 607
 608 Int_t AliRunLoader::LoadKinematics(Option_t* option)
 609 {
 610 //Loads the kinematics
 611  Int_t retval = fKineDataLoader->GetBaseLoader(0)->Load(option);
 612  if (retval)
 613   {
 614     Error("LoadKinematics","Error occured while loading kinamatics tree.");
 615     return retval;
 616   }
 617  if (fStack) fStack->GetEvent();
 618  return 0;
 619 }
 620 /**************************************************************************/
 621
 622 Int_t AliRunLoader::OpenDataFile(const TString& filename,TFile*& file,TDirectory*& dir,Option_t* opt,Int_t cl)
 623 {
 624 //Opens File with kinematics
 625  if (file)
 626   {
 627     if (file->IsOpen() == kFALSE)
 628      {//pointer is not null but file is not opened
 629        Warning("OpenDataFile","Pointer to file is not null, but file is not opened");//risky any way
 630        delete file;
 631        file = 0x0; //proceed with opening procedure
 632      }
 633     else
 634      {
 635        Warning("OpenDataFile","File  %s already opened",filename.Data());
 636        return 0;
 637      }
 638   }
 639 //try to find if that file is opened somewere else
 640  file = (TFile *)( gROOT->GetListOfFiles()->FindObject(filename) );
 641  if (file)
 642   {
 643    if(file->IsOpen() == kTRUE)
 644     {
 645      Warning("OpenDataFile","File %s already opened by sombody else.",file->GetName());
 646      return 0;
 647     }
 648   }
 649
 650  file = TFile::Open(filename,opt);
 651  if (file == 0x0)
 652   {//file is null
 653     Error("LoadKinematics","Can not open file %s",filename.Data());
 654     return 1;
 655   }
 656  if (file->IsOpen() == kFALSE)
 657   {//file is not opened
 658    Error("LoadKinematics","Can not open file %s",filename.Data());
 659    return 1;
 660   }
 661
 662  file->SetCompressionLevel(cl);
 663
 664  dir = AliLoader::ChangeDir(file,fCurrentEvent);
 665  if (dir == 0x0)
 666   {
 667     Error("OpenKineFile","Can not change to root directory in file %s",filename.Data());
 668     return 3;
 669   }
 670  return 0;
 671 }
 672 /**************************************************************************/
 673
 674 TTree* AliRunLoader::TreeE() const
 675 {
 676  //returns the tree from folder; shortcut method
 677  TObject *obj = fEventFolder->FindObject(fgkHeaderContainerName);
 678  return (obj)?dynamic_cast<TTree*>(obj):0x0;
 679 }
 680 /**************************************************************************/
 681
 682 AliHeader* AliRunLoader::GetHeader() const
 683 {
 684 //returns pointer header object
 685  return fHeader;
 686 }
 687 /**************************************************************************/
 688
 689 TTree* AliRunLoader::TreeK() const
 690 {
 691  //returns the tree from folder; shortcut method
 692  TObject *obj = GetEventFolder()->FindObject(fgkKineContainerName);
 693  return (obj)?dynamic_cast<TTree*>(obj):0x0;
 694 }
 695 /**************************************************************************/
 696
 697 TTree* AliRunLoader::TreeTR() const
 698 {
 699  //returns the tree from folder; shortcut method
 700  TObject* obj = GetEventFolder()->FindObject(fgkTrackRefsContainerName);
 701  return (obj)?dynamic_cast<TTree*>(obj):0x0;
 702 }
 703 /**************************************************************************/
 704
 705 AliRun* AliRunLoader::GetAliRun() const
 706 {
 707 //returns AliRun which sits in the folder
 708  if (fEventFolder == 0x0) return 0x0;
 709  TObject *obj = fEventFolder->FindObject(fgkGAliceName);
 710  return (obj)?dynamic_cast<AliRun*>(obj):0x0;
 711 }
 712 /**************************************************************************/
 713
 714 Int_t AliRunLoader::WriteGeometry(Option_t* /*opt*/)
 715 {
 716 //writes geometry to the file
 717   fGAFile->cd();
 718   TGeometry* geo = GetAliRun()->GetGeometry();
 719   if (geo == 0x0)
 720    {
 721      Error("WriteGeometry","Can not get geometry from gAlice");
 722      return 1;
 723    }
 724   geo->Write();
 725   return 0;
 726 }
 727 /**************************************************************************/
 728
 729 Int_t AliRunLoader::WriteHeader(Option_t* opt)
 730 {
 731 //writes treeE
 732   if (GetDebug()) Info("WriteHeader","  WRITING HEADER");
 733
 734   TTree* tree = TreeE();
 735   if ( tree == 0x0)
 736    {
 737      Warning("WriteHeader","Can not find Header Tree in Folder");
 738      return 0;
 739    }
 740   if (fGAFile->IsWritable() == kFALSE)
 741    {
 742      Error("WriteHeader","File %s is not writable",fGAFile->GetName());
 743      return 1;
 744    }
 745
 746   TObject* obj = fGAFile->Get(fgkHeaderContainerName);
 747   if (obj)
 748    { //if they exist, see if option OVERWRITE is used
 749      TString tmp(opt);
 750      if(tmp.Contains("OVERWRITE",TString::kIgnoreCase) == 0)
 751       {//if it is not used -  give an error message and return an error code
 752         Error("WriteHeader","Tree already exisists. Use option \"OVERWRITE\" to overwrite previous data");
 753         return 3;
 754       }
 755    }
 756   fGAFile->cd();
 757   tree->SetDirectory(fGAFile);
 758   tree->Write(0,TObject::kOverwrite);
 759
 760   if (GetDebug()) Info("WriteHeader","WRITTEN\n\n");
 761
 762   return 0;
 763 }
 764 /**************************************************************************/
 765
 766 Int_t AliRunLoader::WriteAliRun(Option_t* /*opt*/)
 767 {
 768 //writes AliRun object to the file
 769   fGAFile->cd();
 770   if (GetAliRun()) GetAliRun()->Write();
 771   return 0;
 772 }
 773 /**************************************************************************/
 774
 775 Int_t AliRunLoader::WriteKinematics(Option_t* opt)
 776 {
 777 //writes Kinematics
 778   return fKineDataLoader->GetBaseLoader(0)->WriteData(opt);
 779 }
 780 /**************************************************************************/
 781 Int_t AliRunLoader::WriteTrackRefs(Option_t* opt)
 782 {
 783 //writes Track References tree
 784   return fTrackRefsDataLoader->GetBaseLoader(0)->WriteData(opt);
 785 }
 786 /**************************************************************************/
 787
 788 Int_t AliRunLoader::WriteHits(Option_t* opt)
 789 {
 790 //Calls WriteHits for all loaders
 791   Int_t res;
 792   Int_t result = 0;
 793   TIter next(fLoaders);
 794   AliLoader *loader;
 795   while((loader = (AliLoader*)next()))
 796    {
 797      res = loader->WriteHits(opt);
 798      if (res)
 799       {
 800         Error("WriteHits","Failed to write hits for %s (%d)",loader->GetDetectorName().Data(),res);
 801         result = 1;
 802       }
 803    }
 804   return result;
 805 }
 806 /**************************************************************************/
 807
 808 Int_t AliRunLoader::WriteSDigits(Option_t* opt)
 809 {
 810 //Calls WriteSDigits for all loaders
 811   Int_t res;
 812   Int_t result = 0;
 813   TIter next(fLoaders);
 814   AliLoader *loader;
 815   while((loader = (AliLoader*)next()))
 816    {
 817      res = loader->WriteSDigits(opt);
 818      if (res)
 819       {
 820         Error("WriteSDigits","Failed to write summable digits for %s.",loader->GetDetectorName().Data());
 821         result = 1;
 822       }
 823    }
 824   return result;
 825 }
 826 /**************************************************************************/
 827
 828 Int_t AliRunLoader::WriteDigits(Option_t* opt)
 829 {
 830 //Calls WriteDigits for all loaders
 831   Int_t res;
 832   Int_t result = 0;
 833   TIter next(fLoaders);
 834   AliLoader *loader;
 835   while((loader = (AliLoader*)next()))
 836    {
 837      res = loader->WriteDigits(opt);
 838      if (res)
 839       {
 840         Error("WriteDigits","Failed to write digits for %s.",loader->GetDetectorName().Data());
 841         result = 1;
 842       }
 843    }
 844   return result;
 845 }
 846 /**************************************************************************/
 847
 848 Int_t AliRunLoader::WriteRecPoints(Option_t* opt)
 849 {
 850 //Calls WriteRecPoints for all loaders
 851   Int_t res;
 852   Int_t result = 0;
 853   TIter next(fLoaders);
 854   AliLoader *loader;
 855   while((loader = (AliLoader*)next()))
 856    {
 857      res = loader->WriteRecPoints(opt);
 858      if (res)
 859       {
 860         Error("WriteRecPoints","Failed to write Reconstructed Points for %s.",
 861               loader->GetDetectorName().Data());
 862         result = 1;
 863       }
 864    }
 865   return result;
 866 }
 867 /**************************************************************************/
 868
 869 Int_t AliRunLoader::WriteTracks(Option_t* opt)
 870 {
 871 //Calls WriteTracks for all loaders
 872   Int_t res;
 873   Int_t result = 0;
 874   TIter next(fLoaders);
 875   AliLoader *loader;
 876   while((loader = (AliLoader*)next()))
 877    {
 878      res = loader->WriteTracks(opt);
 879      if (res)
 880       {
 881         Error("WriteTracks","Failed to write Tracks for %s.",
 882               loader->GetDetectorName().Data());
 883         result = 1;
 884       }
 885    }
 886   return result;
 887 }
 888 /**************************************************************************/
 889
 890 Int_t AliRunLoader::WriteRunLoader(Option_t* /*opt*/)
 891 {
 892 //Writes itself to the file
 893   CdGAFile();
 894   this->Write(0,TObject::kOverwrite);
 895   return 0;
 896 }
 897 /**************************************************************************/
 898
 899 Int_t AliRunLoader::SetEventFolderName(const TString& name)
 900 {
 901 //sets top folder name for this run; of alread
 902   if (name.IsNull())
 903    {
 904      Error("SetTopFolderName","Name is empty");
 905      return 1;
 906    }
 907
 908   //check if such a folder already exists - try to find it in alice top folder
 909   TObject* obj = AliConfig::Instance()->GetTopFolder()->FindObject(name);
 910   if(obj)
 911    {
 912      TFolder* fold = dynamic_cast<TFolder*>(obj);
 913      if (fold == 0x0)
 914       {
 915        Error("SetTopFolderName","Such a obejct already exists in top alice folder and it is not a folder.");
 916        return 2;
 917       }
 918      //folder which was found is our folder
 919      if (fEventFolder == fold)
 920       {
 921        return 0;
 922       }
 923      else
 924       {
 925        Error("SetTopFolderName","Such a folder already exists in top alice folder. Can not mount.");
 926        return 2;
 927       }
 928    }
 929
 930   //event is alredy connected, just change name of the folder
 931   if (fEventFolder)
 932    {
 933      fEventFolder->SetName(name);
 934      return 0;
 935    }
 936
 937   if (fKineDataLoader == 0x0)
 938     fKineDataLoader = new AliDataLoader(fgkDefaultKineFileName,fgkKineContainerName,"Kinematics");
 939
 940   if ( fTrackRefsDataLoader == 0x0)
 941     fTrackRefsDataLoader = new AliDataLoader(fgkDefaultTrackRefsFileName,fgkTrackRefsContainerName,"Track References");
 942
 943   //build the event folder structure
 944   if (GetDebug()) Info("SetEventFolderName","Creating new event folder named %s",name.Data());
 945   fEventFolder = AliConfig::Instance()->BuildEventFolder(name,"Event Folder");
 946   fEventFolder->Add(this);//put myself to the folder to accessible for all
 947
 948   if (Stack()) Stack()->SetEventFolderName(fEventFolder->GetName());
 949   TIter next(fLoaders);
 950   AliLoader *loader;
 951   while((loader = (AliLoader*)next()))
 952    {
 953      loader->Register(fEventFolder);//build folder structure for this detector
 954    }
 955
 956   fKineDataLoader->SetEventFolder(GetEventFolder());
 957   fTrackRefsDataLoader->SetEventFolder(GetEventFolder());
 958   fKineDataLoader->SetFolder(GetEventFolder());
 959   fTrackRefsDataLoader->SetFolder(GetEventFolder());
 960
 961   fEventFolder->SetOwner();
 962   return 0;
 963 }
 964 /**************************************************************************/
 965
 966 void AliRunLoader::AddLoader(AliLoader* loader)
 967  {
 968  //Adds the Loader for given detector
 969   if (loader == 0x0) //if null shout and exit
 970    {
 971      Error("AddLoader","Parameter is NULL");
 972      return;
 973    }
 974   loader->SetDirName(fUnixDirName);
 975   if (fEventFolder) loader->SetEventFolder(fEventFolder); //if event folder is already defined,
 976                                                           //pass information to the Loader
 977   fLoaders->Add(loader);//add the Loader to the array
 978  }
 979 /**************************************************************************/
 980
 981 void AliRunLoader::AddLoader(AliDetector* det)
 982  {
 983 //Asks module (detector) ro make a Loader and stores in the array
 984    if (det == 0x0) return;
 985    AliLoader* get = det->GetLoader();//try to get loader
 986    if (get == 0x0)  get = det->MakeLoader(fEventFolder->GetName());//if did not obtain, ask to make it
 987
 988    if (get)
 989     {
 990       if (GetDebug()) Info("AddLoader","Detector: %s   Loader : %s",det->GetName(),get->GetName());
 991       AddLoader(get);
 992     }
 993  }
 994
 995 /**************************************************************************/
 996
 997 AliLoader* AliRunLoader::GetLoader(const char* detname) const
 998 {
 999 //returns loader for given detector
1000 //note that naming convention is TPCLoader not just TPC
1001   return (AliLoader*)fLoaders->FindObject(detname);
1002 }
1003
1004 /**************************************************************************/
1005
1006 AliLoader* AliRunLoader::GetLoader(AliDetector* det) const
1007 {
1008 //get loader for detector det
1009  if(det == 0x0) return 0x0;
1010  TString getname(det->GetName());
1011  getname+="Loader";
1012  if (GetDebug()) Info("GetLoader(AliDetector* det)"," Loader name is %s",getname.Data());
1013  return GetLoader(getname);
1014 }
1015
1016 /**************************************************************************/
1017
1018 void AliRunLoader::CleanFolders()
1019 {
1020 //  fEventFolder->Add(this);//put myself to the folder to accessible for all
1021
1022   CleanDetectors();
1023   CleanHeader();
1024   CleanKinematics();
1025 }
1026 /**************************************************************************/
1027
1028 void AliRunLoader::CleanDetectors()
1029 {
1030 //Calls CleanFolders for all detectors
1031   TIter next(fLoaders);
1032   AliLoader *Loader;
1033   while((Loader = (AliLoader*)next()))
1034    {
1035      Loader->CleanFolders();
1036    }
1037 }
1038 /**************************************************************************/
1039
1040 void AliRunLoader::RemoveEventFolder()
1041 {
1042 //remove all the tree of event
1043 //all the stuff changing EbE stays untached (PDGDB, tasks, etc.)
1044
1045  if (fEventFolder == 0x0) return;
1046  fEventFolder->SetOwner(kFALSE);//don't we want to deleted while removing the folder that we are sitting in
1047  fEventFolder->Remove(this);//remove us drom folder
1048
1049  AliConfig::Instance()->GetTopFolder()->SetOwner(); //brings ownership back for fEventFolder since it sits in top folder
1050  AliConfig::Instance()->GetTopFolder()->Remove(fEventFolder); //remove the event tree
1051  delete fEventFolder;
1052 }
1053 /**************************************************************************/
1054
1055 void AliRunLoader::SetGAliceFile(TFile* gafile)
1056 {
1057 //sets pointer to galice.root file
1058  fGAFile = gafile;
1059 }
1060
1061 /**************************************************************************/
1062
1063 Int_t AliRunLoader::LoadHits(Option_t* detectors,Option_t* opt)
1064 {
1065 //LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1066
1067   if (GetDebug()) Info("LoadHits","Loading Hits");
1068   TObjArray* loaders;
1069   TObjArray arr;
1070
1071   const char* oAll = strstr(detectors,"all");
1072   if (oAll)
1073    {
1074      if (GetDebug()) Info("LoadHits","Option is All");
1075      loaders = fLoaders;
1076    }
1077   else
1078    {
1079      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1080      loaders = &arr;//get the pointer array
1081    }
1082
1083   if (GetDebug()) Info("LoadHits","For detectors. Number of detectors chosen for loading %d",loaders->GetEntries());
1084
1085   TIter next(loaders);
1086   AliLoader *loader;
1087   while((loader = (AliLoader*)next()))
1088    {
1089     if (GetDebug()) Info("LoadHits","    Calling LoadHits(%s) for %s",opt,loader->GetName());
1090     loader->LoadHits(opt);
1091    }
1092   if (GetDebug()) Info("LoadHits","Done");
1093   return 0;
1094 }
1095
1096 /**************************************************************************/
1097
1098 Int_t AliRunLoader::LoadSDigits(Option_t* detectors,Option_t* opt)
1099 {
1100 //LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1101
1102   TObjArray* loaders;
1103   TObjArray arr;
1104
1105   const char* oAll = strstr(detectors,"all");
1106   if (oAll)
1107    {
1108      loaders = fLoaders;
1109    }
1110   else
1111    {
1112      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1113      loaders = &arr;//get the pointer to array
1114    }
1115
1116   TIter next(loaders);
1117   AliLoader *loader;
1118   while((loader = (AliLoader*)next()))
1119    {
1120     loader->LoadSDigits(opt);
1121    }
1122   return 0;
1123 }
1124
1125 /**************************************************************************/
1126
1127 Int_t AliRunLoader::LoadDigits(Option_t* detectors,Option_t* opt)
1128 {
1129 //LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1130
1131   TObjArray* Loaders;
1132   TObjArray arr;
1133
1134   const char* oAll = strstr(detectors,"all");
1135   if (oAll)
1136    {
1137      Loaders = fLoaders;
1138    }
1139   else
1140    {
1141      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1142      Loaders = &arr;//get the pointer array
1143    }
1144
1145   TIter next(Loaders);
1146   AliLoader *Loader;
1147   while((Loader = (AliLoader*)next()))
1148    {
1149     Loader->LoadDigits(opt);
1150    }
1151   return 0;
1152 }
1153 /**************************************************************************/
1154
1155 Int_t AliRunLoader::LoadRecPoints(Option_t* detectors,Option_t* opt)
1156 {
1157 //LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1158
1159   TObjArray* Loaders;
1160   TObjArray arr;
1161
1162   const char* oAll = strstr(detectors,"all");
1163   if (oAll)
1164    {
1165      Loaders = fLoaders;
1166    }
1167   else
1168    {
1169      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1170      Loaders = &arr;//get the pointer array
1171    }
1172
1173   TIter next(Loaders);
1174   AliLoader *Loader;
1175   while((Loader = (AliLoader*)next()))
1176    {
1177     Loader->LoadRecPoints(opt);
1178    }
1179   return 0;
1180 }
1181 /**************************************************************************/
1182
1183 Int_t AliRunLoader::LoadRecParticles(Option_t* detectors,Option_t* opt)
1184 {
1185 //LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1186
1187   TObjArray* Loaders;
1188   TObjArray arr;
1189
1190   const char* oAll = strstr(detectors,"all");
1191   if (oAll)
1192    {
1193      Loaders = fLoaders;
1194    }
1195   else
1196    {
1197      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1198      Loaders = &arr;//get the pointer array
1199    }
1200
1201   TIter next(Loaders);
1202   AliLoader *Loader;
1203   while((Loader = (AliLoader*)next()))
1204    {
1205     Loader->LoadRecParticles(opt);
1206    }
1207   return 0;
1208 }
1209 /**************************************************************************/
1210
1211 Int_t AliRunLoader::LoadTracks(Option_t* detectors,Option_t* opt)
1212 {
1213 //LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
1214
1215   TObjArray* Loaders;
1216   TObjArray arr;
1217
1218   const char* oAll = strstr(detectors,"all");
1219   if (oAll)
1220    {
1221      Loaders = fLoaders;
1222    }
1223   else
1224    {
1225      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1226      Loaders = &arr;//get the pointer array
1227    }
1228
1229   TIter next(Loaders);
1230   AliLoader *Loader;
1231   while((Loader = (AliLoader*)next()))
1232    {
1233     Loader->LoadTracks(opt);
1234    }
1235   return 0;
1236 }
1237 /**************************************************************************/
1238
1239 void AliRunLoader::UnloadHits(Option_t* detectors)
1240 {
1241   //unloads hits for detectors specified in parameter
1242   TObjArray* loaders;
1243   TObjArray arr;
1244
1245   const char* oAll = strstr(detectors,"all");
1246   if (oAll)
1247    {
1248      loaders = fLoaders;
1249    }
1250   else
1251    {
1252      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1253      loaders = &arr;//get the pointer to array
1254    }
1255
1256   TIter next(loaders);
1257   AliLoader *loader;
1258   while((loader = (AliLoader*)next()))
1259    {
1260     loader->UnloadHits();
1261    }
1262 }
1263 /**************************************************************************/
1264
1265 void AliRunLoader::UnloadSDigits(Option_t* detectors)
1266 {
1267   //unloads SDigits for detectors specified in parameter
1268   TObjArray* loaders;
1269   TObjArray arr;
1270
1271   const char* oAll = strstr(detectors,"all");
1272   if (oAll)
1273    {
1274      loaders = fLoaders;
1275    }
1276   else
1277    {
1278      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1279      loaders = &arr;//get the pointer to array
1280    }
1281
1282   TIter next(loaders);
1283   AliLoader *loader;
1284   while((loader = (AliLoader*)next()))
1285    {
1286     loader->UnloadSDigits();
1287    }
1288 }
1289 /**************************************************************************/
1290
1291 void AliRunLoader::UnloadDigits(Option_t* detectors)
1292 {
1293   //unloads Digits for detectors specified in parameter
1294   TObjArray* loaders;
1295   TObjArray arr;
1296
1297   const char* oAll = strstr(detectors,"all");
1298   if (oAll)
1299    {
1300      loaders = fLoaders;
1301    }
1302   else
1303    {
1304      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1305      loaders = &arr;//get the pointer to array
1306    }
1307
1308   TIter next(loaders);
1309   AliLoader *loader;
1310   while((loader = (AliLoader*)next()))
1311    {
1312     loader->UnloadDigits();
1313    }
1314 }
1315 /**************************************************************************/
1316
1317 void AliRunLoader::UnloadRecPoints(Option_t* detectors)
1318 {
1319   //unloads RecPoints for detectors specified in parameter
1320   TObjArray* loaders;
1321   TObjArray arr;
1322
1323   const char* oAll = strstr(detectors,"all");
1324   if (oAll)
1325    {
1326      loaders = fLoaders;
1327    }
1328   else
1329    {
1330      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1331      loaders = &arr;//get the pointer to array
1332    }
1333
1334   TIter next(loaders);
1335   AliLoader *loader;
1336   while((loader = (AliLoader*)next()))
1337    {
1338     loader->UnloadRecPoints();
1339    }
1340 }
1341 /**************************************************************************/
1342
1343 void AliRunLoader::UnloadAll(Option_t* detectors)
1344 {
1345   //calls UnloadAll for detectors names specified in parameter
1346   // option "all" passed can be passed
1347   TObjArray* loaders;
1348   TObjArray arr;
1349
1350   const char* oAll = strstr(detectors,"all");
1351   if (oAll)
1352    {
1353      loaders = fLoaders;
1354    }
1355   else
1356    {
1357      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1358      loaders = &arr;//get the pointer to array
1359    }
1360
1361   TIter next(loaders);
1362   AliLoader *loader;
1363   while((loader = (AliLoader*)next()))
1364    {
1365     loader->UnloadAll();
1366    }
1367 }
1368 /**************************************************************************/
1369
1370 void AliRunLoader::UnloadTracks(Option_t* detectors)
1371 {
1372   //unloads Tracks for detectors specified in parameter
1373   TObjArray* loaders;
1374   TObjArray arr;
1375
1376   const char* oAll = strstr(detectors,"all");
1377   if (oAll)
1378    {
1379      loaders = fLoaders;
1380    }
1381   else
1382    {
1383      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1384      loaders = &arr;//get the pointer to array
1385    }
1386
1387   TIter next(loaders);
1388   AliLoader *loader;
1389   while((loader = (AliLoader*)next()))
1390    {
1391     loader->UnloadTracks();
1392    }
1393 }
1394 /**************************************************************************/
1395
1396 void AliRunLoader::UnloadRecParticles(Option_t* detectors)
1397 {
1398   //unloads Particles for detectors specified in parameter
1399   TObjArray* loaders;
1400   TObjArray arr;
1401
1402   const char* oAll = strstr(detectors,"all");
1403   if (oAll)
1404    {
1405      loaders = fLoaders;
1406    }
1407   else
1408    {
1409      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
1410      loaders = &arr;//get the pointer to array
1411    }
1412
1413   TIter next(loaders);
1414   AliLoader *loader;
1415   while((loader = (AliLoader*)next()))
1416    {
1417     loader->UnloadRecParticles();
1418    }
1419 }
1420 /**************************************************************************/
1421
1422 AliRunLoader* AliRunLoader::GetRunLoader(const char* eventfoldername)
1423 {
1424 //returns RunLoader from folder named eventfoldername
1425   TFolder* evfold= dynamic_cast<TFolder*>(AliConfig::Instance()->GetTopFolder()->FindObject(eventfoldername));
1426   if (evfold == 0x0)
1427    {
1428      return 0x0;
1429    }
1430   AliRunLoader* runget = dynamic_cast<AliRunLoader*>(evfold->FindObject(AliRunLoader::fgkRunLoaderName));
1431   return runget;
1432
1433 }
1434 /**************************************************************************/
1435
1436 AliLoader* AliRunLoader::GetDetectorLoader(const char* detname, const char* eventfoldername)
1437 {
1438 //get the loader of the detector with the given name from the global
1439 //run loader object
1440   AliRunLoader* runLoader = GetRunLoader(eventfoldername);
1441   if (!runLoader) {
1442     ::Error("AliRunLoader::GetDetectorLoader","No run loader found");
1443     return NULL;
1444   }
1445   return runLoader->GetDetectorLoader(detname);
1446 }
1447 /**************************************************************************/
1448
1449 AliLoader* AliRunLoader::GetDetectorLoader(const char* detname)
1450 {
1451 //get the loader of the detector with the given name from the global
1452 //run loader object
1453
1454   char loadername[256];
1455   sprintf(loadername, "%sLoader", detname);
1456   AliLoader* loader = GetLoader(loadername);
1457   if (!loader) {
1458     Error("GetDetectorLoader", "No loader for %s found", detname);
1459     return NULL;
1460   }
1461   return loader;
1462 }
1463 /**************************************************************************/
1464
1465 TTree* AliRunLoader::GetTreeH(const char* detname, Bool_t maketree, const char* eventfoldername)
1466 {
1467 //get the tree with hits of the detector with the given name
1468 //if maketree is true and the tree does not exist, the tree is created
1469   AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1470   if (!loader) return NULL;
1471   if (!loader->TreeH() && maketree) loader->MakeTree("H");
1472   return loader->TreeH();
1473 }
1474
1475 /**************************************************************************/
1476
1477 TTree* AliRunLoader::GetTreeH(const char* detname, Bool_t maketree)
1478 {
1479 //get the tree with hits of the detector with the given name
1480 //if maketree is true and the tree does not exist, the tree is created
1481   AliLoader* loader = GetDetectorLoader(detname);
1482   if (!loader) return NULL;
1483   if (!loader->TreeH() && maketree) loader->MakeTree("H");
1484   return loader->TreeH();
1485 }
1486 /**************************************************************************/
1487
1488 TTree* AliRunLoader::GetTreeS(const char* detname, Bool_t maketree,const char* eventfoldername)
1489 {
1490 //get the tree with summable digits of the detector with the given name
1491 //if maketree is true and the tree does not exist, the tree is created
1492   AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1493   if (!loader) return NULL;
1494   if (!loader->TreeS() && maketree) loader->MakeTree("S");
1495   return loader->TreeS();
1496 }
1497 /**************************************************************************/
1498
1499 TTree* AliRunLoader::GetTreeS(const char* detname, Bool_t maketree)
1500 {
1501 //get the tree with summable digits of the detector with the given name
1502 //if maketree is true and the tree does not exist, the tree is created
1503   AliLoader* loader = GetDetectorLoader(detname);
1504   if (!loader) return NULL;
1505   if (!loader->TreeS() && maketree) loader->MakeTree("S");
1506   return loader->TreeS();
1507 }
1508 /**************************************************************************/
1509
1510 TTree* AliRunLoader::GetTreeD(const char* detname, Bool_t maketree,const char* eventfoldername)
1511 {
1512 //get the tree with digits of the detector with the given name
1513 //if maketree is true and the tree does not exist, the tree is created
1514   AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1515   if (!loader) return NULL;
1516   if (!loader->TreeD() && maketree) loader->MakeTree("D");
1517   return loader->TreeD();
1518 }
1519 /**************************************************************************/
1520
1521 TTree* AliRunLoader::GetTreeD(const char* detname, Bool_t maketree)
1522 {
1523 //get the tree with digits of the detector with the given name
1524 //if maketree is true and the tree does not exist, the tree is created
1525   AliLoader* loader = GetDetectorLoader(detname);
1526   if (!loader) return NULL;
1527   if (!loader->TreeD() && maketree) loader->MakeTree("D");
1528   return loader->TreeD();
1529 }
1530 /**************************************************************************/
1531 TTree* AliRunLoader::GetTreeR(const char* detname, Bool_t maketree,const char* eventfoldername)
1532 {
1533 //get the tree with clusters of the detector with the given name
1534 //if maketree is true and the tree does not exist, the tree is created
1535   AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1536   if (!loader) return NULL;
1537   if (!loader->TreeR() && maketree) loader->MakeTree("R");
1538   return loader->TreeR();
1539 }
1540 /**************************************************************************/
1541
1542 TTree* AliRunLoader::GetTreeR(const char* detname, Bool_t maketree)
1543 {
1544 //get the tree with clusters of the detector with the given name
1545 //if maketree is true and the tree does not exist, the tree is created
1546   AliLoader* loader = GetDetectorLoader(detname);
1547   if (!loader) return NULL;
1548   if (!loader->TreeR() && maketree) loader->MakeTree("R");
1549   return loader->TreeR();
1550 }
1551 /**************************************************************************/
1552
1553 TTree* AliRunLoader::GetTreeT(const char* detname, Bool_t maketree,const char* eventfoldername)
1554 {
1555 //get the tree with tracks of the detector with the given name
1556 //if maketree is true and the tree does not exist, the tree is created
1557   AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1558   if (!loader) return NULL;
1559   if (!loader->TreeT() && maketree) loader->MakeTree("T");
1560   return loader->TreeT();
1561 }
1562 /**************************************************************************/
1563
1564 TTree* AliRunLoader::GetTreeT(const char* detname, Bool_t maketree)
1565 {
1566 //get the tree with tracks of the detector with the given name
1567 //if maketree is true and the tree does not exist, the tree is created
1568   AliLoader* loader = GetDetectorLoader(detname);
1569   if (!loader) return NULL;
1570   if (!loader->TreeT() && maketree) loader->MakeTree("T");
1571   return loader->TreeT();
1572 }
1573 /**************************************************************************/
1574
1575 TTree* AliRunLoader::GetTreeP(const char* detname, Bool_t maketree,const char* eventfoldername)
1576 {
1577 //get the tree with particles of the detector with the given name
1578 //if maketree is true and the tree does not exist, the tree is created
1579   AliLoader* loader = GetDetectorLoader(detname,eventfoldername);
1580   if (!loader) return NULL;
1581   if (!loader->TreeP() && maketree) loader->MakeTree("P");
1582   return loader->TreeP();
1583 }
1584 /**************************************************************************/
1585
1586 TTree* AliRunLoader::GetTreeP(const char* detname, Bool_t maketree)
1587 {
1588 //get the tree with particles of the detector with the given name
1589 //if maketree is true and the tree does not exist, the tree is created
1590   AliLoader* loader = GetDetectorLoader(detname);
1591   if (!loader) return NULL;
1592   if (!loader->TreeP() && maketree) loader->MakeTree("P");
1593   return loader->TreeP();
1594 }
1595
1596 /**************************************************************************/
1597
1598 void AliRunLoader::CdGAFile()
1599 {
1600 //sets gDirectory to galice file
1601 //work around
1602   if(fGAFile) fGAFile->cd();
1603 }
1604
1605 /**************************************************************************/
1606
1607 void AliRunLoader::GetListOfDetectors(const char * namelist,TObjArray& pointerarray) const
1608  {
1609 //this method looks for all Loaders corresponding
1610 //to names (many) specified in namelist i.e. namelist ("ITS TPC TRD")
1611
1612    char buff[10];
1613    char dets [200];
1614    strcpy(dets,namelist);//compiler cries when char* = const Option_t*;
1615    dets[strlen(dets)+1] = '\n';//set endl at the end of string
1616    char* pdet = dets;
1617    Int_t tmp;
1618    for(;;)
1619     {
1620       tmp = sscanf(pdet,"%s",buff);//read the string from the input string pdet into buff
1621       if ( (buff[0] == 0) || (tmp == 0) ) break; //if not read
1622
1623       pdet = strstr(pdet,buff) + strlen(buff);//move the input pointer about number of bytes (letters) read
1624       //I am aware that is a little complicated. I don't know the number of spaces between detector names
1625       //so I read the string, than I find where it starts (strstr) and move the pointer about length of a string
1626       //If there is a better way, please write me (Piotr.Skowronski@cern.ch)
1627       //construct the Loader name
1628       TString getname(buff);
1629       getname+="Loader";
1630       AliLoader* loader = GetLoader(getname);//get the Loader
1631       if (loader)
1632        {
1633         pointerarray.Add(loader);
1634        }
1635       else
1636        {
1637         Error("GetListOfDetectors","Can not find Loader for %s",buff);
1638        }
1639
1640       buff[0] = 0;
1641     }
1642  }
1643 /*****************************************************************************/
1644
1645 void AliRunLoader::Clean(const TString& name)
1646 {
1647 //removes object with given name from event folder and deletes it
1648   if (GetEventFolder() == 0x0) return;
1649   TObject* obj = GetEventFolder()->FindObject(name);
1650   if(obj)
1651    {
1652      if (GetDebug()) Info("Clean(const TString&)","name=%s, cleaning %s.",GetName(),name.Data());
1653      GetEventFolder()->Remove(obj);
1654      delete obj;
1655    }
1656 }
1657
1658 /*****************************************************************************/
1659
1660 TTask* AliRunLoader::GetRunDigitizer()
1661 {
1662 //returns Run Digitizer from folder
1663
1664  TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1665  TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetDigitizerTaskName());
1666  return (obj)?dynamic_cast<TTask*>(obj):0x0;
1667 }
1668 /*****************************************************************************/
1669
1670 TTask* AliRunLoader::GetRunSDigitizer()
1671 {
1672 //returns SDigitizer Task from folder
1673
1674  TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1675  TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetSDigitizerTaskName());
1676  return (obj)?dynamic_cast<TTask*>(obj):0x0;
1677 }
1678 /*****************************************************************************/
1679
1680 TTask* AliRunLoader::GetRunReconstructioner()
1681 {
1682 //returns Reconstructioner Task from folder
1683  TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1684  TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetReconstructionerTaskName());
1685  return (obj)?dynamic_cast<TTask*>(obj):0x0;
1686 }
1687 /*****************************************************************************/
1688
1689 TTask* AliRunLoader::GetRunTracker()
1690 {
1691 //returns Tracker Task from folder
1692  TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1693  TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetTrackerTaskName());
1694  return (obj)?dynamic_cast<TTask*>(obj):0x0;
1695 }
1696 /*****************************************************************************/
1697
1698 TTask* AliRunLoader::GetRunPIDTask()
1699 {
1700 //returns Tracker Task from folder
1701  TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1702  TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetPIDTaskName());
1703  return (obj)?dynamic_cast<TTask*>(obj):0x0;
1704 }
1705 /*****************************************************************************/
1706
1707 TTask* AliRunLoader::GetRunQATask()
1708 {
1709 //returns Quality Assurance Task from folder
1710  TFolder* topf = AliConfig::Instance()->GetTaskFolder();
1711  if (topf == 0x0)
1712   {
1713     ::Error("AliRunLoader::GetRunQATask","Can not get task folder from AliConfig");
1714     return 0x0;
1715   }
1716  TObject* obj = topf->FindObjectAny(AliConfig::Instance()->GetQATaskName());
1717  return (obj)?dynamic_cast<TTask*>(obj):0x0;
1718 }
1719
1720 /*****************************************************************************/
1721
1722 void AliRunLoader::SetCompressionLevel(Int_t cl)
1723 {
1724 //Sets Compression Level in all files
1725  if (fGAFile) fGAFile->SetCompressionLevel(cl);
1726  SetKineComprLevel(cl);
1727  SetTrackRefsComprLevel(cl);
1728  TIter next(fLoaders);
1729  AliLoader *loader;
1730  while((loader = (AliLoader*)next()))
1731   {
1732    loader->SetCompressionLevel(cl);
1733   }
1734 }
1735 /**************************************************************************/
1736
1737 void AliRunLoader::SetKineComprLevel(Int_t cl)
1738 {
1739 //Sets comression level in Kine File
1740   fKineDataLoader->SetCompressionLevel(cl);
1741 }
1742 /**************************************************************************/
1743
1744 void AliRunLoader::SetTrackRefsComprLevel(Int_t cl)
1745 {
1746 //Sets comression level in Track Refences File
1747   fTrackRefsDataLoader->SetCompressionLevel(cl);
1748 }
1749 /**************************************************************************/
1750
1751 void AliRunLoader::UnloadHeader()
1752 {
1753  //removes TreeE from folder and deletes it
1754  // as well as fHeader object
1755  CleanHeader();
1756  delete fHeader;
1757  fHeader = 0x0;
1758 }
1759 /**************************************************************************/
1760
1761 void AliRunLoader::UnloadKinematics()
1762 {
1763 //Unloads Kinematics
1764  fKineDataLoader->GetBaseLoader(0)->Unload();
1765 }
1766 /**************************************************************************/
1767
1768 void AliRunLoader::UnloadTrackRefs()
1769 {
1770 //Unloads Track Refernces
1771  fTrackRefsDataLoader->GetBaseLoader(0)->Unload();
1772 }
1773 /**************************************************************************/
1774
1775 void AliRunLoader::UnloadgAlice()
1776 {
1777 //Unloads gAlice
1778  if (gAlice == GetAliRun())
1779   {
1780    if (GetDebug()) Info("UnloadgAlice","Set gAlice = 0x0");
1781    gAlice = 0x0;//if gAlice is the same that in folder (to be deleted by the way of folder)
1782   }
1783  AliRun* alirun = GetAliRun();
1784  if (GetEventFolder()) GetEventFolder()->Remove(alirun);
1785  delete alirun;
1786 }
1787 /**************************************************************************/
1788
1789 void  AliRunLoader::MakeTrackRefsContainer()
1790 {
1791 // Makes a tree for Track References
1792   fTrackRefsDataLoader->MakeTree();
1793 }
1794 /**************************************************************************/
1795
1796 Int_t AliRunLoader::LoadTrackRefs(Option_t* option)
1797 {
1798 //Load track references from file (opens file and posts tree to folder)
1799
1800  return fTrackRefsDataLoader->GetBaseLoader(0)->Load(option);
1801 }
1802 /**************************************************************************/
1803
1804 void  AliRunLoader::SetDirName(TString& dirname)
1805 {
1806 //sets directory name
1807   if (dirname.IsNull()) return;
1808   fUnixDirName = dirname;
1809   fKineDataLoader->SetDirName(dirname);
1810   fTrackRefsDataLoader->SetDirName(dirname);
1811
1812   TIter next(fLoaders);
1813   AliLoader *loader;
1814   while((loader = (AliLoader*)next()))
1815    {
1816     loader->SetDirName(dirname);
1817    }
1818
1819 }
1820 /*****************************************************************************/
1821
1822 Int_t AliRunLoader::GetFileOffset() const
1823 {
1824 //returns the file number that is added to the file name for current event
1825   return Int_t(fCurrentEvent/fNEventsPerFile);
1826 }
1827
1828 /*****************************************************************************/
1829 const TString AliRunLoader::SetFileOffset(const TString& fname)
1830 {
1831 //adds the the number to the file name at proper place for current event
1832   Long_t offset = (Long_t)GetFileOffset();
1833   if (offset < 1) return fname;
1834   TString soffset;
1835   soffset += offset;//automatic conversion to string
1836   TString dotroot(".root");
1837   const TString& offfsetdotroot = offset + dotroot;
1838   TString out = fname;
1839   out = out.ReplaceAll(dotroot,offfsetdotroot);
1840   if (GetDebug()) Info("SetFileOffset"," in=%s out=%s",fname.Data(),out.Data());
1841   return out;
1842 }
1843 /*****************************************************************************/
1844
1845 void AliRunLoader::SetDigitsFileNameSuffix(const TString& suffix)
1846 {
1847 //adds the suffix before ".root",
1848 //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
1849 //made on Jiri Chudoba demand
1850
1851   TIter next(fLoaders);
1852   AliLoader *Loader;
1853   while((Loader = (AliLoader*)next()))
1854    {
1855      Loader->SetDigitsFileNameSuffix(suffix);
1856    }
1857 }
1858 /*****************************************************************************/
1859
1860 TString AliRunLoader::GetFileName() const
1861 {
1862 //returns name of galice file
1863  TString result;
1864  if (fGAFile == 0x0) return result;
1865  result = fGAFile->GetName();
1866  return result;
1867 }
1868 /*****************************************************************************/
1869
1870 void AliRunLoader::SetDetectorAddresses()
1871 {
1872  //calls SetTreeAddress for all detectors
1873   if (GetAliRun()==0x0) return;
1874   TIter next(GetAliRun()->Modules());
1875   AliModule* mod;
1876   while((mod = (AliModule*)next()))
1877    {
1878      AliDetector* det = dynamic_cast<AliDetector*>(mod);
1879      if (det) det->SetTreeAddress();
1880    }
1881 }
1882 /*****************************************************************************/
1883
1884 void AliRunLoader::Synchronize()
1885 {
1886   //synchrinizes all writtable files
1887   TIter next(fLoaders);
1888   AliLoader *loader;
1889   while((loader = (AliLoader*)next()))
1890    {
1891      loader->Synchronize();
1892    }
1893
1894   fKineDataLoader->Synchronize();
1895   fTrackRefsDataLoader->Synchronize();
1896
1897 }
1898 /*****************************************************************************/
1899 /*****************************************************************************/