Coding Convention
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 13 Nov 2003 12:19:25 +0000 (12:19 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 13 Nov 2003 12:19:25 +0000 (12:19 +0000)
33 files changed:
EMCAL/AliEMCAL.cxx
EMCAL/AliEMCAL.h
EMCAL/AliEMCALClusterizer.cxx
EMCAL/AliEMCALClusterizer.h
EMCAL/AliEMCALFast.cxx
EMCAL/AliEMCALFastRecParticle.h
EMCAL/AliEMCALGeometry.cxx
EMCAL/AliEMCALGeometry.h
EMCAL/AliEMCALGetter.cxx
EMCAL/AliEMCALGetter.h
EMCAL/AliEMCALHit.cxx
EMCAL/AliEMCALHit.h
EMCAL/AliEMCALLoader.cxx
EMCAL/AliEMCALLoader.h
EMCAL/AliEMCALPID.cxx
EMCAL/AliEMCALPID.h
EMCAL/AliEMCALPIDv1.cxx
EMCAL/AliEMCALPIDv1.h
EMCAL/AliEMCALRecParticle.cxx
EMCAL/AliEMCALRecParticle.h
EMCAL/AliEMCALRecPoint.cxx
EMCAL/AliEMCALRecPoint.h
EMCAL/AliEMCALSDigitizer.cxx
EMCAL/AliEMCALSDigitizer.h
EMCAL/AliEMCALTick.cxx
EMCAL/AliEMCALTick.h
EMCAL/AliEMCALTowerRecPoint.cxx
EMCAL/AliEMCALTowerRecPoint.h
EMCAL/AliEMCALTrackSegment.h
EMCAL/AliEMCALTrackSegmentMaker.cxx
EMCAL/AliEMCALTrackSegmentMakerv1.cxx
EMCAL/AliEMCALv0.cxx
EMCAL/AliEMCALv1.cxx

index 12051e0..953f398 100644 (file)
 // --- ROOT system ---
 class TFile;
 #include <TFolder.h> 
-#include <TROOT.h>
 #include <TTree.h>
 #include <TVirtualMC.h> 
 
 // --- Standard library ---
-#include <Rstrstream.h>
 
 // --- AliRoot header files ---
 #include "AliMagF.h"
 #include "AliEMCAL.h"
 #include "AliEMCALGeometry.h"
 #include "AliEMCALLoader.h"
-//#include "AliEMCALQAChecker.h" 
-#include "AliRun.h"
 
 ClassImp(AliEMCAL)
 //____________________________________________________________________________
@@ -183,7 +179,7 @@ AliEMCALGeometry * AliEMCAL::GetGeometry() const
 //____________________________________________________________________________
 void AliEMCAL::SetTreeAddress()
 { 
-
+  // Linking Hits in Tree to Hits array
   TBranch *branch;
   char branchname[20];
   sprintf(branchname,"%s",GetName());
@@ -194,7 +190,8 @@ void AliEMCAL::SetTreeAddress()
     branch = treeH->GetBranch(branchname);
     if (branch) 
       { 
-       if (fHits == 0x0) fHits= new TClonesArray("AliEMCALHit",1000);
+       if (fHits == 0x0) 
+         fHits= new TClonesArray("AliEMCALHit",1000);
        //Info("SetTreeAddress","<%s> Setting Hits Address",GetName());
        branch->SetAddress(&fHits);
       }
index 457b17f..ea1c34e 100644 (file)
@@ -10,8 +10,6 @@
 //                  
 //*-- Author: Yves Schutz (SUBATECH)
 
-#include <stdlib.h>
-
 // --- ROOT system ---
 
 class TString ;
@@ -21,10 +19,7 @@ class TFolder ;
 // --- AliRoot header files ---
 
 #include "AliDetector.h"
-//class AliDetector;
 class AliEMCALGeometry ; 
-//class AliEMCALQAChecker ;
-
 class AliEMCAL : public AliDetector {
 
  public:
@@ -38,10 +33,7 @@ class AliEMCAL : public AliDetector {
   }
   virtual ~AliEMCAL() ; 
   virtual void   AddHit(Int_t, Int_t*, Float_t *) {
-    // do not use this definition but the one below
-    Fatal("AddHit(Int_t, Int_t*, Float_t *", 
-         "not to be used: use AddHit( Int_t shunt, Int_t primary, Int_t track,Int_t id, Float_t *hits )") ;  
-
+    Fatal("AddHit(Int_t, Int_t*, Float_t *", "not to be used: use AddHit( Int_t shunt, Int_t primary, Int_t track,Int_t id, Float_t *hits )") ;  
   }
   virtual void  CreateMaterials() ;   
   virtual void  FinishRun() {WriteQA();}                  
@@ -53,11 +45,7 @@ class AliEMCAL : public AliDetector {
   virtual const TString Version() const {return TString(" ") ; }  
   virtual void WriteQA() ; 
   AliEMCAL & operator = (const AliEMCAL & /*rvalue*/)  {
-    // assignement operator requested by coding convention
-    // but not needed
-    Fatal("operator =", "not implemented") ;  
-    return *this ; 
-  }
+    Fatal("operator =", "not implemented") ;  return *this ; }
  
   virtual AliLoader* MakeLoader(const char* topfoldername);
   
index 50010de..332f9b8 100644 (file)
 //////////////////////////////////////////////////////////////////////////////
 
 // --- ROOT system ---
-#include "TGeometry.h"
-#include "TDirectory.h"
-#include "TFile.h"
-#include "TTree.h" 
 
 // --- Standard library ---
-#include <Riostream.h>
-#include <stdlib.h>   
+
 
 // --- AliRoot header files ---
 #include "AliRun.h" 
 #include "AliEMCALClusterizer.h"
-#include "AliHeader.h" 
-#include "AliEMCALGetter.h"
-#include "AliEMCALSDigitizer.h"
-#include "AliEMCALDigitizer.h"
 
 ClassImp(AliEMCALClusterizer)
 
index 4d4e707..a547ffa 100644 (file)
@@ -18,7 +18,6 @@
 // --- Standard library ---
 
 // --- AliRoot header files ---
-#include "AliConfig.h"
 
 class AliEMCALClusterizer : public TTask {
 
index ac9f4f2..b67fb16 100644 (file)
 
 //*-- Author: Andreas Morsch (CERN)
 
-#include "AliEMCALFast.h"
+#include "TMath.h"
 #include <TRandom.h>
 
+#include "AliEMCALFast.h"
+
 
 ClassImp(AliEMCALFast)
 
index 5dba3e8..99f04f8 100644 (file)
@@ -14,7 +14,6 @@
 // --- ROOT system ---
 
 #include "TParticle.h"
-#include "TVector3.h"
 
 // --- Standard library ---
 
index a36fb8d..bb1a8a1 100644 (file)
 // --- ROOT system ---
 
 // --- Standard library ---
-#include <stdlib.h> 
+//#include <stdlib.h> 
 
 // --- AliRoot header files ---
-#include <TError.h>
+//#include <TError.h>
 #include <TMath.h>
 #include <TVector3.h>
 
 // -- ALICE Headers.
-#include "AliConst.h"
+//#include "AliConst.h"
 
 // --- EMCAL headers
 #include "AliEMCALGeometry.h"
index 6cfdc77..93ab407 100644 (file)
 //*-- Author: Sahal Yacoob (LBL / UCT)
 //*--   and : Yves Schutz (Subatech)
 
-#include <assert.h> 
+  //#include <assert.h> 
 
 // --- ROOT system ---
-  class TString ;
+class TString ;
 class TObjArray ;
 class TVector3 ;
 class TParticle ; 
@@ -32,7 +32,7 @@ public:
   };
   AliEMCALGeometry(const AliEMCALGeometry& geom):AliGeometry(geom) {
     // cpy ctor requested by Coding Convention but not yet needed
-    assert(0==1);
+    Fatal("Cpy ctor", "Not implemented");
   };
   virtual ~AliEMCALGeometry(void) ; 
   static AliEMCALGeometry * GetInstance(const Text_t* name,
index 7ab61d2..7613c40 100644 (file)
@@ -54,6 +54,7 @@
 // #include "AliRun.h"
 // #include "AliConfig.h"
 #include "AliEMCALGetter.h"
+#include "AliEMCAL.h"
 #include "AliRunLoader.h"
 #include "AliStack.h"  
 #include "AliEMCALLoader.h"
index 6efde57..ce88c10 100644 (file)
@@ -38,7 +38,7 @@ class AliEMCAL ;
 // #include "AliEMCALRecPoint.h"
 // #include "AliEMCALRecPoint.h"
 // #include "AliEMCALTrackSegment.h"
-// #include "AliEMCALRecParticle.h"
+#include "AliEMCALRecParticle.h"
 class AliEMCALGeometry ;
 #include "AliEMCALDigitizer.h"
 #include "AliEMCALSDigitizer.h" 
index dec3473..e301124 100644 (file)
 // Based on AliPHOSHit
 
 // --- Standard library ---
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <Rstrstream.h>
 #include <Riostream.h>
 
 // --- ROOT system ---
-#include <TLorentzVector.h>
 
 // --- AliRoot header files ---
 #include "AliEMCALHit.h"
-#include "AliRun.h"
-#include "AliConst.h"
-#include "AliEMCALGeometry.h"
-#include "AliEMCALGetter.h"
 
 ClassImp(AliEMCALHit)
 
@@ -53,10 +44,10 @@ AliEMCALHit::AliEMCALHit(){
     fX       = 0.0;
     fY       = 0.0;
     fZ       = 0.0;
-    fPx       = 0.0;
-    fPy       = 0.0;
-    fPz       = 0.0;
-    fPe       = 0.0;
+    fPx      = 0.0;
+    fPy      = 0.0;
+    fPz      = 0.0;
+    fPe      = 0.0;
     fIparent = 0;
     fIenergy = 0.0;
 }
index ffa2aa9..f6ab2dd 100644 (file)
 //               
 //*-- Author: Sahal Yacoob (LBL /UCT) 
 // Based on AliPHOSHit
-#include <TLorentzVector.h>
+
 // --- AliRoot header files ---
 #include "AliHit.h"
 
-//class ostream;
 
 class AliEMCALHit : public AliHit {
     
index c4fdcae..9842520 100644 (file)
 
 // --- ROOT system ---
 
-#include "TFile.h"
 #include "TTree.h"
-#include "TROOT.h"
-#include "TObjString.h"
-#include "TFolder.h"
-#include "TParticle.h"
 
 // --- Standard library ---
-#include <Riostream.h>
 
 // --- AliRoot header files ---
 
-#include "AliRun.h"
-#include "AliConfig.h"
-#include "AliDataLoader.h"
 #include "AliEMCALLoader.h"
 #include "AliEMCAL.h"
-#include "AliEMCALDigitizer.h"
-#include "AliEMCALSDigitizer.h"
-#include "AliEMCALClusterizer.h"
-#include "AliEMCALClusterizerv1.h"
-#include "AliEMCALTrackSegmentMaker.h"
-#include "AliEMCALTrackSegmentMakerv1.h"
-#include "AliEMCALTrackSegment.h"
-#include "AliEMCALPID.h" 
-#include "AliEMCALPIDv1.h" 
-#include "AliEMCALGeometry.h"
-//#include "AliEMCALCalibrationDB.h"
+#include "AliEMCALHit.h"
 
 ClassImp(AliEMCALLoader)
-
-
+  
+  
 const TString AliEMCALLoader::fgkHitsName("HITS");//Name for TClonesArray with hits from one event
 const TString AliEMCALLoader::fgkSDigitsName("SDIGITS");//Name for TClonesArray 
 const TString AliEMCALLoader::fgkDigitsName("DIGITS");//Name for TClonesArray 
@@ -86,21 +67,23 @@ const TString AliEMCALLoader::fgkECARecPointsBranchName("EMCALECARP");//Name for
 const TString AliEMCALLoader::fgkHCARecPointsBranchName("EMCALHCARP");//Name for branch with HCA Reconstructed Points
 const TString AliEMCALLoader::fgkTrackSegmentsBranchName("EMCALTS");//Name for branch with TrackSegments
 const TString AliEMCALLoader::fgkRecParticlesBranchName("EMCALRP");//Name for branch with Reconstructed Particles
+
 //____________________________________________________________________________ 
 AliEMCALLoader::AliEMCALLoader()
- {
+{
   fDebug = 0;
   fRecParticlesLoaded = kFALSE;
- }
+}
+
 //____________________________________________________________________________ 
 AliEMCALLoader::AliEMCALLoader(const Char_t *detname,const Char_t *eventfoldername):
-      AliLoader(detname,eventfoldername)
+  AliLoader(detname,eventfoldername)
 {
   fDebug=0;
   fRecParticlesLoaded = kFALSE;
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 AliEMCALLoader::~AliEMCALLoader()
 {
   //remove and delete arrays
@@ -113,22 +96,22 @@ AliEMCALLoader::~AliEMCALLoader()
   Clean(fgkTracksName);
   Clean(fgkRecParticlesName);
 }
-//____________________________________________________________________________ 
 
-void AliEMCALLoader::CleanFolders()
- {
-   CleanRecParticles();
-   AliLoader::CleanFolders();
- }
 //____________________________________________________________________________ 
+void AliEMCALLoader::CleanFolders()
+{
+  CleanRecParticles();
+  AliLoader::CleanFolders();
+}
 
+//____________________________________________________________________________ 
 Int_t AliEMCALLoader::SetEvent()
 {
-//Cleans loaded stuff and and sets Files and Directories
-// do not post any data to folder/tasks
-
+  //Cleans loaded stuff and and sets Files and Directories
+  // do not post any data to folder/tasks
 
- Int_t retval = AliLoader::SetEvent();
+  
+  Int_t retval = AliLoader::SetEvent();
   if (retval)
    {
      Error("SetEvent","AliLoader::SetEvent returned error");
@@ -147,22 +130,22 @@ Int_t AliEMCALLoader::SetEvent()
    
   return 0;
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 Int_t AliEMCALLoader::GetEvent()
 {
-//Overloads GetEvent method called by AliRunLoader::GetEvent(Int_t) method
-//to add Rec Particles specific for EMCAL
-
-//First call the original method to get whatever from std. setup is needed
+  //Overloads GetEvent method called by AliRunLoader::GetEvent(Int_t) method
+  //to add Rec Particles specific for EMCAL
+  
+  //First call the original method to get whatever from std. setup is needed
   Int_t retval;
   
   retval = AliLoader::GetEvent();
   if (retval)
-   {
-     Error("GetEvent","AliLoader::GetEvent returned error");
-     return retval;
-   }
+    {
+      Error("GetEvent","AliLoader::GetEvent returned error");
+      return retval;
+    }
   
   if (GetHitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadHits();
   if (GetSDigitsDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadSDigits();
@@ -172,11 +155,9 @@ Int_t AliEMCALLoader::GetEvent()
   if (GetRecParticlesDataLoader()->GetBaseDataLoader()->IsLoaded()) ReadRecParticles();
 
 
-//Now, check if RecPart were loaded  
+  //Now, check if RecPart were loaded  
   return 0;
 }
-//____________________________________________________________________________ 
-
 
 //____________________________________________________________________________ 
 const AliEMCAL * AliEMCALLoader::EMCAL() 
@@ -192,19 +173,19 @@ const AliEMCAL * AliEMCALLoader::EMCAL()
 //____________________________________________________________________________ 
 const AliEMCALGeometry * AliEMCALLoader::EMCALGeometry() 
 {
+  // Gets the EMCAL Geometry object 
   AliEMCALGeometry * rv = 0 ; 
   if (EMCAL() )
     rv =  EMCAL()->GetGeometry();
   return rv ; 
 } 
 
-
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::LoadHits(Option_t* opt)
 {  
-//------- Hits ----------------------
-//Overload (extends) LoadHits implemented in AliLoader
-//
+  //------- Hits ----------------------
+  //Overload (extends) LoadHits implemented in AliLoader
+  //
   Int_t res;
   
   //First call the AliLoader's method to send the TreeH to folder
@@ -221,124 +202,131 @@ Int_t AliEMCALLoader::LoadHits(Option_t* opt)
   return 0;
 }
 
-
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::LoadSDigits(Option_t* opt)
-{  //---------- SDigits -------------------------
+{  
+  // Loads the SDigits array in the folder structure
   Int_t res;
   //First call the AliLoader's method to send the TreeS to folder
   res = AliLoader::LoadSDigits(opt);
   if (res)
-   {//oops, error
-     Error("PostSDigits","AliLoader::LoadSDigits returned error");
-     return res;
-   }
+    {//oops, error
+      Error("PostSDigits","AliLoader::LoadSDigits returned error");
+      return res;
+    }
   return ReadSDigits();
-   
+  
 } 
+
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::LoadDigits(Option_t* opt)
 { 
+  // Loads the Digits array in the folder structure
+  
   Int_t res;
   //First call the AliLoader's method to send the TreeS to folder
   res = AliLoader::LoadDigits(opt);
   if (res)
-   {//oops, error
-     Error("LoadDigits","AliLoader::LoadDigits returned error");
-     return res;
-   }
+    {//oops, error
+      Error("LoadDigits","AliLoader::LoadDigits returned error");
+      return res;
+    }
   return ReadDigits();
 }
+
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::LoadRecPoints(Option_t* opt) 
-{ // -------------- RecPoints -------------------------------------------
+{ 
+  // Loads the RecPoints array in the folder structure
   Int_t res;
   //First call the AliLoader's method to send the TreeR to folder
   res = AliLoader::LoadRecPoints(opt);
   if (res)
-   {//oops, error
-     Error("LoadRecPoints","AliLoader::LoadRecPoints returned error");
-     return res;
-   }
-
+    {//oops, error
+      Error("LoadRecPoints","AliLoader::LoadRecPoints returned error");
+      return res;
+    }
+  
   TFolder * emcalFolder = GetDetectorDataFolder();
   if ( emcalFolder  == 0x0 ) 
-   {
-     Error("LoadRecPoints","Can not get detector data folder");
-     return 1;
-   }
+    {
+      Error("LoadRecPoints","Can not get detector data folder");
+      return 1;
+    }
   return ReadRecPoints();
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 Int_t  AliEMCALLoader::LoadTracks(Option_t* opt)
 {
- //Loads Tracks: Open File, Reads Tree and posts, Read Data and Posts
- if (GetDebug()) Info("LoadTracks","opt = %s",opt);
- if (fTracksLoaded)
-  {
-    Warning("LoadTracks","Tracks are already loaded");
-    return 0;
-  }
- Int_t res;
+  //Loads Tracks: Open File, Reads Tree and posts, Read Data and Posts
+  if (GetDebug()) 
+    Info("LoadTracks","opt = %s",opt);
+  if (fTracksLoaded)
+    {
+      Warning("LoadTracks","Tracks are already loaded");
+      return 0;
+    }
+  Int_t res;
   //First call the AliLoader's method to send the TreeS to folder
- if (GetTracksDataLoader()->GetBaseLoader(0)->IsLoaded() == kFALSE) 
-  {//tracks can be loaded by LoadRecPoints
-   res = AliLoader::LoadTracks(opt);
-   if (res)
-    {//oops, error
-      Error("LoadTracks","AliLoader::LoadTracks returned error");
+  if (GetTracksDataLoader()->GetBaseLoader(0)->IsLoaded() == kFALSE) 
+    {//tracks can be loaded by LoadRecPoints
+      res = AliLoader::LoadTracks(opt);
+      if (res)
+       {//oops, error
+         Error("LoadTracks","AliLoader::LoadTracks returned error");
+         return res;
+       }
+    }
+  res = ReadTracks();
+  if (res)
+    {
+      Error("LoadTracks","Error occured while reading Tracks");
       return res;
     }
-  }
- res = ReadTracks();
- if (res)
-  {
-    Error("LoadTracks","Error occured while reading Tracks");
-    return res;
-  }
-
- fTracksLoaded = kTRUE;
- return 0;
+  
+  fTracksLoaded = kTRUE;
+  return 0;
 }
 
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::LoadRecParticles(Option_t* opt) 
-{ // -------------- RecPoints -------------------------------------------
+{ 
+  // Loads the RecParticles array in the folder structure
   Int_t res;
   //First call the AliLoader's method to send the TreeS to folder
   res = AliLoader::LoadRecParticles(opt);
   if (res)
-   {//oops, error
-     Error("LoadRecParticles","AliLoader::LoadRecParticles returned error");
-     return res;
-   }
-
+    {//oops, error
+      Error("LoadRecParticles","AliLoader::LoadRecParticles returned error");
+      return res;
+    }
+  
   TFolder * emcalFolder = GetDetectorDataFolder();
   if ( emcalFolder  == 0x0 ) 
-   {
-     Error("PostDigits","Can not get detector data folder");
-     return 1;
-   }
+    {
+      Error("PostDigits","Can not get detector data folder");
+      return 1;
+    }
   return ReadRecParticles();
 }
 
 //____________________________________________________________________________ 
-
 Int_t AliEMCALLoader::PostHits()
 {
   Int_t reval = AliLoader::PostHits();
   if (reval)
-   {
+    {
      Error("PostHits","AliLoader::  returned error");
      return reval;
-   }
+    }
   return ReadHits();
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 Int_t AliEMCALLoader::PostSDigits()
 {
+  // Posts the SDigits array to the folder structure
   Int_t reval = AliLoader::PostSDigits();
   if (reval)
    {
@@ -347,22 +335,24 @@ Int_t AliEMCALLoader::PostSDigits()
    }
   return ReadSDigits();
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 Int_t AliEMCALLoader::PostDigits()
 {
+  // Posts the Digits array to the folder structure
   Int_t reval = AliLoader::PostDigits();
   if (reval)
-   {
-     Error("PostDigits","AliLoader::PostDigits  returned error");
-     return reval;
-   }
+    {
+      Error("PostDigits","AliLoader::PostDigits  returned error");
+      return reval;
+    }
   return ReadDigits();
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 Int_t AliEMCALLoader::PostRecPoints()
 {
+  // Posts the RecPoints array to the folder structure
   Int_t reval = AliLoader::PostRecPoints();
   if (reval)
    {
@@ -373,126 +363,127 @@ Int_t AliEMCALLoader::PostRecPoints()
 }
 
 //____________________________________________________________________________ 
-
 Int_t AliEMCALLoader::PostRecParticles()
 {
+  // Posts the RecParticles array to the folder structure
+  
   Int_t reval = AliLoader::PostRecParticles();
   if (reval)
-   {
-     Error("PostRecParticles","AliLoader::PostRecParticles  returned error");
-     return reval;
-   }
+    {
+      Error("PostRecParticles","AliLoader::PostRecParticles  returned error");
+      return reval;
+    }
   return ReadRecParticles();
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 Int_t AliEMCALLoader::PostTracks()
 {
+  // Posts the Tracks array to the folder structure
   Int_t reval = AliLoader::PostTracks();
   if (reval)
-   {
-     Error("PostTracks","AliLoader::PostTracks  returned error");
-     return reval;
-   }
+    {
+      Error("PostTracks","AliLoader::PostTracks  returned error");
+      return reval;
+    }
   return ReadTracks();
 }
-//____________________________________________________________________________ 
-
-
 
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::ReadHits()
 {
-// If there is no Clones Array in folder creates it and sends to folder
-// then tries to read
-// Reads the first entry of EMCAL branch in hit tree TreeH()
-// Reads data from TreeH and stores it in TClonesArray that sits in DetectorDataFolder
-//
+  // If there is no Clones Array in folder creates it and sends to folder
+  // then tries to read
+  // Reads the first entry of EMCAL branch in hit tree TreeH()
+  // Reads data from TreeH and stores it in TClonesArray that sits in DetectorDataFolder
+  //
   TObject** hitref = HitsRef();
   if(hitref == 0x0)
-   {
-     MakeHitsArray();
+    {
+      MakeHitsArray();
      hitref = HitsRef();
-   }
-
+    }
+  
   TClonesArray* hits = dynamic_cast<TClonesArray*>(*hitref);
-
+  
   TTree* treeh = TreeH();
   
   if(treeh == 0)
-   {
-    Error("ReadHits"," Cannot read TreeH from folder");
-    return 1;
-  }
+    {
+      Error("ReadHits"," Cannot read TreeH from folder");
+      return 1;
+    }
   
   TBranch * hitsbranch = treeh->GetBranch(fDetectorName);
   if (hitsbranch == 0) 
-   {
-    Error("ReadHits"," Cannot find branch EMCAL"); 
-    return 1;
-  }
+    {
+      Error("ReadHits"," Cannot find branch EMCAL"); 
+      return 1;
+    }
   
-  if (GetDebug()) Info("ReadHits","Reading Hits");
+  if (GetDebug()) 
+    Info("ReadHits","Reading Hits");
   
   if (hitsbranch->GetEntries() > 1)
-   {
-    TClonesArray * tempo =  new TClonesArray("AliEMCALHit",1000);
-
-    hitsbranch->SetAddress(&tempo);
-    Int_t index = 0 ; 
-    Int_t i = 0 ;
-    for (i = 0 ; i < hitsbranch->GetEntries(); i++) 
-     {
-      hitsbranch->GetEntry(i) ;
-      Int_t j = 0 ;
-      for ( j = 0 ; j < tempo->GetEntries() ; j++) 
-       {
-         AliEMCALHit* hit = (AliEMCALHit*)tempo->At(j); 
-         new((*hits)[index]) AliEMCALHit( *hit ) ;
-         index++ ; 
-       }
-     }
-    delete tempo;
-   }
+    {
+      TClonesArray * tempo =  new TClonesArray("AliEMCALHit",1000);
+      
+      hitsbranch->SetAddress(&tempo);
+      Int_t index = 0 ; 
+      Int_t i = 0 ;
+      for (i = 0 ; i < hitsbranch->GetEntries(); i++) 
+       {
+         hitsbranch->GetEntry(i) ;
+         Int_t j = 0 ;
+         for ( j = 0 ; j < tempo->GetEntries() ; j++) 
+           {
+             AliEMCALHit* hit = (AliEMCALHit*)tempo->At(j); 
+             new((*hits)[index]) AliEMCALHit( *hit ) ;
+             index++ ; 
+           }
+       }
+      delete tempo;
+    }
   else 
-   {
-    hitsbranch->SetAddress(hitref);
-    hitsbranch->GetEntry(0) ;
-   }
-
+    {
+      hitsbranch->SetAddress(hitref);
+      hitsbranch->GetEntry(0) ;
+    }
+  
   return 0;
 }
+
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::ReadSDigits()
 {
-// Read the summable digits tree TreeS():
-// Check if TClones is in folder
-// if not create and add to folder
-// connect to tree if available
-// Read the data
-
+  // Read the summable digits tree TreeS():
+  // Check if TClones is in folder
+  // if not create and add to folder
+  // connect to tree if available
+  // Read the data
+  
   TObject** sdref = SDigitsRef();
   if(sdref == 0x0)
-   {
-     MakeSDigitsArray();
-     sdref = SDigitsRef();
-   }
-   
+    {
+      MakeSDigitsArray();
+      sdref = SDigitsRef();
+    }
+  
   TTree * treeS = TreeS();
   if(treeS==0)
-   {
-     //May happen if file is truncated or new in LoadSDigits
-     //Error("ReadSDigits","There is no SDigit Tree");
-     return 0;
-   }
+    {
+      //May happen if file is truncated or new in LoadSDigits
+      //Error("ReadSDigits","There is no SDigit Tree");
+      return 0;
+    }
   
   TBranch * branch = treeS->GetBranch(fDetectorName);
   if (branch == 0) 
-   {//easy, maybe just a new tree
-    //Error("ReadSDigits"," Cannot find branch EMCAL"); 
-    return 0;
-  }
-    
+    {//easy, maybe just a new tree
+      //Error("ReadSDigits"," Cannot find branch EMCAL"); 
+      return 0;
+    }
+  
   branch->SetAddress(SDigitsRef());
   branch->GetEntry(0);
   return 0;
@@ -501,69 +492,71 @@ Int_t AliEMCALLoader::ReadSDigits()
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::ReadDigits()
 {
-// Read the summable digits tree TreeS():
-// Check if TClones is in folder
-// if not create and add to folder
-// connect to tree if available
-// Read the data
+  // Read the summable digits tree TreeS():
+  // Check if TClones is in folder
+  // if not create and add to folder
+  // connect to tree if available
+  // Read the data
   
   TObject** dref = DigitsRef();
   if(dref == 0x0)
-   {//if there is not array in folder, create it and put it there
-     MakeDigitsArray();
-     dref = DigitsRef();
-   }
-
+    {//if there is not array in folder, create it and put it there
+      MakeDigitsArray();
+      dref = DigitsRef();
+    }
+  
   TTree * treeD = TreeD();
   if(treeD==0)
-   {
-     //May happen if file is truncated or new in LoadSDigits
-     //Error("ReadDigits","There is no Digit Tree");
-     return 0;
-   }
-
+    {
+      //May happen if file is truncated or new in LoadSDigits
+      //Error("ReadDigits","There is no Digit Tree");
+      return 0;
+    }
+  
   TBranch * branch = treeD->GetBranch(fDetectorName);
   if (branch == 0) 
-   {//easy, maybe just a new tree
-    //Error("ReadDigits"," Cannot find branch ",fDetectorName.Data()); 
-    return 0;
-   }
+    {//easy, maybe just a new tree
+      //Error("ReadDigits"," Cannot find branch ",fDetectorName.Data()); 
+      return 0;
+    }
   
   branch->SetAddress(dref);//connect branch to buffer sitting in folder
   branch->GetEntry(0);//get first event 
-
+  
   return 0;  
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 void AliEMCALLoader::UnloadRecParticles()
 {
+  // Unloads the RecParticles array fromthe folder structure
   fRecParticlesLoaded = kFALSE;
   CleanRecParticles();
   if (fTracksLoaded == kFALSE) UnloadTracks();
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 void AliEMCALLoader::UnloadTracks()
 {
- CleanTracks();//free the memory
- //in case RecPart are loaded we can not onload tree and close the file
- if (fRecParticlesLoaded == kFALSE) AliLoader::UnloadTracks();
- fTracksLoaded = kFALSE;//mark that nobody needs them
+  // Unloads the Tracks array fromthe folder structure
+  CleanTracks();//free the memory
+  //in case RecPart are loaded we can not onload tree and close the file
+  if (fRecParticlesLoaded == kFALSE) AliLoader::UnloadTracks();
+  fTracksLoaded = kFALSE;//mark that nobody needs them
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 void AliEMCALLoader::Track(Int_t itrack)
 {
-// Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
+  // Read the first entry of EMCAL branch in hit tree gAlice->TreeH()
   if(TreeH()== 0)
-   {
-     if (LoadHits())
-      {
-        Error("Track","Can not load hits.");
-        return;
-      } 
-   }
+    {
+      if (LoadHits())
+       {
+         Error("Track","Can not load hits.");
+         return;
+       } 
+    }
   
   TBranch * hitsbranch = dynamic_cast<TBranch*>(TreeH()->GetListOfBranches()->FindObject("EMCAL")) ;
   if ( !hitsbranch ) {
@@ -572,17 +565,18 @@ void AliEMCALLoader::Track(Int_t itrack)
     return ;
   }  
   if(!Hits()) PostHits();
-
+  
   hitsbranch->SetAddress(HitsRef());
   hitsbranch->GetEntry(itrack);
-
+  
 }
+
 //____________________________________________________________________________ 
 void AliEMCALLoader::ReadTreeQA()
 {
   // Read the digit tree gAlice->TreeQA()
   // so far only EMCAL knows about this Tree  
-
+  
   if(EMCAL()->TreeQA()== 0){
     cerr <<   "ERROR: AliEMCALLoader::ReadTreeQA: can not read TreeQA " << endl ;
     return ;
@@ -595,20 +589,19 @@ void AliEMCALLoader::ReadTreeQA()
     return ; 
   }   
   
-//  if(!Alarms()) PostQA();
-
+  //  if(!Alarms()) PostQA();
+  
   qabranch->SetAddress(AlarmsRef()) ;
-
+  
   qabranch->GetEntry(0) ;
   
 }
 
-
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::ReadRecPoints()
 {
-//Creates and posts to folder an array container, 
-//connects branch in tree (if exists), and reads data to array
+  //Creates and posts to folder an array container, 
+  //connects branch in tree (if exists), and reads data to array
   
   MakeRecPointsArray();
   
@@ -617,54 +610,54 @@ Int_t AliEMCALLoader::ReadRecPoints()
   TObjArray * hca = 0x0 ; 
 
   TTree * treeR = TreeR();
+  
   if(treeR==0)
-   {
-     //May happen if file is truncated or new in LoadSDigits
-     return 0;
-   }
-
+    {
+      //May happen if file is truncated or new in LoadSDigits
+      return 0;
+    }
+  
   Int_t retval = 0;
   TBranch * prebranch = treeR->GetBranch(fgkPRERecPointsBranchName);
-
+  
   if (prebranch == 0x0)
-   {
-     Error("ReadRecPoints","Can not get branch with PRE Rec. Points named %s",fgkPRERecPointsBranchName.Data());
-     retval = 1;
-   }
+    {
+      Error("ReadRecPoints","Can not get branch with PRE Rec. Points named %s",fgkPRERecPointsBranchName.Data());
+      retval = 1;
+    }
   else
-   {
-     prebranch->SetAddress(&pre) ;
-     prebranch->GetEntry(0) ;
-   }
+    {
+      prebranch->SetAddress(&pre) ;
+      prebranch->GetEntry(0) ;
+    }
   TBranch * ecabranch = treeR->GetBranch(fgkECARecPointsBranchName);
   if (ecabranch == 0x0)
-   {
-     Error("ReadRecPoints","Can not get branch with ECA Rec. Points named %s",fgkECARecPointsBranchName.Data());
-     retval = 2;
-   }
+    {
+      Error("ReadRecPoints","Can not get branch with ECA Rec. Points named %s",fgkECARecPointsBranchName.Data());
+      retval = 2;
+    }
   else
-   {
-     ecabranch->SetAddress(&eca);
-     ecabranch->GetEntry(0) ;
-   }
+    {
+      ecabranch->SetAddress(&eca);
+      ecabranch->GetEntry(0) ;
+    }
   TBranch * hcabranch = treeR->GetBranch(fgkHCARecPointsBranchName);
   if (hcabranch == 0x0)
-   {
-     Error("ReadRecPoints","Can not get branch with HCA Rec. Points named %s",fgkHCARecPointsBranchName.Data());
-     retval = 2;
-   }
+    {
+      Error("ReadRecPoints","Can not get branch with HCA Rec. Points named %s",fgkHCARecPointsBranchName.Data());
+      retval = 2;
+    }
   else
-   {
-     hcabranch->SetAddress(&hca);
-     hcabranch->GetEntry(0) ;
-   }
-
+    {
+      hcabranch->SetAddress(&hca);
+      hcabranch->GetEntry(0) ;
+    }
+  
   Int_t ii ; 
   Int_t maxpre = pre->GetEntries() ; 
   for ( ii= 0 ; ii < maxpre ; ii++ ) 
     PRERecPoints()->Add(pre->At(ii)) ;
+  
   Int_t maxeca = eca->GetEntries() ; 
   for ( ii= 0 ; ii < maxeca ; ii++ ) 
     ECARecPoints()->Add(eca->At(ii)) ;
@@ -672,112 +665,113 @@ Int_t AliEMCALLoader::ReadRecPoints()
   Int_t maxhca = hca->GetEntries() ; 
   for ( ii= 0 ; ii < maxhca ; ii++ ) 
     HCARecPoints()->Add(hca->At(ii)) ;
+  
   return retval;
 }
 
 //____________________________________________________________________________ 
 Int_t AliEMCALLoader::ReadTracks()
 {
-//Creates and posts to folder an array container, 
-//connects branch in tree (if exists), and reads data to arry
-
+  //Creates and posts to folder an array container, 
+  //connects branch in tree (if exists), and reads data to arry
+  
   TObject** trkref = TracksRef();
   if ( trkref == 0x0 )   
-   {//Create and post array
-    MakeTrackSegmentsArray();
-    trkref = TracksRef();
-   }
-
+    {//Create and post array
+      MakeTrackSegmentsArray();
+      trkref = TracksRef();
+    }
+  
   TTree * treeT = TreeT();
   if(treeT==0)
-   {
-     //May happen if file is truncated or new in LoadSDigits, or the file is in update mode, 
-     //but tracking was not performed yet for a current event
-     //Error("ReadTracks","There is no Tree with Tracks");
-     return 0;
-   }
+    {
+      //May happen if file is truncated or new in LoadSDigits, or the file is in update mode, 
+      //but tracking was not performed yet for a current event
+      //Error("ReadTracks","There is no Tree with Tracks");
+      return 0;
+    }
   
   TBranch * branch = treeT->GetBranch(fgkTrackSegmentsBranchName);
   if (branch == 0) 
-   {//easy, maybe just a new tree
-    Error("ReadTracks"," Cannot find branch named %s",fgkTrackSegmentsBranchName.Data());
-    return 0;
-  }
-
+    {//easy, maybe just a new tree
+      Error("ReadTracks"," Cannot find branch named %s",fgkTrackSegmentsBranchName.Data());
+      return 0;
+    }
+  
   branch->SetAddress(trkref);//connect branch to buffer sitting in folder
   branch->GetEntry(0);//get first event 
   
   return 0;
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 Int_t AliEMCALLoader::ReadRecParticles()
 {
-//Reads Reconstructed  Particles from file
-//Creates and posts to folder an array container, 
-//connects branch in tree (if exists), and reads data to arry
+  //Reads Reconstructed  Particles from file
+  //Creates and posts to folder an array container, 
+  //connects branch in tree (if exists), and reads data to arry
   
   TObject** recpartref = RecParticlesRef();
   
   if ( recpartref == 0x0 )   
-   {//Create and post array
-    MakeRecParticlesArray();
-    recpartref = RecParticlesRef();
-   }
-
+    {//Create and post array
+      MakeRecParticlesArray();
+      recpartref = RecParticlesRef();
+    }
+  
   TTree * treeP = TreeP();
   if(treeP==0)
-   {
-     //May happen if file is truncated or new in LoadSDigits, 
-     //or the file is in update mode, 
-     //but tracking was not performed yet for a current event
-     //     Error("ReadRecParticles","There is no Tree with Tracks and Reconstructed Particles");
-     return 0;
-   }
+    {
+      //May happen if file is truncated or new in LoadSDigits, 
+      //or the file is in update mode, 
+      //but tracking was not performed yet for a current event
+      //     Error("ReadRecParticles","There is no Tree with Tracks and Reconstructed Particles");
+      return 0;
+    }
   
   TBranch * branch = treeP->GetBranch(fgkRecParticlesBranchName);
   if (branch == 0) 
-   {//easy, maybe just a new tree
-    Error("ReadRecParticles"," Cannot find branch %s",fgkRecParticlesBranchName.Data()); 
-    return 0;
-  }
-
+    {//easy, maybe just a new tree
+      Error("ReadRecParticles"," Cannot find branch %s",fgkRecParticlesBranchName.Data()); 
+      return 0;
+    }
+  
   branch->SetAddress(recpartref);//connect branch to buffer sitting in folder
   branch->GetEntry(0);//get first event 
   
   return 0;
 }
 
-
+//____________________________________________________________________________ 
 AliEMCALGeometry* AliEMCALLoader::GetEMCALGeometry()
 {
-//returns EMCAL geometry from gAlice 
-//static Method used by some classes where it is not convienient to pass eventfoldername
- if (gAlice == 0x0)
-  return 0x0;
- AliEMCAL* emcal=dynamic_cast<AliEMCAL*>(gAlice->GetDetector("EMCAL"));
- if (emcal == 0x0)
-  return 0x0;
- return emcal->GetGeometry();
+  //returns EMCAL geometry from gAlice 
+  //static Method used by some classes where it is not convienient to pass eventfoldername
+  if (gAlice == 0x0)
+    return 0x0;
+  AliEMCAL* emcal=dynamic_cast<AliEMCAL*>(gAlice->GetDetector("EMCAL"));
+  if (emcal == 0x0)
+    return 0x0;
+  return emcal->GetGeometry();
 }
-/***************************************************************************************/
 
+//____________________________________________________________________________ 
 AliEMCALLoader* AliEMCALLoader::GetEMCALLoader(const  char* eventfoldername)
 {
+  // Get an instance of the EMCALLoader object
   AliRunLoader* rn  = AliRunLoader::GetRunLoader(eventfoldername);
   if (rn == 0x0)
-   {
-     cerr<<"Error: <AliEMCALLoader::GetEMCALLoader>: "
-         << "Can not find Run Loader in folder "<<eventfoldername<<endl;
-     return 0x0;
-   }
+    {
+      cerr<<"Error: <AliEMCALLoader::GetEMCALLoader>: "
+         << "Can not find Run Loader in folder "<<eventfoldername<<endl;
+      return 0x0;
+    }
   return dynamic_cast<AliEMCALLoader*>(rn->GetLoader("EMCALLoader"));
 }
-/***************************************************************************************/
 
+//____________________________________________________________________________ 
 Bool_t AliEMCALLoader::BranchExists(const TString& recName)
- {
+{
   if (fBranchTitle.IsNull()) return kFALSE;
   TString dataname, zername ;
   TTree* tree;
@@ -818,17 +812,16 @@ Bool_t AliEMCALLoader::BranchExists(const TString& recName)
   }
   else
     return kFALSE ;
-
   
   if(!tree ) 
     return kFALSE ;
-
+  
   TObjArray * lob = static_cast<TObjArray*>(tree->GetListOfBranches()) ;
   TIter next(lob) ; 
   TBranch * branch = 0 ;  
   TString titleName(fBranchTitle);
   titleName+=":";
-
+  
   while ((branch = (static_cast<TBranch*>(next())))) {
     TString branchName(branch->GetName() ) ; 
     TString branchTitle(branch->GetTitle() ) ;  
@@ -842,17 +835,19 @@ Bool_t AliEMCALLoader::BranchExists(const TString& recName)
     }
   }
   return kFALSE ;
+  
+}
 
- }
-
+//____________________________________________________________________________ 
 void AliEMCALLoader::SetBranchTitle(const TString& btitle)
- {
+{
+  // Gives a name to a branch in the folder structure
   if (btitle.CompareTo(fBranchTitle) == 0) return;
   fBranchTitle = btitle;
   ReloadAll();
- }
-//____________________________________________________________________________ 
+}
 
+//____________________________________________________________________________ 
 void AliEMCALLoader::CleanHits()
 {
   AliLoader::CleanHits();
@@ -860,10 +855,11 @@ void AliEMCALLoader::CleanHits()
   TClonesArray* hits = Hits();
   if (hits) hits->Clear();
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 void AliEMCALLoader::CleanSDigits()
 {
+  // Cleans the SDigits array in the folder structure
   AliLoader::CleanSDigits();
   TClonesArray* sdigits = SDigits();
   if (sdigits) sdigits->Clear();
@@ -873,47 +869,49 @@ void AliEMCALLoader::CleanSDigits()
 
 void AliEMCALLoader::CleanDigits()
 {
+  // Cleans the Digits array in the folder structure
   AliLoader::CleanDigits();
   TClonesArray* digits = Digits();
   if (digits) digits->Clear();
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 void AliEMCALLoader::CleanRecPoints()
 {
+  // Cleans the RecPoints array in the folder structure
   AliLoader::CleanRecPoints();
   TObjArray* recpoints = PRERecPoints();
-  if (recpoints) recpoints->Clear();
+  if (recpoints) 
+    recpoints->Clear();
   recpoints = ECARecPoints();
-  if (recpoints) recpoints->Clear();
+  if (recpoints) 
+    recpoints->Clear();
   recpoints = HCARecPoints();
-  if (recpoints) recpoints->Clear();
+  if (recpoints) 
+    recpoints->Clear();
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 void AliEMCALLoader::CleanTracks()
 {
-//Cleans Tracks stuff
-  
+  // Cleans the Tracks array in the folder structure
   AliLoader::CleanTracks();//tree
-  
   //and clear the array
   TClonesArray* tracks = TrackSegments();
-  if (tracks) tracks->Clear();
-
+  if (tracks) 
+    tracks->Clear();  
 }
-//____________________________________________________________________________ 
 
+//____________________________________________________________________________ 
 void AliEMCALLoader::CleanRecParticles()
- {
+{
+  // Cleans the RecParticles array in the folder structure
+  TClonesArray *recpar = RecParticles();
+  if (recpar) 
+    recpar->Clear();
+}
 
-   TClonesArray *recpar = RecParticles();
-   if (recpar) recpar->Clear();
-  
- }
 //____________________________________________________________________________ 
-
 // void AliEMCALLoader::ReadCalibrationDB(const char * database,const char * filename)
 // {
 
@@ -944,6 +942,7 @@ void AliEMCALLoader::CleanRecParticles()
 //____________________________________________________________________________ 
 void AliEMCALLoader::MakeHitsArray()
 {
+  // Create the array for Hits
   if (Hits()) return;
   TClonesArray* hits = new TClonesArray("AliEMCALHit",1000);
   hits->SetName(fgkHitsName);
@@ -953,6 +952,7 @@ void AliEMCALLoader::MakeHitsArray()
 //____________________________________________________________________________ 
 void AliEMCALLoader::MakeSDigitsArray()
 {
+  // Create the array for SDigits
   if ( SDigits()) return;
   TClonesArray* sdigits = new TClonesArray("AliEMCALDigit",1);
   sdigits->SetName(fgkSDigitsName);
@@ -962,6 +962,7 @@ void AliEMCALLoader::MakeSDigitsArray()
 //____________________________________________________________________________ 
 void AliEMCALLoader::MakeDigitsArray()
 {
+  // Create the array for Digits
   if ( Digits()) return;
   TClonesArray* digits = new TClonesArray("AliEMCALDigit",1);
   digits->SetName(fgkDigitsName);
@@ -971,7 +972,8 @@ void AliEMCALLoader::MakeDigitsArray()
 
 //____________________________________________________________________________ 
 void AliEMCALLoader::MakeRecPointsArray()
-{
+{ 
+  // Create the array for RecPoints
   if ( PRERecPoints() == 0x0) {
     if (GetDebug()>9) 
       Info("MakeRecPointsArray","Making array for PRE");
@@ -985,29 +987,31 @@ void AliEMCALLoader::MakeRecPointsArray()
     TObjArray* eca = new TObjArray(100) ;
     eca->SetName(fgkECARecPointsName) ;
     GetDetectorDataFolder()->Add(eca);
-   }
+  }
   if ( HCARecPoints() == 0x0) {
     if (GetDebug()>9) 
       Info("MakeRecPointsArray","Making array for HCA");
     TObjArray* hca = new TObjArray(100) ;
     hca->SetName(fgkHCARecPointsName) ;
     GetDetectorDataFolder()->Add(hca);
-   }
+  }
 }
 
 //____________________________________________________________________________ 
 void AliEMCALLoader::MakeTrackSegmentsArray()
 {
-  if ( TrackSegments()) return;
+  // Create the array for TrackSegments
+  if ( TrackSegments()) 
+    return;
   TClonesArray * ts = new TClonesArray("AliEMCALTrackSegment",100) ;
   ts->SetName(fgkTracksName);
   GetDetectorDataFolder()->Add(ts);
-
 }
 
 //____________________________________________________________________________ 
 void AliEMCALLoader::MakeRecParticlesArray()
-{
+{  
+  // Create the array for RecParticles
   if ( RecParticles()) return;
   TClonesArray * rp = new TClonesArray("AliEMCALRecParticle",100) ;
   rp->SetName(fgkRecParticlesName);
index bbff9f0..40fe8b7 100644 (file)
@@ -25,26 +25,25 @@ class TParticle ;
 class TTask ;
 
 // --- Standard library ---
-#include <stdlib.h>
-#include <Riostream.h>
 
 // --- AliRoot header files ---
 
 #include "AliRun.h"
-#include "AliLoader.h"
 #include "AliRunLoader.h"
-#include "AliEMCAL.h" 
-#include "AliEMCALHit.h" 
 #include "AliEMCALDigit.h"
-#include "AliEMCALTowerRecPoint.h"
+#include "AliEMCALRecPoint.h"
+#include "AliEMCALTowerRecPoint.h" 
 #include "AliEMCALTrackSegment.h"
-#include "AliEMCALRecParticle.h"
-class AliEMCALGeometry ;
-#include "AliEMCALDigitizer.h"
-#include "AliEMCALSDigitizer.h"
 #include "AliEMCALClusterizer.h"
-#include "AliEMCALTrackSegmentMaker.h"
+#include "AliEMCALTrackSegmentMaker.h" 
 #include "AliEMCALPID.h"
+class AliLoader ;
+class AliEMCAL ; 
+class AliEMCALHit ;
+class AliEMCALRecParticle ; 
+class AliEMCALGeometry ;
+class AliEMCALDigitizer ; 
+class AliEMCALSDigitizer ; 
 class AliEMCALCalibrationDB ;
 
 
@@ -61,7 +60,7 @@ class AliEMCALLoader : public AliLoader {
   virtual ~AliEMCALLoader() ; 
 
   // assignement operator requested by coding convention, but not needed
-  AliEMCALLoader & operator = (const AliEMCALLoader & ) {return *this;}
+  const AliEMCALLoader & operator = (const AliEMCALLoader & ) {return *this;}
 
   Int_t   GetEvent();//extends the method on EMCAL RecPart posting
   Int_t   SetEvent();//extends the method on EMCAL RecPart posting
@@ -190,6 +189,21 @@ class AliEMCALLoader : public AliLoader {
   AliEMCALCalibrationDB * CalibrationDB(){return  fcdb; }
   //void ReadCalibrationDB(const char * name, const char * filename);
   
+
+  static TString HitsName() { return fgkHitsName ; }   //Name for TClonesArray with hits from one event
+  static TString SDigitsName() { return fgkSDigitsName ;} //Name for TClonesArray 
+  static TString DigitsName() { return fgkDigitsName ;} //Name for TClonesArray 
+  static TString PreRecPointsName() { return fgkPRERecPointsName ;} //Name for TClonesArray 
+  static TString ECARecPointsName() { return fgkECARecPointsName ;} //Name for TClonesArray 
+  static TString HCARecPointsName() { return fgkHCARecPointsName ;} //Name for TClonesArray 
+  static TString TracksName() { return fgkTracksName ;} //Name for TClonesArray 
+  static TString RecParticlesName() { return fgkRecParticlesName ;} //Name for TClonesArray
+  static TString PRERecPointsBranchName() { return fgkPRERecPointsBranchName ;} //Name for branch
+  static TString ECARecPointsBranchName() { return fgkECARecPointsBranchName ;} //Name for branch
+  static TString HCARecPointsBranchName() { return fgkHCARecPointsBranchName ;} //Name for branch
+  static TString TrackSegmentsBranchName() { return fgkTrackSegmentsBranchName ;} //Name for branch
+  static TString RecParticlesBranchName() { return fgkRecParticlesBranchName ;} //Name for branch
+
 protected:
   TString fBranchTitle;            //Title of the branch
   Bool_t  fRecParticlesLoaded;     //Flag signing if Reconstructed Particles are loaded
@@ -207,9 +221,6 @@ private:
   Int_t ReadRecParticles();
   
   void  ReadTreeQA() ;
-  Int_t  fDebug ;             // Debug level
- public:
 
   static const TString fgkHitsName;//Name for TClonesArray with hits from one event
   static const TString fgkSDigitsName;//Name for TClonesArray 
@@ -225,6 +236,9 @@ private:
   static const TString fgkHCARecPointsBranchName;//Name for branch
   static const TString fgkTrackSegmentsBranchName;//Name for branch
   static const TString fgkRecParticlesBranchName;//Name for branch
+  Int_t  fDebug ;             // Debug level
+
   
   ClassDef(AliEMCALLoader,3)  // Algorithm class that provides methods to retrieve objects from a list knowing the index 
 
index 05732b7..b9d507e 100644 (file)
 
 
 // --- ROOT system ---
-#include "TGeometry.h"
-#include "TDirectory.h"
-#include "TFile.h"
-#include "TTree.h"
+
 // --- Standard library ---
 
 // --- AliRoot header files ---
index b215acb..ddc1c02 100644 (file)
@@ -15,7 +15,6 @@
 
 #include "TTask.h" 
 #include "AliConfig.h"
-
 class TFormula ;
 class TClonesArray ;
 
index 848c308..0eef875 100644 (file)
 //*-- Author: Yves Schutz (SUBATECH) 
 //
 // --- ROOT system ---
-#include "TROOT.h"
+//#include "TROOT.h"
 #include "TTree.h"
-#include "TFile.h"
-#include "TF2.h"
-#include "TCanvas.h"
-#include "TFolder.h"
-#include "TSystem.h"
 #include "TBenchmark.h"
 #include "TSystem.h"
   
   // --- Standard library ---
   
   // --- AliRoot header files ---
-  
-#include "AliGenerator.h"
-#include "AliEMCAL.h"
 #include "AliEMCALPIDv1.h"
-#include "AliEMCALClusterizerv1.h"
 #include "AliEMCALTrackSegment.h"
-#include "AliEMCALTrackSegmentMakerv1.h"
 #include "AliEMCALRecParticle.h"
-#include "AliEMCALGeometry.h"
 #include "AliEMCALGetter.h"
   
   ClassImp( AliEMCALPIDv1) 
@@ -106,7 +95,7 @@ void AliEMCALPIDv1::Init()
 //____________________________________________________________________________
 void AliEMCALPIDv1::InitParameters()
 {
-
+  // Initialize the parameters
   fRecParticlesInRun = 0 ; 
   fNEvent            = 0 ;            
   fRecParticlesInRun = 0 ;
@@ -209,13 +198,13 @@ void  AliEMCALPIDv1::MakeRecParticles(){
       // Looking PCA. Define and calculate the data (X),
       // introduce in the function X2P that gives the components (P).  
 
-      Float_t  Spher = 0. ;
-      Float_t  Emaxdtotal = 0. ; 
+      Float_t  spher = 0. ;
+      Float_t  emaxdtotal = 0. ; 
       
       if((lambda[0]+lambda[1])!=0) 
-       Spher=fabs(lambda[0]-lambda[1])/(lambda[0]+lambda[1]); 
+       spher=fabs(lambda[0]-lambda[1])/(lambda[0]+lambda[1]); 
       
-      Emaxdtotal=eca->GetMaximalEnergy()/eca->GetEnergy(); 
+      emaxdtotal=eca->GetMaximalEnergy()/eca->GetEnergy(); 
     }
     
     //    Float_t time = ecal->GetTime() ;
@@ -285,6 +274,7 @@ void AliEMCALPIDv1::PrintRecParticles(Option_t * option)
 //____________________________________________________________________________
 void AliEMCALPIDv1::Unload() 
 {
+  // Unloads RecPoints, TrackSegments and RecParticles from the folder 
   AliEMCALGetter * gime = AliEMCALGetter::Instance() ;  
   gime->EmcalLoader()->UnloadRecPoints() ;
   gime->EmcalLoader()->UnloadTracks() ;
@@ -294,7 +284,7 @@ void AliEMCALPIDv1::Unload()
 //____________________________________________________________________________
 void  AliEMCALPIDv1::WriteRecParticles()
 {
+  // Write RecParticles array to file
   AliEMCALGetter *gime = AliEMCALGetter::Instance() ; 
 
   TClonesArray * recParticles = gime->RecParticles() ; 
index 3d95e00..47b86af 100644 (file)
@@ -43,7 +43,7 @@ class  AliEMCALPIDv1 : public AliEMCALPID {
   virtual void Print(Option_t * option) const ;
  
   //To turn on or off the Pi0 analysis
-  const Bool_t GetPi0Analysis(){return fPi0Analysis;}
+  Bool_t GetPi0Analysis() const {return fPi0Analysis;}
   void  SetPi0Analysis(Bool_t turnonoff){ fPi0Analysis = turnonoff; }
  
   virtual const char * Version() const { return "pid-v1" ; }  
index 173ceea..6b0122d 100644 (file)
@@ -78,6 +78,7 @@ const Int_t AliEMCALRecParticle::GetNPrimaries() const
 //____________________________________________________________________________
 const Int_t AliEMCALRecParticle::GetNPrimariesToRecParticles() const  
 { 
+  // Returns the number of primaries at the origine of a RecParticle
   Int_t rv = 0 ;
   AliEMCALGetter * gime = AliEMCALGetter::Instance() ; 
   Int_t ecaRPindex = dynamic_cast<AliEMCALTrackSegment*>(gime->TrackSegments()->At(GetEMCALTSIndex()))->GetECAIndex();
@@ -88,6 +89,7 @@ const Int_t AliEMCALRecParticle::GetNPrimariesToRecParticles() const
 //____________________________________________________________________________
 const TParticle * AliEMCALRecParticle::GetPrimary(Int_t index) const  
 {
+  // Getts the list of primary particles at the origine of the RecParticle
   if ( index > GetNPrimariesToRecParticles() ) { 
     if (fDebug) 
       Warning("GetPrimary", "AliEMCALRecParticle::GetPrimary -> %d is larger that the number of primaries %d", 
index 32911f1..a9a49d9 100644 (file)
@@ -41,7 +41,7 @@ class AliEMCALRecParticle : public AliEMCALFastRecParticle {
  private:
 
   Int_t fEMCALTrackSegment ; // pointer to the associated track segment in EMCAL  
-  Bool_t fDebug ; 
+  Bool_t fDebug ; // to steer debug output 
 
   ClassDef(AliEMCALRecParticle,2)  // Reconstructed Particle
 };
index 40fa9fd..684b8f0 100644 (file)
 //  Why should I put meaningless comments
 //  just to satisfy
 //  the code checker                
-//*-- Author: Gines Martinez (SUBATECH)
+//*-- Author: Yves Schutz (SUBATECH)
 
 // --- ROOT system ---
 #include "TPad.h"
+#include "TGraph.h"
+#include "TPaveText.h"
 #include "TClonesArray.h"
 
 // --- Standard library ---
index 0d44c11..1f26b8c 100644 (file)
@@ -5,16 +5,10 @@
 //_________________________________________________________________________
 //  Base Class for EMCAL Reconstructed Points  
 //  A recpoint being equivalent to a cluster in encal terminology                 
-//*-- Author: Gines Martinez (SUBATECH)
-
-#include <assert.h>
+//*-- Author: Yves Schutz (SUBATECH)
 
 // --- ROOT system ---
 
-#include "TMarker.h"
-#include "TGraph.h"
-#include "TPaveText.h"
-
 // --- Standard library ---
 
 // --- AliRoot header files ---
@@ -30,19 +24,12 @@ class AliEMCALRecPoint : public AliRecPoint {
 
   AliEMCALRecPoint() ;                   // ctor         
   AliEMCALRecPoint(const char * opt) ;   // ctor 
-  AliEMCALRecPoint(const AliEMCALRecPoint & rp):AliRecPoint(rp) {
-    // cpy ctor requested by Coding Convention 
-    // but not yet needed
-    assert(0==1) ; 
-  } 
+  AliEMCALRecPoint(const AliEMCALRecPoint & rp):AliRecPoint(rp) { Fatal("cpy ctor", "not implemented") ; } 
   
   virtual ~AliEMCALRecPoint(){
     // dtor
   }
-  virtual  void   AddDigit(AliDigitNew &){
-    // do not use this definition but the one below
-    assert(0==1) ; 
-  }
+  virtual  void   AddDigit(AliDigitNew &){ Fatal("AddDigit", "use AddDigit(AliEMCALDigit & digit, Float_t Energy )") ; }
   virtual  void   AddDigit(AliEMCALDigit & digit, Float_t Energy) = 0 ; 
   virtual Int_t   Compare(const TObject * obj) const = 0 ;   
   virtual Int_t   DistancetoPrimitive(Int_t px, Int_t py);
@@ -75,8 +62,7 @@ class AliEMCALRecPoint : public AliRecPoint {
   void SetHCA() { fHCASection = kTRUE ; } 
   void SetPRE()  { fPRESection  = kTRUE ; } 
   AliEMCALRecPoint & operator = (const AliEMCALRecPoint & )  {
-    // assignement operator requested by coding convention but not needed
-    assert(0==1) ;
+    Fatal("operator =", "not implemented") ;
     return *this ; 
   }
 
index 1524d70..9793f86 100644 (file)
 //////////////////////////////////////////////////////////////////////////////
 
 // --- ROOT system ---
-#include "TFile.h"
-#include "TROOT.h"
 #include "TBenchmark.h"
 
 // --- Standard library ---
+#include "stdlib.h"
 
 // --- AliRoot header files ---
-#include "AliRun.h"
 #include "AliEMCALDigit.h"
 #include "AliEMCALGetter.h"
 #include "AliEMCALHit.h"
@@ -132,6 +130,7 @@ void AliEMCALSDigitizer::Init(){
 //____________________________________________________________________________ 
 void AliEMCALSDigitizer::InitParameters()
 {
+  // Initializes parameters
   fA                      = 0;
   fB                      = 10000000.;
 
@@ -157,7 +156,7 @@ void AliEMCALSDigitizer::Exec(Option_t *option)
   // Collects all hits in the section (PRE/ECAL/HCAL) of the same tower into digit
   
   if (strstr(option, "print") ) {
-    Print("") ; 
+    Print() ; 
     return ; 
   }
   
@@ -257,7 +256,7 @@ void AliEMCALSDigitizer::Exec(Option_t *option)
     fSDigitsInRun += nSdigits ;  
     sdigits->Expand(nSdigits) ;
 
-    Int_t NPrimarymax = -1 ; 
+    Int_t nPrimarymax = -1 ; 
     Int_t i ;
     for (i = 0 ; i < sdigits->GetEntriesFast() ; i++) { 
       AliEMCALDigit * sdigit = dynamic_cast<AliEMCALDigit *>(sdigits->At(i)) ;
@@ -265,8 +264,8 @@ void AliEMCALSDigitizer::Exec(Option_t *option)
     }
     
     for (i = 0 ; i < sdigits->GetEntriesFast() ; i++) {   
-      if (((dynamic_cast<AliEMCALDigit *>(sdigits->At(i)))->GetNprimary()) > NPrimarymax)
-       NPrimarymax = ((dynamic_cast<AliEMCALDigit *>(sdigits->At(i)))->GetNprimary()) ;
+      if (((dynamic_cast<AliEMCALDigit *>(sdigits->At(i)))->GetNprimary()) > nPrimarymax)
+       nPrimarymax = ((dynamic_cast<AliEMCALDigit *>(sdigits->At(i)))->GetNprimary()) ;
     }
     
     // Now write SDigits    
@@ -301,7 +300,7 @@ void AliEMCALSDigitizer::Exec(Option_t *option)
 
 
 //__________________________________________________________________
-void AliEMCALSDigitizer::Print(Option_t*)const
+void AliEMCALSDigitizer::Print()const
 { 
   // Prints parameters of SDigitizer
   Info("Print", "\n------------------- %s -------------", GetName() ) ; 
@@ -331,9 +330,11 @@ Bool_t AliEMCALSDigitizer::operator==( AliEMCALSDigitizer const &sd )const
 }
 
 //__________________________________________________________________
-void AliEMCALSDigitizer::PrintSDigits(Option_t * option){
+void AliEMCALSDigitizer::PrintSDigits(Option_t * option)
+{
   //Prints list of digits produced at the current pass of AliEMCALDigitizer
   
+  
   AliEMCALGetter * gime = AliEMCALGetter::Instance() ; 
   const TClonesArray * sdigits = gime->SDigits() ; 
   
@@ -369,6 +370,7 @@ void AliEMCALSDigitizer::PrintSDigits(Option_t * option){
 //____________________________________________________________________________ 
 void AliEMCALSDigitizer::Unload() const
 {
+  // Unload Hits and SDigits from the folder
   AliEMCALGetter * gime = AliEMCALGetter::Instance() ; 
   AliEMCALLoader * loader = gime->EmcalLoader() ; 
   loader->UnloadHits() ; 
index 7c9f7e3..a4a979c 100644 (file)
@@ -35,11 +35,11 @@ public:
   Int_t         Digitize(Float_t Energy)const { return (Int_t ) ( fA + Energy*fB); }
   virtual void  Exec(Option_t *option); 
   Int_t         GetSDigitsInRun() const {return fSDigitsInRun ;}  
-  virtual void  Print(Option_t*) const ;
+  virtual void  Print() const ;
   void          SetEventFolderName(TString name) { fEventFolderName = name ; }
 
   Bool_t operator == (const AliEMCALSDigitizer & sd) const ;
-  AliEMCALSDigitizer & operator = (const AliEMCALSDigitizer & /*sd*/) {return *this ;}
+  const AliEMCALSDigitizer & operator = (const AliEMCALSDigitizer & /*sd*/) {return *this ;}
 
 
 private:
index 31811c7..8aa504a 100644 (file)
@@ -35,6 +35,7 @@ ClassImp(AliEMCALTick)
 //____________________________________________________________________________ 
   AliEMCALTick::AliEMCALTick():TObject() 
 {
+  //ctor
   fTime = 0;
   fA = 0;
   fB = 0 ;
@@ -43,12 +44,15 @@ ClassImp(AliEMCALTick)
 //____________________________________________________________________________ 
 AliEMCALTick::AliEMCALTick(Float_t time, Float_t a, Float_t slope):TObject()
 {
+  //ctor
   fTime = time;
   fA = a;
   fB = slope ;  
 }
 //____________________________________________________________________________ 
-Int_t AliEMCALTick::Compare(const TObject * obj) const {
+Int_t AliEMCALTick::Compare(const TObject * obj) const 
+{
+  // compares time values
   if(obj->InheritsFrom("AliEMCALTick")){
     AliEMCALTick * tick = (AliEMCALTick *) obj ;
     if(fTime < tick->fTime)
index b93e00d..f31d361 100644 (file)
@@ -32,7 +32,7 @@ public:
     {if(fB) return fTime + (threshold - fA)/fB ;
     else return 1. ;} //return very big time
 
-  Float_t GetTime(void){return fTime ;}
+  Float_t GetTime(void) const {return fTime ;}
 
   void operator+=(AliEMCALTick const &rValue) ;
 
index 8c711c5..862919b 100644 (file)
 
 
 // --- ROOT system ---
-#include "TH2.h"
 #include "TMath.h" 
-#include "TCanvas.h" 
 
 // --- Standard library ---
 
 // --- AliRoot header files ---
 
- #include "AliGenerator.h"
+#include "AliGenerator.h"
 #include "AliEMCALGeometry.h"
 #include "AliEMCALTowerRecPoint.h"
-#include "AliRun.h"
 #include "AliEMCALGetter.h"
 
 ClassImp(AliEMCALTowerRecPoint)
index 9856abb..04999b5 100644 (file)
 //*-- Author: Yves Schutz (SUBATECH)
 
 // --- ROOT system ---
-
-#include "TArrayI.h"
 class TVector3 ;  
 
 // --- Standard library ---
 
 // --- AliRoot header files ---
-
-#include "AliEMCALDigit.h"
 #include "AliEMCALRecPoint.h"
 
 class AliEMCALTowerRecPoint : public AliEMCALRecPoint  {
@@ -31,9 +27,7 @@ public:
   AliEMCALTowerRecPoint() ;
   AliEMCALTowerRecPoint(const char * opt) ;
   AliEMCALTowerRecPoint(const AliEMCALTowerRecPoint & rp):AliEMCALRecPoint(rp) {
-    // cpy ctor requested by Coding Convention 
-    // but not yet needed
-    assert(0==1) ; 
+    Fatal("cpy ctor", "not implemented") ; 
   } 
  
   virtual ~AliEMCALTowerRecPoint() ;  
@@ -65,8 +59,7 @@ public:
   const TVector3 XYZInAlice(Float_t r = 9999., Float_t theta = 9999., Float_t phi = 9999.) const ;  
 
   AliEMCALTowerRecPoint & operator = (const AliEMCALTowerRecPoint & /*rvalue*/)  {
-    // assignement operator requested by coding convention but not needed
-    assert(0==1) ;
+    Fatal("operator =", "not implemented") ;
     return *this ; 
   }
 
index 46bf284..cd34fec 100644 (file)
 // --- ROOT system ---
 
 #include "TObject.h"
+class TClonesArray ; 
 
 // --- Standard library ---
 
 // --- AliRoot header files ---
-
-#include "AliEMCALTowerRecPoint.h"
+#include "AliEMCALTowerRecPoint.h" 
+class AliEMCALRecPoint ; 
 
 class AliEMCALTrackSegment : public TObject  {
 
index dc7a98a..415bc78 100644 (file)
 
 
 // --- ROOT system ---
-#include "TGeometry.h"
-#include "TFile.h"
-#include "TTree.h"
 
 // --- Standard library ---
 
 // --- AliRoot header files ---
 #include "AliEMCALTrackSegmentMaker.h"
-#include "AliHeader.h" 
 
 ClassImp( AliEMCALTrackSegmentMaker) 
 
index 3a1df1f..484eb9a 100644 (file)
 //
 
 // --- ROOT system ---
-#include "TROOT.h"
-#include "TFile.h"
-#include "TFolder.h"
 #include "TTree.h"
-#include "TSystem.h"
 #include "TBenchmark.h"
 
 // --- Standard library ---
 // --- AliRoot header files ---
 
 #include "AliEMCALTrackSegmentMakerv1.h"
-#include "AliEMCALClusterizerv1.h"
 #include "AliEMCALTrackSegment.h"
 #include "AliEMCALLink.h"
 #include "AliEMCALGetter.h"
-#include "AliEMCAL.h"
 
 ClassImp( AliEMCALTrackSegmentMakerv1) 
 
index f13ea3d..e50fdc7 100644 (file)
 
 // --- ROOT system ---
 
-#include "TPGON.h"
+//#include "TPGON.h"
 #include "TTUBS.h"
 #include "TNode.h"
-#include "TRandom.h"
 #include "TGeometry.h"
 #include "TVirtualMC.h"
+#include "TArrayI.h"
 
 // --- Standard library ---
 
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <Rstrstream.h>
-#include <Riostream.h>
+//#include <stdio.h>
 
 // --- AliRoot header files ---
 
 #include "AliEMCALv0.h"
 #include "AliEMCALGeometry.h"
-#include "AliConst.h"
 #include "AliRun.h"
 
 ClassImp(AliEMCALv0)
index 0540291..553fef6 100644 (file)
 //  2. Timing signal is collected and added to hit
 
 // --- ROOT system ---
-#include "TPGON.h"
-#include "TTUBS.h"
-#include "TNode.h"
-#include "TRandom.h"
-#include "TTree.h"
-#include "TGeometry.h"
 #include "TParticle.h"
 #include "TVirtualMC.h"
 
 // --- Standard library ---
 
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <Rstrstream.h>
-#include <Riostream.h>
-#include <math.h>
-
 // --- AliRoot header files ---
-
 #include "AliEMCALv1.h"
 #include "AliEMCALHit.h"
 #include "AliEMCALGeometry.h"
-#include "AliConst.h"
 #include "AliRun.h"
 #include "AliMC.h"