polish

[u/mrichter/AliRoot.git] / STEER / AliLoader.cxx

diff --git a/STEER/AliLoader.cxx b/STEER/AliLoader.cxx
index 34ed89c2d7179f345df0b4ef5780a2d28b7bed76..480c11260a763d579d6a001c5788f805a02d005e 100644 (file)
--- a/STEER/AliLoader.cxx
+++ b/STEER/AliLoader.cxx
@@ -24,6 +24,7 @@
 #include <AliRunDigitizer.h>
 #include <AliDigitizer.h>
 #include <AliDetector.h>
+#include "AliConfig.h"
 
 Int_t  AliLoader::fgDebug = 0;
 
@@ -111,7 +112,24 @@ AliLoader::AliLoader(const Char_t * detname,TFolder* eventfolder):
    //fileoption's don't need to initialized because default TString ctor does it correctly
 }
 /*****************************************************************************/ 
+AliLoader::AliLoader(const AliLoader& source):TNamed(source) {
+  // dummy copy constructor
+  if(&source==this)return;
+  
+  Fatal("AliLoader","Copy constructor not implemented. Aborting");
+  return;
+}
 
+/*****************************************************************************/ 
+AliLoader& AliLoader::operator=(const AliLoader& source) {
+  // dummy assignment operator
+  if(&source==this) return *this;
+  
+  Fatal("AliLoader","Assignment operator not implemented. Aborting");
+  return *this;
+}
+
+/*****************************************************************************/ 
 AliLoader::~AliLoader()
 {
 //detructor
@@ -172,6 +190,24 @@ AliDataLoader* AliLoader::GetDataLoader(const char* name)
   return dynamic_cast<AliDataLoader*>(fDataLoaders->FindObject(name));
 }
 /*****************************************************************************/ 
+void AliLoader::AddDataLoader(AliDataLoader* dl)
+{
+
+  if (dl == 0x0)
+   {
+     Error("AddDataLoader","Pointer is NULL");
+     return;
+   }
+  if (fDataLoaders->FindObject(dl->GetName()))
+   {
+     Error("AddDataLoader","Such a loader exists");
+     return;
+   }
+  fDataLoaders->AddLast(dl);
+  dl->SetEventFolder(fEventFolder);
+  dl->SetFolder(GetDetectorDataFolder()); //Must exists - ensure register is called before
+}
+/*****************************************************************************/ 
 
 Int_t AliLoader::SetEvent()
 {
@@ -279,6 +315,7 @@ TFolder* AliLoader::GetTasksFolder()
 
 TFolder* AliLoader::GetModulesFolder()
 {
+  //returns pointer to the folder containing modules
  if (!fModuleFolder)
   {
    fModuleFolder =  dynamic_cast<TFolder*>(GetEventFolder()->FindObjectAny(AliConfig::GetModulesFolderName()));
@@ -312,7 +349,7 @@ TFolder* AliLoader::GetQAFolder()
   
 }
 /*****************************************************************************/ 
-TTask* AliLoader::SDigitizer()
+TTask* AliLoader::SDigitizer() const
 {
 //returns SDigitizer task for this detector
   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Task();
@@ -320,14 +357,14 @@ TTask* AliLoader::SDigitizer()
 }
 /*****************************************************************************/ 
 
-AliDigitizer* AliLoader::Digitizer()
+AliDigitizer* AliLoader::Digitizer() const
 {
 //returns Digitizer task for this detector
   return dynamic_cast<AliDigitizer*>(GetDigitsDataLoader()->GetBaseTaskLoader()->Task());
 }
 /*****************************************************************************/ 
 
-TTask* AliLoader::Reconstructioner()
+TTask* AliLoader::Reconstructioner() const
 {
 //returns Recontructioner (Cluster Finder, Cluster Maker, 
 //or whatever you want to call it) task for this detector
@@ -335,14 +372,14 @@ TTask* AliLoader::Reconstructioner()
 }
 /*****************************************************************************/ 
 
-TTask* AliLoader::Tracker()
+TTask* AliLoader::Tracker() const
 {
 //returns tracker
   return dynamic_cast<TTask*>(GetTracksDataLoader()->GetBaseTaskLoader()->Task());
 }
 
 /*****************************************************************************/ 
-TTask* AliLoader::PIDTask()
+TTask* AliLoader::PIDTask() const
 {
 //returns tracker
   return dynamic_cast<TTask*>(GetRecParticlesDataLoader()->GetBaseTaskLoader()->Task());
@@ -350,8 +387,9 @@ TTask* AliLoader::PIDTask()
 
 /*****************************************************************************/ 
 
-TTask* AliLoader::QAtask(const char* name)
+TTask* AliLoader::QAtask(const char* name) const
 {
+  // Returns pointer to the quality assurance task
   TTask* qat = AliRunLoader::GetRunQATask();
   if ( qat == 0x0 ) 
    {
@@ -447,7 +485,7 @@ TDirectory* AliLoader::ChangeDir(TFile* file, Int_t eventno)
 }
 /*****************************************************************************/ 
 
-TString AliLoader::GetUnixDir()
+TString AliLoader::GetUnixDir() const
  {
  //This Method will manage jumping through unix directories in case of 
  //run with more events per run than defined in gAlice
@@ -484,16 +522,18 @@ void AliLoader::MakeTree(Option_t *option)
  }
 
 /*****************************************************************************/ 
-Int_t  AliLoader::WriteHits(Option_t* opt)
+Int_t  AliLoader::WriteHits(Option_t* opt) const
  {
+   // Writes hits
    AliDataLoader* dl = GetHitsDataLoader();
    Int_t ret = dl->WriteData(opt);
    return ret;
  }
 /*****************************************************************************/ 
 
-Int_t AliLoader::WriteSDigits(Option_t* opt)
+Int_t AliLoader::WriteSDigits(Option_t* opt) const
  {
+   // Writes summable digits
    AliDataLoader* dl = GetSDigitsDataLoader();
    Int_t ret = dl->WriteData(opt);
    return ret;
@@ -501,38 +541,44 @@ Int_t AliLoader::WriteSDigits(Option_t* opt)
  
 /*****************************************************************************/ 
 
-Int_t AliLoader::PostSDigitizer(TTask* sdzer)
+Int_t AliLoader::PostSDigitizer(TTask* sdzer) const
 {
+  // Posts sdigitizer
   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Post(sdzer);
 }
 /*****************************************************************************/ 
 
-Int_t AliLoader::PostDigitizer(AliDigitizer* task)
+Int_t AliLoader::PostDigitizer(AliDigitizer* task) const
  {
+   // Posts digitizer
   return GetDigitsDataLoader()->GetBaseTaskLoader()->Post(task);
  }
 /*****************************************************************************/ 
 
-Int_t AliLoader::PostReconstructioner(TTask* task)
+Int_t AliLoader::PostReconstructioner(TTask* task) const
  {
+   // Posts Reconstructioner
   return GetRecPointsDataLoader()->GetBaseTaskLoader()->Post(task);
  }
 /*****************************************************************************/ 
 
-Int_t AliLoader::PostTracker(TTask* task)
+Int_t AliLoader::PostTracker(TTask* task) const
  {
+   // Posts a tracker
   return GetTracksDataLoader()->GetBaseTaskLoader()->Post(task);
  }
 /*****************************************************************************/ 
 
-Int_t AliLoader::PostPIDTask(TTask* task)
+Int_t AliLoader::PostPIDTask(TTask* task) const
  {
+  // Posts particle identification task
   return GetRecParticlesDataLoader()->GetBaseTaskLoader()->Post(task);
  }
 /*****************************************************************************/ 
 
 TObject** AliLoader::GetDetectorDataRef(TObject *obj)
 {
+  // Returns pointer to an entry in the list of folders pointing to "obj"
  if (obj == 0x0)
   {
     return 0x0;
@@ -543,6 +589,7 @@ TObject** AliLoader::GetDetectorDataRef(TObject *obj)
 
 TObject** AliLoader::SDigitizerRef()
 {
+  // Returns pointer to a Runloader's task-list entry pointing to SDigitizer
   TTask* rsd = AliRunLoader::GetRunSDigitizer();
   if (rsd == 0x0)
    {
@@ -554,6 +601,7 @@ TObject** AliLoader::SDigitizerRef()
 
 TObject** AliLoader::DigitizerRef()
 {
+  // Returns pointer to a Runloader's task-list entry pointing to Digitizer
  TTask* rd = AliRunLoader::GetRunDigitizer();
  if (rd == 0x0)
   {
@@ -565,6 +613,7 @@ TObject** AliLoader::DigitizerRef()
 
 TObject** AliLoader::ReconstructionerRef()
 {
+  // Returns pointer to a Runloader's task-list entry pointing to Reconstructioner
   TTask* rrec = AliRunLoader::GetRunReconstructioner();
   if (rrec == 0x0)
    {
@@ -576,6 +625,7 @@ TObject** AliLoader::ReconstructionerRef()
 
 TObject** AliLoader::TrackerRef()
 {
+  // Returns pointer to a Runloader's task-list entry pointing to Tracker
    TTask* rrec = AliRunLoader::GetRunTracker();
    if (rrec == 0x0)
     {
@@ -587,6 +637,7 @@ TObject** AliLoader::TrackerRef()
 
 TObject** AliLoader::PIDTaskRef()
 {
+  // Returns pointer to a Runloader's task-list entry pointing to PIDTask
   TTask* rrec = AliRunLoader::GetRunPIDTask();
   if (rrec == 0x0)
    {
@@ -694,6 +745,7 @@ void AliLoader::CleanPIDTask()
 
 Int_t AliLoader::ReloadAll()
 {
+  // Calling Reload function for all the data loaders
  TIter next(fDataLoaders);
  AliDataLoader* dl;
  
@@ -724,6 +776,7 @@ void AliLoader::CloseFiles()
 
 Int_t  AliLoader::SetEventFolder(TFolder* eventfolder)
 {
+  //sets the event folder
  if (eventfolder == 0x0)
   {
     Error("SetEventFolder","Stupid joke. Argument is NULL");
@@ -804,7 +857,7 @@ void  AliLoader::SetDirName(TString& dirname)
 
 /*****************************************************************************/ 
 
-void AliLoader::SetDigitsFileNameSuffix(const TString& suffix)
+void AliLoader::SetDigitsFileNameSuffix(const TString& suffix) const
 {
   //adds the suffix before ".root", 
   //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
@@ -839,6 +892,8 @@ void AliLoader::Clean()
 
 void AliLoader::Clean(const TString& name)
 {
+  // Removes object with "name" from the detector's data folder
+  // and from the memory
   TObject* obj = GetDetectorDataFolder()->FindObject(name);
   if(obj)
    {
@@ -853,6 +908,7 @@ void AliLoader::Clean(const TString& name)
 
 Bool_t AliLoader::IsOptionWritable(const TString& opt)
 {
+  // Returns "true" if the option means also "writable"
   if (opt.CompareTo("recreate",TString::kIgnoreCase)) return kTRUE;
   if (opt.CompareTo("new",TString::kIgnoreCase)) return kTRUE;
   if (opt.CompareTo("create",TString::kIgnoreCase)) return kTRUE;