Corrections to obey our coding conventions
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 3 Nov 2003 08:36:21 +0000 (08:36 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 3 Nov 2003 08:36:21 +0000 (08:36 +0000)
STEER/AliConfig.cxx
STEER/AliConfig.h
STEER/AliDataLoader.cxx
STEER/AliDataLoader.h
STEER/AliLoader.cxx
STEER/AliLoader.h
STEER/AliMC.cxx
STEER/AliMC.h
STEER/AliRunLoader.cxx
STEER/AliRunLoader.h
STEER/AliStack.cxx

index e2f5dd3..b69e05c 100644 (file)
@@ -62,7 +62,7 @@ enum
  };
 ClassImp(AliConfig)
 
-AliConfig* AliConfig::fInstance = 0;
+AliConfig* AliConfig::fgInstance = 0;
 
 //0 level folder
 const TString AliConfig::fgkTopFolderName("Folders");
@@ -111,11 +111,11 @@ AliConfig* AliConfig::Instance ()
   //
   // Instance method for singleton class
   //
-   if(fInstance == 0) 
+   if(fgInstance == 0) 
     {
-     fInstance = new AliConfig (fgkTopFolderName,"Alice data exchange board");
+     fgInstance = new AliConfig (fgkTopFolderName,"Alice data exchange board");
     }
-   return fInstance;
+   return fgInstance;
 }
 
 //____________________________________________________________________________
@@ -129,7 +129,7 @@ AliConfig::AliConfig():
   //
   // Default constructor, mainly to keep coding conventions
   //
-  fInstance=0;//never mind, its going to exit in next step
+  fgInstance=0;//never mind, its going to exit in next step
   Fatal("ctor","Constructor should not be called for a singleton\n");
 }
 //____________________________________________________________________________
@@ -145,13 +145,26 @@ AliConfig::AliConfig(const AliConfig& conf):
   //
   // Copy constructor, mainly to keep coding conventions
   //
-  fInstance=0;
+  fgInstance=0;
     
   Fatal("copy ctor",
    "Copy constructor should not be called for a singleton\n");
 }
 //____________________________________________________________________________
 
+AliConfig& AliConfig::operator=(const AliConfig& /*conf*/)
+{
+  //
+  // Assignment, mainly to keep coding conventions
+  //
+  fgInstance=0;
+    
+  Fatal("Assignment operator",
+   "Assignment operator should not be called for a singleton\n");
+  return *this;
+}
+//____________________________________________________________________________
+
 AliConfig::AliConfig(const char *name, const char *title): 
   TNamed(name,title), 
   fTopFolder(gROOT->GetRootFolder()->AddFolder(name,title)),
@@ -206,12 +219,13 @@ AliConfig::AliConfig(const char *name, const char *title):
   fDetectorTask[kDetTaskPID] = fgkPIDTaskName;
   fDetectorTask[kDetTaskLast] = "";
 
-  fInstance=this;
+  fgInstance=this;
 }
 
 //____________________________________________________________________________
 AliConfig::~AliConfig()
 { 
+  // destructor
   delete [] fDetectorFolder ;  
   delete [] fDetectorTask;
   if (fTopFolder)
@@ -224,6 +238,7 @@ AliConfig::~AliConfig()
 
 void AliConfig::AddInFolder (const char *dir, TObject *obj)
 {
+  // Adds object "obj" to folder "dir"
   TFolder *folder = dynamic_cast<TFolder *>(fTopFolder->FindObject(dir));
   if (folder)
     folder->Add (static_cast<TObject *>(obj));
@@ -235,12 +250,12 @@ Int_t AliConfig::AddSubTask(const char *taskname, const char* name,const char* t
 //Create new task named 'name' and titled 'title' 
 //as a subtask of the task named 'taskname'
 
-   if (AliLoader::fgDebug) Info("AddSubTask","Try to get folder named %s",taskname);
+   if (AliLoader::GetDebug()) Info("AddSubTask","Try to get folder named %s",taskname);
    TObject* obj = fTopFolder->FindObject(taskname);
    TTask * task = (obj)?dynamic_cast<TTask*>(obj):0x0;
    if (task)
      {
-      if (AliLoader::fgDebug) Info("AddSubTask","          Got");
+      if (AliLoader::GetDebug()) Info("AddSubTask","          Got");
       TTask * subtask = static_cast<TTask*>(task->GetListOfTasks()->FindObject(name));
       if (!subtask) 
         {
@@ -263,6 +278,7 @@ Int_t AliConfig::AddSubTask(const char *taskname, const char* name,const char* t
 //____________________________________________________________________________
 TObject* AliConfig::FindInFolder (const char *dir, const char *name)
 {
+  // Finds object with name "name" in folder "dir"
   if(!name) return(fTopFolder->FindObject(name));
   TFolder * folder = dynamic_cast<TFolder *>(fTopFolder->FindObject(dir));
   if (!folder) return (NULL);
@@ -272,6 +288,7 @@ TObject* AliConfig::FindInFolder (const char *dir, const char *name)
 //____________________________________________________________________________
 void    AliConfig::Add (AliGenerator * obj,const char* eventfolder)
 {
+  // Adds generator "obj" to the event folder "eventfolder"
   TString path(eventfolder);
   path = path + "/" + fgkGeneratorsFolderName;
   AddInFolder(path,obj);
@@ -280,6 +297,7 @@ void    AliConfig::Add (AliGenerator * obj,const char* eventfolder)
 //____________________________________________________________________________
 void AliConfig::Add (TVirtualMC * obj,const char* eventfolder)
 {
+  // Adds TVirtualMC object to the event folder
   TString path(eventfolder);
   path = path + "/" + fgkMCFolderName;
   AddInFolder(path, obj);
@@ -288,16 +306,17 @@ void AliConfig::Add (TVirtualMC * obj,const char* eventfolder)
 //____________________________________________________________________________
 void  AliConfig::Add (TDatabasePDG * obj)
 {
+  // Adds TDataBase object
   AddInFolder(fgkPDGFolderName, obj);
 }
 
 //____________________________________________________________________________
 void AliConfig::Add(AliModule* obj,const char* eventfolder)
 {
-  
+  // Adds module to the event folder
   TString path(eventfolder);
   path = path + "/" + fgkModuleFolderName;
-  if (AliLoader::fgDebug)
+  if (AliLoader::GetDebug())
     Info("Add(AliModule*)","module name = %s, Ev. Fold. Name is %s.",
          obj->GetName(),eventfolder);
   AddInFolder(path, obj);
@@ -340,7 +359,8 @@ Int_t AliConfig::AddDetector(const char* evntfoldername,const char *name, const
 
 void  AliConfig::Add(AliDetector * obj,const char* eventfolder)
 {
-  if (AliLoader::fgDebug) 
+  // Adds new AliDetector objest to the correspondent event folder
+  if (AliLoader::GetDebug()) 
     Info("Add(AliDetector*)","detector name = %s, Ev. Fold. Name is %s.",
         obj->GetName(),eventfolder);
 
@@ -401,6 +421,7 @@ Int_t  AliConfig::CreateDetectorFolders(TFolder* evntfolder,const char *name, co
 //____________________________________________________________________________
 Int_t AliConfig::CreateDetectorTasks(const char *name, const char* title)
 {
+  // Creates new detector's task "name"
    Int_t i = 0;
    Int_t tmp;
    while (i < kDetTaskLast)
@@ -421,12 +442,14 @@ Int_t AliConfig::CreateDetectorTasks(const char *name, const char* title)
 //____________________________________________________________________________
 void    AliConfig::Add (char *list)
 {
+  // Adds space separated list of objects to the
+  // configuration macro (?)
   char *path;
   
-  const char   *conf_path = gSystem->Getenv ("ALICE_CONFIG_PATH");
-  if  (conf_path) {
-    path = new char[strlen (conf_path)];
-    strcpy (path, conf_path);
+  const char   *confPath = gSystem->Getenv ("ALICE_CONFIG_PATH");
+  if  (confPath) {
+    path = new char[strlen (confPath)];
+    strcpy (path, confPath);
   } else {
     const char   *alice = gSystem->Getenv ("ALICE_ROOT");
     path = new char[strlen (alice) + 32];
@@ -699,7 +722,7 @@ const TString& AliConfig::GetQAFolderName() const
 }
 /*****************************************************************************/
 
-const TString& AliConfig::GetDataFolderName()
+const TString& AliConfig::GetDataFolderName() const
 {
 //returns name of data folder path relative to event folder
  return fgkDataFolderName;
index 57329d1..709f427 100644 (file)
@@ -42,34 +42,6 @@ public:
   
   static     AliConfig* Instance();
   
-private:
-  AliConfig(const char * name, const char * title );
-  AliConfig(const AliConfig&);
-
-  void          AddInFolder (const char * dir, TObject *obj);
-  Int_t         AddSubTask(const char *taskname, const char* name, const char* title);
-  Int_t         AddSubFolder(TFolder* topfolder, const char* infoler, //helper method
-                     const char* newfoldname, const char* newfoldtitle);
-  TObject*      FindInFolder (const char *dir, const char *name);
-  
-  // folders
-  TFolder*              fTopFolder;
-  TFolder*              fTaskFolder;
-  TFolder*              fConstFolder;
-
-  static const TString  fgkPDGFolderName; 
-  static const TString  fgkGeneratorFolderName; 
-  static const TString  fgkMCFolderName;
-  static const TString  fgkModuleFolderName;
-  
-  TString              *fDetectorTask;//!array with names for detector tasks
-  TString              *fDetectorFolder;//!array with names for detector folders (where detector is going to be put)
-  
-  static AliConfig*     fInstance;
-  
-  
- public:
-
   TFolder*              BuildEventFolder(const char* name,const char* tilte);
   
   TFolder*              GetTopFolder(){return fTopFolder;}
@@ -88,33 +60,61 @@ private:
   
   const TString&        GetQAFolderName() const; //returns path to folder with QA output
   
-  const TString&        GetDataFolderName();//returns name of data folder
+  const TString&        GetDataFolderName() const;//returns name of data folder
   
   static const TString  fgkTopFolderName; //name of top AliRoot folder
  
-  static const TString  fgkDefaultEventFolderName; 
-  static const TString  fgkTasksFolderName;
-  static const TString  fgkConstantsFolderName;
-  
-  static const TString  fgkDataFolderName;  
-  static const TString  fgkConditionsFolderName;
-  static const TString  fgkConfigurationFolderName;
-  static const TString  fgkHeaderFolderName;
-  
-  static const TString  fgkDigitizerTaskName;
-  static const TString  fgkSDigitizerTaskName;
-  static const TString  fgkQATaskName;
-  static const TString  fgkReconstructionerTaskName;
-  static const TString  fgkTrackerTaskName;
-  static const TString  fgkPIDTaskName;
-  
-  static const TString  fgkCalibrationFolderName;
-  static const TString  fgkAligmentFolderName;
-  static const TString  fgkQAFolderName;
-  
-  static const TString  fgkFieldFolderName;
-  static const TString  fgkGeneratorsFolderName;
-  static const TString  fgkVirtualMCFolderName;
+  static const TString  fgkDefaultEventFolderName; //name of event folder
+  static const TString  fgkTasksFolderName;        //name of task folder
+  static const TString  fgkConstantsFolderName;    //name of constants folder
+  
+  static const TString  fgkDataFolderName;         //name of data folde
+  static const TString  fgkConditionsFolderName;   //name of conditions folder
+  static const TString  fgkConfigurationFolderName;//name of configuration foolder
+  static const TString  fgkHeaderFolderName;       //name of header folder
+  
+  static const TString  fgkDigitizerTaskName;      //name of digitizer task
+  static const TString  fgkSDigitizerTaskName;     //name of sdigitizer task
+  static const TString  fgkQATaskName;             //name of Q-A task
+  static const TString  fgkReconstructionerTaskName;//name of reconstructioner
+                                                    //task
+  static const TString  fgkTrackerTaskName;        //name of tracker task 
+  static const TString  fgkPIDTaskName;            //name of PID task
+  
+  static const TString  fgkCalibrationFolderName;  //name of calibration folder
+  static const TString  fgkAligmentFolderName;     //name of alignment folder
+  static const TString  fgkQAFolderName;           //name of QA folder
+  
+  static const TString  fgkFieldFolderName;        //name of magn.field folder
+  static const TString  fgkGeneratorsFolderName;   //name of generator folder
+  static const TString  fgkVirtualMCFolderName;    //name of virtual MC folder
+
+private:
+  AliConfig(const char * name, const char * title );
+  AliConfig(const AliConfig&);
+  AliConfig& operator=(const AliConfig&);
+
+  void          AddInFolder (const char * dir, TObject *obj);
+  Int_t         AddSubTask(const char *taskname, const char* name, const char* title);
+  Int_t         AddSubFolder(TFolder* topfolder, const char* infoler, //helper method
+                     const char* newfoldname, const char* newfoldtitle);
+  TObject*      FindInFolder (const char *dir, const char *name);
+  
+  // folders
+  TFolder*              fTopFolder;    //pointer to top folder
+  TFolder*              fTaskFolder;   //pointer to task folder
+  TFolder*              fConstFolder;  //pointer to constants folder
+
+  static const TString  fgkPDGFolderName; //name of PDG folder
+  static const TString  fgkGeneratorFolderName; //name of generator name
+  static const TString  fgkMCFolderName;        //name of MC folder
+  static const TString  fgkModuleFolderName;    //name of module folder
+  
+  TString              *fDetectorTask;//!array with names for detector tasks
+  TString              *fDetectorFolder;//!array with names for detector folders (where detector is going to be put)
+  
+  static AliConfig*     fgInstance; //pointer to the AliConfig instance
+  
   
   ClassDef(AliConfig,2) //Configuration class for AliRun
 };                             // end class AliConfig
index 498e3fd..139edb9 100644 (file)
@@ -86,6 +86,17 @@ AliDataLoader::AliDataLoader(const char* filename, const char* contname, const c
   
 }
 /*****************************************************************************/ 
+AliDataLoader::AliDataLoader(const AliDataLoader& source):TNamed(source) {
+  // copy constructor
+  Fatal("AliDataLoader","Copy constructor not implemented");
+}
+/*****************************************************************************/ 
+AliDataLoader& AliDataLoader::operator=(const AliDataLoader& /*source*/) {
+  // Assignment operator
+  Fatal("AliDataLoader","Assignment operator not implemented");
+  return *this;
+}
+/*****************************************************************************/ 
 
 AliDataLoader::~AliDataLoader()
 {
@@ -331,7 +342,7 @@ Int_t  AliDataLoader::SetEventFolder(TFolder* eventfolder)
 
 Int_t  AliDataLoader::SetFolder(TFolder* folder)
 {
-
+  // Sets the folder and the data loaders
  if (folder == 0x0)
   {
     Error("SetFolder","Stupid joke. Argument is NULL");
@@ -490,6 +501,7 @@ Int_t AliDataLoader::GetDebug() const
 
 void AliDataLoader::MakeTree()
 {
+  // Makes tree for the current data loader
   AliTreeLoader* tl = dynamic_cast<AliTreeLoader*>(fBaseLoaders->At(0));
   if (tl == 0x0)
    {
@@ -566,6 +578,7 @@ AliBaseLoader* AliDataLoader::GetBaseLoader(const TString& name) const
 
 AliBaseLoader* AliDataLoader::GetBaseLoader(Int_t n) const
 {
+  // Gets the n-th base loader (what is n?)
  return dynamic_cast<AliBaseLoader*>(fBaseLoaders->At(n));
 }
 /*****************************************************************************/ 
@@ -584,6 +597,7 @@ TTree* AliDataLoader::Tree() const
 
 void  AliDataLoader::SetDirName(TString& dirname)
 {
+  // Sets the directory name where the files will be stored
   if (GetDebug()>9) Info("SetDirName","FileName before %s",fFileName.Data());
 
   Int_t n = fFileName.Last('/');
@@ -601,16 +615,19 @@ void  AliDataLoader::SetDirName(TString& dirname)
 /*****************************************************************************/ 
 AliObjectLoader* AliDataLoader::GetBaseDataLoader()
 {
+  // Gets the base data loader
  return dynamic_cast<AliObjectLoader*>(GetBaseLoader(kData));
 }
 /*****************************************************************************/ 
 AliTaskLoader* AliDataLoader::GetBaseTaskLoader()
 {
+  // Gets the base task loader
  return dynamic_cast<AliTaskLoader*>(GetBaseLoader(kTask));
 }
 /*****************************************************************************/ 
 AliBaseLoader* AliDataLoader::GetBaseQALoader()
 {
+  // Gets the base QA loader
   return GetBaseLoader(kQA);
 }
 /*****************************************************************************/ 
@@ -691,6 +708,7 @@ AliBaseLoader::AliBaseLoader():
  fDoNotReload(kFALSE),
  fDataLoader(0x0)
 {
+  //default constructor
 }
 /*****************************************************************************/ 
 
@@ -701,12 +719,25 @@ AliBaseLoader::AliBaseLoader(const TString& name,  AliDataLoader* dl, Bool_t sto
  fDoNotReload(storeontop),//if stored on top of file - this object is loaded ones pe
  fDataLoader(dl)
 {
+  //constructor
 }
 
 /*****************************************************************************/ 
+AliBaseLoader::AliBaseLoader(const AliBaseLoader& source):TNamed(source) {
+  // copy constructor
+  Fatal("AliBaseLoader","Copy constructor not implemented");
+}
+/*****************************************************************************/ 
+AliBaseLoader& AliBaseLoader::operator=(const AliBaseLoader& /*source*/) {
+  // Assignment operator
+  Fatal("AliBaseLoader","Assignment operator not implemented");
+  return *this;
+}
+/*****************************************************************************/ 
 
 Int_t AliBaseLoader::Load(Option_t* opt)
 {
+  // Loads and posts the data
   if (GetDebug())
     Info("Load","data type = %s, option = %s",GetName(),opt);
 
@@ -912,6 +943,7 @@ void AliBaseLoader::Clean()
 
 void AliBaseLoader::Unload()
 {
+  // Unloads data and closes the files
   Clean();
   fIsLoaded = kFALSE;
   GetDataLoader()->CloseFile();
@@ -919,6 +951,7 @@ void AliBaseLoader::Unload()
 /*****************************************************************************/ 
 AliDataLoader* AliBaseLoader::GetDataLoader() const
 {
+  // Returns pointer to the data loader
  if (fDataLoader == 0x0) 
   {
     Fatal("GetDataLoader","Pointer to Data Loader is NULL");
@@ -929,10 +962,11 @@ AliDataLoader* AliBaseLoader::GetDataLoader() const
 
 Int_t AliBaseLoader::GetDebug() const 
 { 
- return (Int_t)AliLoader::fgDebug;
+  // Returns debug level
+ return (Int_t)AliLoader::GetDebug();
 }
 
-TDirectory* AliBaseLoader::GetDirectory()
+TDirectory* AliBaseLoader::GetDirectory() const
 {
  // returnd TDirectory where data are to be saved
  //if fStoreInTopOfFile flag is true - returns pointer to file
@@ -960,6 +994,7 @@ AliObjectLoader::AliObjectLoader(const TString& name, AliDataLoader* dl, Bool_t
 
 TFolder* AliObjectLoader::GetFolder() const
 {
+  // Returns pointer to the object folder
   TFolder* df = GetDataLoader()->GetFolder();
   if (df == 0x0)
    {
@@ -968,14 +1003,28 @@ TFolder* AliObjectLoader::GetFolder() const
   return df;
 }
 /*****************************************************************************/ 
+AliObjectLoader::AliObjectLoader(const AliObjectLoader& source):
+  AliBaseLoader(source) {
+  // copy constructor
+  Fatal("AliObjectLoader","Copy constructor not implemented");
+}
+/*****************************************************************************/ 
+AliObjectLoader& AliObjectLoader::operator=(const AliObjectLoader& /*source*/) {
+  // Assignment operator
+  Fatal("AliObjectLoader","Assignment operator not implemented");
+  return *this;
+}
+/*****************************************************************************/ 
 
 void AliObjectLoader::RemoveFromBoard(TObject* obj)
 {
+  // Removes "obj" from the board
   GetFolder()->Remove(obj);
 }
 /*****************************************************************************/ 
 Int_t AliObjectLoader::AddToBoard(TObject* obj)
 {
+  // Adds "obj" to the board
   GetFolder()->Add(obj);
   return 0;
 }
@@ -983,6 +1032,7 @@ Int_t AliObjectLoader::AddToBoard(TObject* obj)
 
 TObject* AliObjectLoader::Get() const
 {
+  // Returns pointer to the object loader
   return (GetFolder()) ? GetFolder()->FindObject(GetName()) : 0x0;
 }
 
@@ -1004,6 +1054,18 @@ AliTreeLoader::AliTreeLoader(const TString& name, AliDataLoader* dl,Bool_t store
 {
 //constructor
 }
+/*****************************************************************************/ 
+AliTreeLoader::AliTreeLoader(const AliTreeLoader& source):
+  AliObjectLoader(source) {
+  // copy constructor
+  Fatal("AliTreeLoader","Copy constructor not implemented");
+}
+/*****************************************************************************/ 
+AliTreeLoader& AliTreeLoader::operator=(const AliTreeLoader& /*source*/) {
+  // Assignment operator
+  Fatal("AliTreeLoader","Assignment operator not implemented");
+  return *this;
+}
 
 /*****************************************************************************/ 
 
@@ -1123,15 +1185,29 @@ AliTaskLoader::AliTaskLoader(const TString& name, AliDataLoader* dl, TTask* pare
 }
 
 /*****************************************************************************/ 
+AliTaskLoader::AliTaskLoader(const AliTaskLoader& source):
+  AliBaseLoader(source) {
+  // copy constructor
+  Fatal("AliTaskLoader","Copy constructor not implemented");
+}
+/*****************************************************************************/ 
+AliTaskLoader& AliTaskLoader::operator=(const AliTaskLoader& /*source*/) {
+  // Assignment operator
+  Fatal("AliTaskLoader","Assignment operator not implemented");
+  return *this;
+}
+/*****************************************************************************/ 
 
 void AliTaskLoader::RemoveFromBoard(TObject* obj)
 {
+  // Removes the task "obj" from the board
   GetParentalTask()->GetListOfTasks()->Remove(obj);
 }
 /*****************************************************************************/ 
 
 Int_t AliTaskLoader::AddToBoard(TObject* obj)
 {
+  // Adds task "obj" to the board
   TTask* task = dynamic_cast<TTask*>(obj);
   if (task == 0x0)
    {
@@ -1145,6 +1221,7 @@ Int_t AliTaskLoader::AddToBoard(TObject* obj)
 
 TObject* AliTaskLoader::Get() const
 {
+  // Returns pointer to the current task
   return (GetParentalTask()) ? GetParentalTask()->GetListOfTasks()->FindObject(GetName()) : 0x0;
 }
 /*****************************************************************************/ 
index 423dc36..25e9401 100644 (file)
@@ -35,6 +35,8 @@ class AliDataLoader: public TNamed
   public:
    AliDataLoader();
    AliDataLoader(const char* filename, const char* contname, const char* name, Option_t* opt = "t");
+   AliDataLoader(const AliDataLoader& source);
+   AliDataLoader& operator=(const AliDataLoader& source);
    virtual ~AliDataLoader();
 
    virtual Int_t      SetEvent();
@@ -119,7 +121,6 @@ class AliDataLoader: public TNamed
    TFolder*     fEventFolder;//!event folder
    TFolder*     fFolder;//! folder with data
    
-  public:
    ClassDef(AliDataLoader,1)
  };
 
@@ -138,6 +139,8 @@ class AliBaseLoader: public TNamed
   public:
     AliBaseLoader();
     AliBaseLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop = kFALSE);
+   AliBaseLoader(const AliBaseLoader& source);
+   AliBaseLoader& operator=(const AliBaseLoader& source);
     
     virtual ~AliBaseLoader(){};
      
@@ -154,8 +157,9 @@ class AliBaseLoader: public TNamed
     void               SetEventFolder(TFolder* /*ef*/){;}
     void               SetDoNotReload(Bool_t flag){fDoNotReload = flag;}
     Bool_t             DoNotReload() const {return fDoNotReload;}
-    TDirectory*        GetDirectory();//returns pointer to directory where data are stored. 
-    TObject*           GetFromDirectory(const char *name){return (GetDirectory())?GetDirectory()->Get(name):0x0;}    
+    TDirectory*        GetDirectory() const;//returns pointer to directory where data are stored. 
+    TObject*           GetFromDirectory(const char *name) const
+      {return (GetDirectory())?GetDirectory()->Get(name):0x0;}    
    protected:
     
     virtual Int_t      AddToBoard(TObject* obj) = 0;//add to white board - board can be TTask or TFolder
@@ -191,6 +195,8 @@ class AliObjectLoader: public AliBaseLoader
    public:
      AliObjectLoader(){};
      AliObjectLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop = kFALSE);
+     AliObjectLoader(const AliObjectLoader& source);
+     AliObjectLoader& operator=(const AliObjectLoader& source);
      virtual          ~AliObjectLoader(){};
      TObject*          Get() const;
 
@@ -216,6 +222,8 @@ class AliTreeLoader: public AliObjectLoader
    public:
      AliTreeLoader(){};
      AliTreeLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop = kFALSE);
+     AliTreeLoader(const AliTreeLoader& source);
+     AliTreeLoader& operator=(const AliTreeLoader& source);
      virtual ~AliTreeLoader(){};
      
      virtual TTree*     Tree() const {return dynamic_cast<TTree*>(Get());}
@@ -238,6 +246,8 @@ class AliTaskLoader: public AliBaseLoader
   public:
     AliTaskLoader():fParentalTask(0x0){};
     AliTaskLoader(const TString& name, AliDataLoader* dl, TTask* parentaltask, Bool_t storeontop = kFALSE);
+    AliTaskLoader(const AliTaskLoader& source);
+    AliTaskLoader& operator=(const AliTaskLoader& source);
     virtual ~AliTaskLoader(){};
     
     TObject*           Get() const; 
@@ -249,7 +259,7 @@ class AliTaskLoader: public AliBaseLoader
     TTask*             GetParentalTask() const;
 
   private:
-    TTask*             fParentalTask;
+    TTask*             fParentalTask; // Parental task
 
   ClassDef(AliTaskLoader,1)    
  };
index 34ed89c..f9b0b87 100644 (file)
@@ -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
@@ -279,6 +297,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 +331,7 @@ TFolder* AliLoader::GetQAFolder()
   
 }
 /*****************************************************************************/ 
-TTask* AliLoader::SDigitizer()
+TTask* AliLoader::SDigitizer() const
 {
 //returns SDigitizer task for this detector
   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Task();
@@ -320,14 +339,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 +354,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 +369,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 +467,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
@@ -486,6 +506,7 @@ void AliLoader::MakeTree(Option_t *option)
 /*****************************************************************************/ 
 Int_t  AliLoader::WriteHits(Option_t* opt)
  {
+   // Writes hits
    AliDataLoader* dl = GetHitsDataLoader();
    Int_t ret = dl->WriteData(opt);
    return ret;
@@ -494,6 +515,7 @@ Int_t  AliLoader::WriteHits(Option_t* opt)
 
 Int_t AliLoader::WriteSDigits(Option_t* opt)
  {
+   // Writes summable digits
    AliDataLoader* dl = GetSDigitsDataLoader();
    Int_t ret = dl->WriteData(opt);
    return ret;
@@ -503,36 +525,42 @@ Int_t AliLoader::WriteSDigits(Option_t* opt)
 
 Int_t AliLoader::PostSDigitizer(TTask* sdzer)
 {
+  // Posts sdigitizer
   return GetSDigitsDataLoader()->GetBaseTaskLoader()->Post(sdzer);
 }
 /*****************************************************************************/ 
 
 Int_t AliLoader::PostDigitizer(AliDigitizer* task)
  {
+   // Posts digitizer
   return GetDigitsDataLoader()->GetBaseTaskLoader()->Post(task);
  }
 /*****************************************************************************/ 
 
 Int_t AliLoader::PostReconstructioner(TTask* task)
  {
+   // Posts Reconstructioner
   return GetRecPointsDataLoader()->GetBaseTaskLoader()->Post(task);
  }
 /*****************************************************************************/ 
 
 Int_t AliLoader::PostTracker(TTask* task)
  {
+   // Posts a tracker
   return GetTracksDataLoader()->GetBaseTaskLoader()->Post(task);
  }
 /*****************************************************************************/ 
 
 Int_t AliLoader::PostPIDTask(TTask* task)
  {
+  // 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 +571,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 +583,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 +595,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 +607,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 +619,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 +727,7 @@ void AliLoader::CleanPIDTask()
 
 Int_t AliLoader::ReloadAll()
 {
+  // Calling Reload function for all the data loaders
  TIter next(fDataLoaders);
  AliDataLoader* dl;
  
@@ -724,6 +758,7 @@ void AliLoader::CloseFiles()
 
 Int_t  AliLoader::SetEventFolder(TFolder* eventfolder)
 {
+  //sets the event folder
  if (eventfolder == 0x0)
   {
     Error("SetEventFolder","Stupid joke. Argument is NULL");
@@ -839,6 +874,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 +890,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;
index ea77545..3c507ea 100644 (file)
@@ -4,7 +4,7 @@
 #include <TFolder.h>
 #include <TObjArray.h>
 
-#include <AliConfig.h>
+//#include <AliConfig.h>
 #include "AliDataLoader.h"
 
 class TString;
@@ -34,6 +34,8 @@ class AliLoader: public TNamed
     AliLoader();
     AliLoader(const Char_t *detname,const Char_t *eventfoldername); //contructor with name of the top folder of the tree
     AliLoader(const Char_t *detname,TFolder* eventfolder);
+    AliLoader(const AliLoader& source); //copy constructor
+    AliLoader& operator=(const AliLoader& source); //assignment operator
 
     virtual ~AliLoader();//----------------- 
  
@@ -72,12 +74,12 @@ class AliLoader: public TNamed
     TFolder*       GetTasksFolder();
     TFolder*       GetQAFolder();
    
-    TTask*         SDigitizer();//return detector SDigitizer()
-    AliDigitizer*  Digitizer();
-    TTask*         Reconstructioner();
-    TTask*         Tracker();
-    TTask*         PIDTask();
-    TTask*         QAtask(const char* name = 0x0);
+    TTask*         SDigitizer() const;//return detector SDigitizer()
+    AliDigitizer*  Digitizer() const;
+    TTask*         Reconstructioner() const;
+    TTask*         Tracker() const;
+    TTask*         PIDTask() const;
+    TTask*         QAtask(const char* name = 0x0) const;
 
     TObject**      SDigitizerRef();
     TObject**      DigitizerRef();
@@ -107,12 +109,18 @@ class AliLoader: public TNamed
     virtual Int_t  WriteTracker(Option_t* opt=""){return GetTracksDataLoader()->GetBaseTaskLoader()->WriteData(opt);}
     virtual Int_t  WritePIDTask(Option_t* opt=""){return GetRecParticlesDataLoader()->GetBaseTaskLoader()->WriteData(opt);}
 
-    TTree*         TreeH(){return GetHitsDataLoader()->Tree();}      //returns the tree from folder; shortcut method
-    TTree*         TreeS(){return GetSDigitsDataLoader()->Tree();}   //returns the tree from folder; shortcut method
-    TTree*         TreeD(){return GetDigitsDataLoader()->Tree();}    //returns the tree from folder; shortcut method
-    TTree*         TreeR(){return GetRecPointsDataLoader()->Tree();} //returns the tree from folder; shortcut method
-    TTree*         TreeT(){return GetTracksDataLoader()->Tree();}    //returns the tree from folder; shortcut method
-    TTree*         TreeP(){return GetRecParticlesDataLoader()->Tree();} //returns the tree from folder; shortcut method
+    TTree*         TreeH() const
+      {return GetHitsDataLoader()->Tree();}      //returns the tree from folder; shortcut method
+    TTree*         TreeS() const
+      {return GetSDigitsDataLoader()->Tree();}   //returns the tree from folder; shortcut method
+    TTree*         TreeD() const
+      {return GetDigitsDataLoader()->Tree();}    //returns the tree from folder; shortcut method
+    TTree*         TreeR() const
+      {return GetRecPointsDataLoader()->Tree();} //returns the tree from folder; shortcut method
+    TTree*         TreeT() const
+      {return GetTracksDataLoader()->Tree();}    //returns the tree from folder; shortcut method
+    TTree*         TreeP() const
+      {return GetRecParticlesDataLoader()->Tree();} //returns the tree from folder; shortcut method
 
     Int_t          LoadHits(Option_t* opt=""){Int_t status = GetHitsDataLoader()->Load(opt);SetTAddrInDet();return status;}
     Int_t          LoadSDigits(Option_t* opt=""){Int_t status = GetSDigitsDataLoader()->Load(opt);SetTAddrInDet(); return status;}
@@ -161,12 +169,18 @@ class AliLoader: public TNamed
     void           SetTracksFileName(const TString& fname){GetTracksDataLoader()->SetFileName(fname);}
     void           SetRecParticlesFileName(const TString& fname){GetRecParticlesDataLoader()->SetFileName(fname);}
 
-    const TString& GetHitsFileName(){return GetHitsDataLoader()->GetFileName();}
-    const TString& GetSDigitsFileName(){return GetSDigitsDataLoader()->GetFileName();}
-    const TString& GetDigitsFileName(){return GetDigitsDataLoader()->GetFileName();}
-    const TString& GetRecPointsFileName(){return GetRecPointsDataLoader()->GetFileName();}
-    const TString& GetTracksFileName(){return GetTracksDataLoader()->GetFileName();}
-    const TString& GetRecParticlesFileName(){return GetRecParticlesDataLoader()->GetFileName();}
+    const TString& GetHitsFileName() const 
+      {return GetHitsDataLoader()->GetFileName();}
+    const TString& GetSDigitsFileName() const 
+      {return GetSDigitsDataLoader()->GetFileName();}
+    const TString& GetDigitsFileName() const
+      {return GetDigitsDataLoader()->GetFileName();}
+    const TString& GetRecPointsFileName() const
+      {return GetRecPointsDataLoader()->GetFileName();}
+    const TString& GetTracksFileName() const
+      {return GetTracksDataLoader()->GetFileName();}
+    const TString& GetRecParticlesFileName() const
+      {return GetRecParticlesDataLoader()->GetFileName();}
    
     virtual void  CleanHits()     {GetHitsDataLoader()->Clean();}       //cleans hits from folder
     virtual void  CleanSDigits()  {GetSDigitsDataLoader()->Clean();}    //cleans digits from folder
@@ -204,6 +218,20 @@ class AliLoader: public TNamed
                                                           //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
                                                               //made on Jiri Chudoba demand
     void Synchronize();
+
+    /**********************************************/
+    /***********     P U B L I C     **************/
+    /*********       S T A T I C       ************/
+    /*********         METHODS         ************/
+    /*********     They are used by    ************/
+    /*********** AliRunLoader as well**************/
+    /**********************************************/
+    static TDirectory* ChangeDir(TFile* file, Int_t eventno); //changes the root directory in "file" to directory corresponing to eventno
+    static Bool_t      TestFileOption(Option_t* opt);//checks is file is created from scratch
+    static Bool_t      IsOptionWritable(const TString& opt);
+    
+    static Int_t GetDebug() {return fgDebug;}
+    static void        SetDebug(Int_t deb = 1){fgDebug = deb;}//Sets debugging information
     
    protected:
 
@@ -230,7 +258,7 @@ class AliLoader: public TNamed
     void          Clean(const TString& name);//removes and deletes object from data folder 
     
     
-    TString       GetUnixDir();
+    TString       GetUnixDir() const;
     TObject*      GetDetectorData(const char* name){return GetDetectorDataFolder()->FindObject(name);}
     TObject**     GetDetectorDataRef(TObject* obj);
     
@@ -244,9 +272,8 @@ class AliLoader: public TNamed
     /*********        D A T A          ************/
     /**********************************************/
   
-    // array with data loaders each corresponds to 
-    // one data type (Hits, Digits, ...) 
-    TObjArray*    fDataLoaders; 
+    TObjArray*    fDataLoaders; // array with data loaders each corresponds to 
+                                // one data type (Hits, Digits, ...) 
 
     TString       fDetectorName;//detector name that this loader belongs to
     
@@ -274,20 +301,6 @@ class AliLoader: public TNamed
     //descendant classes should
     //use protected interface methods to access these folders
 
-    /**********************************************/
-    /***********     P U B L I C     **************/
-    /*********       S T A T I C       ************/
-    /*********         METHODS         ************/
-    /*********     They are used by    ************/
-    /*********** AliRunLoader as well**************/
-    /**********************************************/
-   public:
-    static TDirectory* ChangeDir(TFile* file, Int_t eventno); //changes the root directory in "file" to directory corresponing to eventno
-    static Bool_t      TestFileOption(Option_t* opt);//checks is file is created from scratch
-    static Bool_t      IsOptionWritable(const TString& opt);
-    
-    static Int_t GetDebug() {return fgDebug;}
-    static void        SetDebug(Int_t deb = 1){fgDebug = deb;}//Sets debugging information
     static Int_t       fgDebug; //debug flag for loaders
 
     ClassDef(AliLoader,2)
index 13380f3..3cb495c 100644 (file)
 
 /* $Id$ */
 
+// This class is extracted from the AliRun class
+// and contains all the MC-related functionality
+// The number of dependencies has to be reduced...
+// Author: F.Carminati
+//         Federico.Carminati@cern.ch
+
 #include <TBrowser.h>
 #include <TStopwatch.h>
 #include <TSystem.h>
@@ -48,6 +54,7 @@ AliMC::AliMC() :
   fTrackReferences(0)
 
 {
+  //default constructor
 }
 
 //_______________________________________________________________________
@@ -65,7 +72,7 @@ AliMC::AliMC(const char *name, const char *title) :
   fHitLists(new TList()),
   fTrackReferences(new TClonesArray("AliTrackReference", 100))
 {
-
+  //constructor
   // Set transport parameters
   SetTransPar();
 
@@ -98,6 +105,7 @@ AliMC::AliMC(const AliMC &mc) :
 //_______________________________________________________________________
 AliMC::~AliMC()
 {
+  //destructor
   delete fGenerator;
   delete fImedia;
   delete fMCQA;
@@ -114,6 +122,7 @@ AliMC::~AliMC()
 //_______________________________________________________________________
 void AliMC::Copy(AliMC &) const
 {
+  //dummy Copy function
   Fatal("Copy","Not implemented!\n");
 }
 
@@ -224,6 +233,7 @@ void AliMC::BeginPrimary()
 //_______________________________________________________________________
 void AliMC::PreTrack()
 {
+  // Actions before the track's transport
      TObjArray &dets = *gAlice->Modules();
      AliModule *module;
 
@@ -432,6 +442,7 @@ void AliMC::ResetHits()
 //_______________________________________________________________________
 void AliMC::PostTrack()
 {
+  // Posts tracks for each module
      TObjArray &dets = *gAlice->Modules();
      AliModule *module;
 
@@ -543,12 +554,14 @@ void AliMC::FinishEvent()
 //_______________________________________________________________________
 void AliMC::Field(const Double_t* x, Double_t* b) const
 {
+  // Calculates field "b" at point "x"
     gAlice->Field(x,b);
 }
     
 //_______________________________________________________________________
 void AliMC::Init()
 {
+  // MC initialization
 
    //=================Create Materials and geometry
    gMC->Init();
@@ -847,6 +860,8 @@ Int_t AliMC::GetPrimary(Int_t track) const
 //_______________________________________________________________________
 TParticle* AliMC::Particle(Int_t i) const
 {
+  // Returns the i-th particle from the stack taking into account
+  // the remaping done by PurifyKine
   AliRunLoader * runloader = gAlice->GetRunLoader();
   if (runloader)
    if (runloader->Stack())
index 9281814..5d72961 100644 (file)
@@ -19,8 +19,11 @@ public:
     AliMC(const AliMC &mc);
     virtual ~AliMC();
     
-    AliMC operator = (const AliMC &mc) 
-        {mc.Copy(*this); return *this;}
+    AliMC& operator= (const AliMC &mc) {
+      // Assignment operator
+      mc.Copy(*this);
+      return *this;
+    }
 
 //
 //  MC Application
index 471f77f..09e4671 100644 (file)
@@ -301,7 +301,7 @@ AliRunLoader* AliRunLoader::Open
 //in case of error returns NULL
  
  static const TString webaddress("http://alisoft.cern.ch/people/skowron/codedoc/split/index.html");
- if (AliLoader::fgDebug) 
+ if (AliLoader::GetDebug()) 
   ::Info("AliRunLoader::Open",
          "\n\n\nNew I/O strcture: See more info:\n %s\n\n\n",webaddress.Data());
  
@@ -378,7 +378,7 @@ AliRunLoader* AliRunLoader::Open
  //else create new AliRunLoader
  if ( AliLoader::TestFileOption(option) )
   { 
-    if (AliLoader::fgDebug) 
+    if (AliLoader::GetDebug()) 
      ::Info("AliRunLoader::Open","Reading RL from file");
     
     result = dynamic_cast<AliRunLoader*>(gAliceFile->Get(fgkRunLoaderName));//get the run Loader from the file
@@ -399,7 +399,7 @@ AliRunLoader* AliRunLoader::Open
   }
  else
   {
-    if (AliLoader::fgDebug) 
+    if (AliLoader::GetDebug()) 
       ::Info("AliRunLoader::Open","Creating new AliRunLoader. Folder name is %s",eventfoldername);
     result = new AliRunLoader(eventfoldername);
   }
@@ -416,7 +416,7 @@ AliRunLoader* AliRunLoader::Open
   }
  else dirname = fname.Remove(nsl);//slash found
  
- if (AliLoader::fgDebug) 
+ if (AliLoader::GetDebug()) 
   ::Info("AliRunLoader::Open","Dir name is : %s",dirname.Data());
  
  result->SetDirName(dirname); 
@@ -1033,10 +1033,10 @@ void AliRunLoader::CleanDetectors()
 {
 //Calls CleanFolders for all detectors
   TIter next(fLoaders);
-  AliLoader *Loader;
-  while((Loader = (AliLoader*)next())) 
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
    {
-     Loader->CleanFolders();
+     loader->CleanFolders();
    }
 }
 /**************************************************************************/
@@ -1132,25 +1132,25 @@ Int_t AliRunLoader::LoadDigits(Option_t* detectors,Option_t* opt)
 {
 //LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
 
-  TObjArray* Loaders;
+  TObjArray* loaders;
   TObjArray arr;
 
   const char* oAll = strstr(detectors,"all");
   if (oAll)
    {
-     Loaders = fLoaders;
+     loaders = fLoaders;
    }
   else
    {
      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
-     Loaders = &arr;//get the pointer array
+     loaders = &arr;//get the pointer array
    }   
 
-  TIter next(Loaders);
-  AliLoader *Loader;
-  while((Loader = (AliLoader*)next())) 
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
    {
-    Loader->LoadDigits(opt);
+    loader->LoadDigits(opt);
    }
   return 0;
 } 
@@ -1160,25 +1160,25 @@ Int_t AliRunLoader::LoadRecPoints(Option_t* detectors,Option_t* opt)
 {
 //LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
 
-  TObjArray* Loaders;
+  TObjArray* loaders;
   TObjArray arr;
 
   const char* oAll = strstr(detectors,"all");
   if (oAll)
    {
-     Loaders = fLoaders;
+     loaders = fLoaders;
    }
   else
    {
      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
-     Loaders = &arr;//get the pointer array
+     loaders = &arr;//get the pointer array
    }   
 
-  TIter next(Loaders);
-  AliLoader *Loader;
-  while((Loader = (AliLoader*)next())) 
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
    {
-    Loader->LoadRecPoints(opt);
+    loader->LoadRecPoints(opt);
    }
   return 0;
 } 
@@ -1188,25 +1188,25 @@ Int_t AliRunLoader::LoadRecParticles(Option_t* detectors,Option_t* opt)
 {
 //LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
 
-  TObjArray* Loaders;
+  TObjArray* loaders;
   TObjArray arr;
 
   const char* oAll = strstr(detectors,"all");
   if (oAll)
    {
-     Loaders = fLoaders;
+     loaders = fLoaders;
    }
   else
    {
      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
-     Loaders = &arr;//get the pointer array
+     loaders = &arr;//get the pointer array
    }   
 
-  TIter next(Loaders);
-  AliLoader *Loader;
-  while((Loader = (AliLoader*)next())) 
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
    {
-    Loader->LoadRecParticles(opt);
+    loader->LoadRecParticles(opt);
    }
   return 0;
 } 
@@ -1216,25 +1216,25 @@ Int_t AliRunLoader::LoadTracks(Option_t* detectors,Option_t* opt)
 {
 //LoadHits in selected detectors i.e. detectors="ITS TPC TRD" or "all"
 
-  TObjArray* Loaders;
+  TObjArray* loaders;
   TObjArray arr;
 
   const char* oAll = strstr(detectors,"all");
   if (oAll)
    {
-     Loaders = fLoaders;
+     loaders = fLoaders;
    }
   else
    {
      GetListOfDetectors(detectors,arr);//this method looks for all Loaders corresponding to names (many) specified in detectors option
-     Loaders = &arr;//get the pointer array
+     loaders = &arr;//get the pointer array
    }   
 
-  TIter next(Loaders);
-  AliLoader *Loader;
-  while((Loader = (AliLoader*)next())) 
+  TIter next(loaders);
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
    {
-    Loader->LoadTracks(opt);
+    loader->LoadTracks(opt);
    }
   return 0;
 } 
@@ -1853,10 +1853,10 @@ void AliRunLoader::SetDigitsFileNameSuffix(const TString& suffix)
 //made on Jiri Chudoba demand
 
   TIter next(fLoaders);
-  AliLoader *Loader;
-  while((Loader = (AliLoader*)next())) 
+  AliLoader *loader;
+  while((loader = (AliLoader*)next())) 
    {
-     Loader->SetDigitsFileNameSuffix(suffix);
+     loader->SetDigitsFileNameSuffix(suffix);
    }
 }
 /*****************************************************************************/ 
index cea79aa..af3f804 100644 (file)
@@ -160,7 +160,36 @@ class AliRunLoader: public TNamed
     TTree*        GetTreeR(const char* detname, Bool_t maketree);
     TTree*        GetTreeT(const char* detname, Bool_t maketree);
     TTree*        GetTreeP(const char* detname, Bool_t maketree);
-    
+
+  /******************************************/
+  /*****   Public S T A T I C Stuff   *******/
+  /******************************************/
+    static AliRunLoader* GetRunLoader(const char* eventfoldername);
+    static AliRunLoader* GetRunLoader(){return fgRunLoader;}
+    static AliLoader*    GetDetectorLoader(const char* detname, const char* eventfoldername);
+    static TTree*        GetTreeH(const char* detname, Bool_t maketree, const char* eventfoldername);
+    static TTree*        GetTreeS(const char* detname, Bool_t maketree, const char* eventfoldername);
+    static TTree*        GetTreeD(const char* detname, Bool_t maketree, const char* eventfoldername);
+    static TTree*        GetTreeR(const char* detname, Bool_t maketree, const char* eventfoldername);
+    static TTree*        GetTreeT(const char* detname, Bool_t maketree, const char* eventfoldername);
+    static TTree*        GetTreeP(const char* detname, Bool_t maketree, const char* eventfoldername);
+
+//    static AliRunDigitizer* GetRunDigitizer();
+//  Tasks are supposed to be singletons, that is why following methods are static
+    static TTask*           GetRunDigitizer();        //
+    static TTask*           GetRunSDigitizer();       //
+    static TTask*           GetRunReconstructioner(); //
+    static TTask*           GetRunTracker();          //
+    static TTask*           GetRunPIDTask();          // 
+    static TTask*           GetRunQATask();           //
+     
+    static const TString   fgkRunLoaderName;          //default name of the run loader
+    static const TString   fgkHeaderContainerName;    //default name of the kinematics container (TREE) name - TreeE
+    static const TString   fgkKineContainerName;      //default name of the kinematics container (TREE) name - TreeK
+    static const TString   fgkTrackRefsContainerName; //default name of the track references container (TREE) name - TreeTR
+    static const TString   fgkHeaderBranchName;       //default name of the branch containing the header
+    static const TString   fgkKineBranchName;         //default name of the branch with kinematics
+    static const TString   fgkGAliceName;             //default name for gAlice file    
   protected:
     /**********************************************/
     /************    PROTECTED      ***************/
@@ -207,38 +236,8 @@ class AliRunLoader: public TNamed
     
     Int_t SetEvent();
    
-    static AliRunLoader* fgRunLoader;
+    static AliRunLoader* fgRunLoader; //pointer to the AliRunLoader instance
 
-  public:
-  /******************************************/
-  /*****   Public S T A T I C Stuff   *******/
-  /******************************************/
-    static AliRunLoader* GetRunLoader(const char* eventfoldername);
-    static AliRunLoader* GetRunLoader(){return fgRunLoader;}
-    static AliLoader*    GetDetectorLoader(const char* detname, const char* eventfoldername);
-    static TTree*        GetTreeH(const char* detname, Bool_t maketree, const char* eventfoldername);
-    static TTree*        GetTreeS(const char* detname, Bool_t maketree, const char* eventfoldername);
-    static TTree*        GetTreeD(const char* detname, Bool_t maketree, const char* eventfoldername);
-    static TTree*        GetTreeR(const char* detname, Bool_t maketree, const char* eventfoldername);
-    static TTree*        GetTreeT(const char* detname, Bool_t maketree, const char* eventfoldername);
-    static TTree*        GetTreeP(const char* detname, Bool_t maketree, const char* eventfoldername);
-
-//    static AliRunDigitizer* GetRunDigitizer();
-//  Tasks are supposed to be singletons, that is why following methods are static
-    static TTask*           GetRunDigitizer();        //
-    static TTask*           GetRunSDigitizer();       //
-    static TTask*           GetRunReconstructioner(); //
-    static TTask*           GetRunTracker();          //
-    static TTask*           GetRunPIDTask();          // 
-    static TTask*           GetRunQATask();           //
-     
-    static const TString   fgkRunLoaderName;
-    static const TString   fgkHeaderContainerName;    //default name of the kinematics container (TREE) name - TreeE
-    static const TString   fgkKineContainerName;      //default name of the kinematics container (TREE) name - TreeK
-    static const TString   fgkTrackRefsContainerName; //default name of the track references container (TREE) name - TreeTR
-    static const TString   fgkHeaderBranchName;
-    static const TString   fgkKineBranchName;
-    static const TString   fgkGAliceName;
     
     ClassDef(AliRunLoader,1)
 };
index 83bd754..57c7f1e 100644 (file)
@@ -805,7 +805,7 @@ TTree* AliStack::TreeK()
     else
      {
       //don't panic - could be Lego
-      if (AliLoader::fgDebug) 
+      if (AliLoader::GetDebug()) 
        { 
          Warning("TreeK","Can not get TreeK from RL. Ev. Folder is %s",fEventFolderName.Data());
        } 
@@ -820,7 +820,7 @@ void AliStack::ConnectTree()
 //
 //  Creates branch for writing particles
 //
-  if (AliLoader::fgDebug) Info("ConnectTree","Connecting TreeK");
+  if (AliLoader::GetDebug()) Info("ConnectTree","Connecting TreeK");
   if (fTreeK == 0x0)
    {
     if (TreeK() == 0x0)
@@ -835,12 +835,12 @@ void AliStack::ConnectTree()
 
  //  Create a branch for particles   
   
-  if (AliLoader::fgDebug) 
+  if (AliLoader::GetDebug()) 
    Info("ConnectTree","Tree name is %s",fTreeK->GetName());
    
   if (fTreeK->GetDirectory())
    {
-     if (AliLoader::fgDebug)    
+     if (AliLoader::GetDebug())    
       Info("ConnectTree","and dir is %s",fTreeK->GetDirectory()->GetName());
    }    
   else
@@ -850,16 +850,16 @@ void AliStack::ConnectTree()
   if(branch == 0x0)
    {
     branch = fTreeK->Branch(AliRunLoader::fgkKineBranchName, "TParticle", &fParticleBuffer, 4000);
-    if (AliLoader::fgDebug) Info("ConnectTree","Creating Branch in Tree");
+    if (AliLoader::GetDebug()) Info("ConnectTree","Creating Branch in Tree");
    }  
   else
    {
-    if (AliLoader::fgDebug) Info("ConnectTree","Branch Found in Tree");
+    if (AliLoader::GetDebug()) Info("ConnectTree","Branch Found in Tree");
     branch->SetAddress(&fParticleBuffer);
    }
   if (branch->GetDirectory())
    {
-    if (AliLoader::fgDebug) 
+    if (AliLoader::GetDebug()) 
       Info("ConnectTree","Branch Dir Name is %s",branch->GetDirectory()->GetName());
    } 
   else