Merge branch 'master' into LocalDev
[u/mrichter/AliRoot.git] / PHOS / AliPHOSLoader.cxx
index f2eae71..d777f16 100644 (file)
 
 /* $Id$ */
 
+/* History of cvs commits:
+ *
+ * $Log$
+ * Revision 1.18  2006/08/28 10:01:56  kharlov
+ * Effective C++ warnings fixed (Timur Pocheptsov)
+ *
+ * Revision 1.17  2006/08/25 16:00:53  kharlov
+ * Compliance with Effective C++AliPHOSHit.cxx
+ *
+ * Revision 1.16  2006/08/01 12:15:04  cvetan
+ * Adding a constructor from TFolder. Needed by AliReconstruction plugin scheme
+ *
+ * Revision 1.15  2005/07/12 20:07:35  hristov
+ * Changes needed to run simulation and reconstrruction in the same AliRoot session
+ *
+ * Revision 1.14  2005/05/28 14:19:04  schutz
+ * Compilation warnings fixed by T.P.
+ *
+ */
+
 //_________________________________________________________________________
 //  A singleton. This class should be used in the analysis stage to get 
 //  reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
 //     ................
 //  please->GetEvent(event) ;    // reads new event from galice.root
 //                  
-//*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
-//*--         Completely redesigned by Dmitri Peressounko March 2001  
+//-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
+//--         Completely redesigned by Dmitri Peressounko March 2001  
 //
-//*-- YS June 2001 : renamed the original AliPHOSIndexToObject and make
-//*--         systematic usage of TFolders without changing the interface        
+//-- YS June 2001 : renamed the original AliPHOSIndexToObject and make
+//--         systematic usage of TFolders without changing the interface        
 //////////////////////////////////////////////////////////////////////////////
 
 
 // --- Standard library ---
 
 // --- AliRoot header files ---
-
+#include "AliObjectLoader.h"
+#include "AliLog.h"
 #include "AliPHOSLoader.h"
 #include "AliPHOS.h"
 #include "AliPHOSHit.h"
-#include "AliPHOSCalibrationDB.h"
-#include "AliPHOSGetter.h"
 
+using std::cout;
+using std::endl;
 ClassImp(AliPHOSLoader)
 
 
@@ -70,17 +91,29 @@ const TString AliPHOSLoader::fgkCpvRecPointsBranchName("PHOSCpvRP");//Name for b
 const TString AliPHOSLoader::fgkTrackSegmentsBranchName("PHOSTS");//Name for branch with TrackSegments
 const TString AliPHOSLoader::fgkRecParticlesBranchName("PHOSRP");//Name for branch with Reconstructed Particles
 //____________________________________________________________________________ 
-AliPHOSLoader::AliPHOSLoader()
- {
-  fDebug = 0;
- }
+AliPHOSLoader::AliPHOSLoader() : fBranchTitle(), fDebug(0), fTmpHits(0x0)
+{
+  //def ctor
+  fTmpHits =  new TClonesArray("AliPHOSHit",1000);
+}
 //____________________________________________________________________________ 
-AliPHOSLoader::AliPHOSLoader(const Char_t *detname,const Char_t *eventfoldername):
-      AliLoader(detname,eventfoldername)
+AliPHOSLoader::AliPHOSLoader(const Char_t *detname,const Char_t *eventfoldername) :
+      AliLoader(detname, eventfoldername),
+      fBranchTitle(), fDebug(0), fTmpHits(0x0)
 {
-  fDebug=0;
+  //ctor
 }
 //____________________________________________________________________________ 
+AliPHOSLoader::AliPHOSLoader(const Char_t *detname,TFolder *topfolder):
+  AliLoader(detname,topfolder),
+  fBranchTitle(), fDebug(0), fTmpHits(0x0)
+
+{
+  //ctor
+  fTmpHits =  new TClonesArray("AliPHOSHit",1000);
+}
+
+//____________________________________________________________________________ 
 
 AliPHOSLoader::~AliPHOSLoader()
 {
@@ -93,10 +126,6 @@ AliPHOSLoader::~AliPHOSLoader()
   Clean(fgkTracksName);
   Clean(fgkRecParticlesName);
   CleanFolders() ;
-  // set to 0x0 the objgetter in AliGetter ... weird isn it !
-  AliPHOSGetter * gime = AliPHOSGetter::Instance((AliLoader::GetRunLoader()->GetFileName()).Data()) ; 
-  if (gime) 
-    gime->Reset() ;
 }
 
 //____________________________________________________________________________ 
@@ -110,13 +139,13 @@ void AliPHOSLoader::CleanFolders()
 Int_t AliPHOSLoader::SetEvent()
 {
 //Cleans loaded stuff and and sets Files and Directories
-// do not post any data to folder/tasks
+// do not post any data to folder
 
 
  Int_t retval = AliLoader::SetEvent();
   if (retval)
    {
-     Error("SetEvent","AliLoader::SetEvent returned error");
+     AliError("returned error");
      return retval;
    }
 
@@ -144,7 +173,7 @@ Int_t AliPHOSLoader::GetEvent()
   retval = AliLoader::GetEvent();
   if (retval)
    {
-     Error("GetEvent","AliLoader::GetEvent returned error");
+     AliError("returned error");
      return retval;
    }
   
@@ -160,27 +189,16 @@ Int_t AliPHOSLoader::GetEvent()
   return 0;
 }
 
-//____________________________________________________________________________ 
-const AliPHOS * AliPHOSLoader::PHOS() 
-{
-  // returns the PHOS object 
-  AliPHOS * phos = dynamic_cast<AliPHOS*>(GetModulesFolder()->FindObject(fDetectorName));
-  if ( phos == 0x0) 
-    if (fDebug)
-      cout << "WARNING: AliPHOSLoader::PHOS -> PHOS module not found in Folders" << endl ; 
-  return phos ; 
-}  
-
-//____________________________________________________________________________ 
-const AliPHOSGeometry * AliPHOSLoader::PHOSGeometry() 
-{
-  // Return PHOS geometry
-  AliPHOSGeometry * rv = 0 ; 
-  if (PHOS() )
-    rv =  PHOS()->GetGeometry();
-  return rv ; 
-} 
-
+// //____________________________________________________________________________ 
+// const AliPHOS * AliPHOSLoader::PHOS() 
+// {
+//   // returns the PHOS object 
+//   AliPHOS * phos = dynamic_cast<AliPHOS*>(GetModulesFolder()->FindObject(fDetectorName));
+//   if ( phos == 0x0) 
+//     if (fDebug)
+//       cout << "WARNING: AliPHOSLoader::PHOS -> PHOS module not found in Folders" << endl ; 
+//   return phos ; 
+// }  
 
 //____________________________________________________________________________ 
 Int_t AliPHOSLoader::LoadHits(Option_t* opt)
@@ -195,7 +213,7 @@ Int_t AliPHOSLoader::LoadHits(Option_t* opt)
   
   if (res)
    {//oops, error
-     Error("LoadHits","AliLoader::LoadHits returned error");
+     AliError("returned error");
      return res;
    }
 
@@ -214,7 +232,7 @@ Int_t AliPHOSLoader::LoadSDigits(Option_t* opt)
   res = AliLoader::LoadSDigits(opt);
   if (res)
    {//oops, error
-     Error("PostSDigits","AliLoader::LoadSDigits returned error");
+     AliError("returned error");
      return res;
    }
   return ReadSDigits();
@@ -229,7 +247,7 @@ Int_t AliPHOSLoader::LoadDigits(Option_t* opt)
   res = AliLoader::LoadDigits(opt);
   if (res)
    {//oops, error
-     Error("LoadDigits","AliLoader::LoadDigits returned error");
+     AliError("returned error");
      return res;
    }
   return ReadDigits();
@@ -243,14 +261,14 @@ Int_t AliPHOSLoader::LoadRecPoints(Option_t* opt)
   res = AliLoader::LoadRecPoints(opt);
   if (res)
    {//oops, error
-     Error("LoadRecPoints","AliLoader::LoadRecPoints returned error");
+     AliError("returned error");
      return res;
    }
 
   TFolder * phosFolder = GetDetectorDataFolder();
   if ( phosFolder  == 0x0 ) 
    {
-     Error("PostDigits","Can not get detector data folder");
+     AliError("Can not get detector data folder");
      return 1;
    }
   return ReadRecPoints();
@@ -260,12 +278,12 @@ Int_t AliPHOSLoader::LoadRecPoints(Option_t* opt)
 Int_t  AliPHOSLoader::LoadTracks(Option_t* opt)
 {
  //Loads Tracks: Open File, Reads Tree and posts, Read Data and Posts
- if (GetDebug()) Info("LoadTracks","opt = %s",opt);
+  AliDebug(1, Form("opt = %s",opt));
  Int_t res;
  res = AliLoader::LoadTracks(opt);
  if (res)
    {//oops, error
-      Error("LoadTracks","AliLoader::LoadTracks returned error");
+      AliError("returned error");
       return res;
    }  
  return ReadTracks();
@@ -280,90 +298,93 @@ Int_t AliPHOSLoader::LoadRecParticles(Option_t* opt)
   res = AliLoader::LoadRecParticles(opt);
   if (res)
    {//oops, error
-     Error("LoadRecParticles","AliLoader::LoadRecParticles returned error");
+     AliError("returned error");
      return res;
    }
   return ReadRecParticles();
 }
 
 //____________________________________________________________________________ 
-
-Int_t AliPHOSLoader::PostHits()
+//PostHits etc. PostXXX must be const - not to hide virtual functions
+//from base class AliLoader, but they call non-constant functions ReadXXX
+//so I have to const_cast this pointer
+Int_t AliPHOSLoader::PostHits()const
 {
   // -------------- Hits -------------------------------------------
   Int_t reval = AliLoader::PostHits();
   if (reval)
    {
-     Error("PostHits","AliLoader::  returned error");
+     AliError("returned error");
      return reval;
    }
-  return ReadHits();
+   
+  return const_cast<AliPHOSLoader *>(this)->ReadHits();
 }
 //____________________________________________________________________________ 
 
-Int_t AliPHOSLoader::PostSDigits()
+Int_t AliPHOSLoader::PostSDigits()const
 {
   // -------------- SDigits -------------------------------------------
   Int_t reval = AliLoader::PostSDigits();
   if (reval)
    {
-     Error("PostSDigits","AliLoader::PostSDigits  returned error");
+     AliError("returned error");
      return reval;
    }
-  return ReadSDigits();
+  return const_cast<AliPHOSLoader *>(this)->ReadSDigits();
 }
 //____________________________________________________________________________ 
 
-Int_t AliPHOSLoader::PostDigits()
+Int_t AliPHOSLoader::PostDigits()const
 {
   // -------------- Digits -------------------------------------------
   Int_t reval = AliLoader::PostDigits();
   if (reval)
    {
-     Error("PostDigits","AliLoader::PostDigits  returned error");
+     AliError("returned error");
      return reval;
    }
-  return ReadDigits();
+  return const_cast<AliPHOSLoader *>(this)->ReadDigits();
 }
 //____________________________________________________________________________ 
 
-Int_t AliPHOSLoader::PostRecPoints()
+Int_t AliPHOSLoader::PostRecPoints()const
 {
   // -------------- RecPoints -------------------------------------------
   Int_t reval = AliLoader::PostRecPoints();
   if (reval)
    {
-     Error("PostRecPoints","AliLoader::PostRecPoints  returned error");
+     AliError("returned error");
      return reval;
    }
-  return ReadRecPoints();
+  return const_cast<AliPHOSLoader *>(this)->ReadRecPoints();
 }
 
 //____________________________________________________________________________ 
 
-Int_t AliPHOSLoader::PostRecParticles()
+Int_t AliPHOSLoader::PostRecParticles()const
 {
   // -------------- RecParticles -------------------------------------------
   Int_t reval = AliLoader::PostRecParticles();
   if (reval)
    {
-     Error("PostRecParticles","AliLoader::PostRecParticles  returned error");
+     AliError("returned error");
      return reval;
    }
-  return ReadRecParticles();
+  return const_cast<AliPHOSLoader *>(this)->ReadRecParticles();
 }
 //____________________________________________________________________________ 
 
-Int_t AliPHOSLoader::PostTracks()
+Int_t AliPHOSLoader::PostTracks()const
 {
   // -------------- Tracks -------------------------------------------
   Int_t reval = AliLoader::PostTracks();
   if (reval)
    {
-     Error("PostTracks","AliLoader::PostTracks  returned error");
+     AliError("returned error");
      return reval;
    }
-  return ReadTracks();
+  return const_cast<AliPHOSLoader *>(this)->ReadTracks();
 }
 //____________________________________________________________________________ 
 
@@ -378,57 +399,47 @@ Int_t AliPHOSLoader::ReadHits()
 // Reads data from TreeH and stores it in TClonesArray that sits in DetectorDataFolder
 //
   TObject** hitref = HitsRef();
-  if(hitref == 0x0)
-   {
-     MakeHitsArray();
-     hitref = HitsRef();
-   }
+  if(hitref == 0x0) {
+    MakeHitsArray();
+    hitref = HitsRef();
+  }
 
-  TClonesArray* hits = dynamic_cast<TClonesArray*>(*hitref);
+  TClonesArray* hits = static_cast<TClonesArray*>(*hitref);
 
   TTree* treeh = TreeH();
   
-  if(treeh == 0)
-   {
-    Error("ReadHits"," Cannot read TreeH from folder");
+  if(treeh == 0) {
+    AliError("Cannot read TreeH from folder");
     return 1;
   }
   
   TBranch * hitsbranch = treeh->GetBranch(fDetectorName);
-  if (hitsbranch == 0) 
-   {
-    Error("ReadHits"," Cannot find branch PHOS"); 
+  if (hitsbranch == 0) {
+    AliError("Cannot find branch PHOS"); 
     return 1;
   }
+
+  AliDebug(1, "Reading Hits");
   
-  if (GetDebug()) Info("ReadHits","Reading Hits");
-  
-  if (hitsbranch->GetEntries() > 1)
-   {
-    TClonesArray * tempo =  new TClonesArray("AliPHOSHit",1000);
+  if (hitsbranch->GetEntries() > 1) {
 
-    hitsbranch->SetAddress(&tempo);
+    hitsbranch->SetAddress(&fTmpHits);
     Int_t index = 0 ; 
-    Int_t i = 0 ;
-    for (i = 0 ; i < hitsbranch->GetEntries(); i++) 
-     {
+    for (Int_t i = 0 ; i < hitsbranch->GetEntries(); i++) {
       hitsbranch->GetEntry(i) ;
-      Int_t j = 0 ;
-      for ( j = 0 ; j < tempo->GetEntries() ; j++) 
-       {
-         AliPHOSHit* hit = (AliPHOSHit*)tempo->At(j); 
-         new((*hits)[index]) AliPHOSHit( *hit ) ;
-         index++ ; 
-       }
-     }
-    delete tempo;
-   }
-  else 
-   {
+      for (Int_t j = 0 ; j < fTmpHits->GetEntriesFast() ; j++) {
+       AliPHOSHit* hit = (AliPHOSHit*)fTmpHits->At(j); 
+       new((*hits)[index]) AliPHOSHit( *hit ) ;
+       index++ ; 
+      }
+    }
+    fTmpHits->Clear();
+  }
+  else {
     hitsbranch->SetAddress(hitref);
     hitsbranch->GetEntry(0) ;
-   }
-
+  }
+  
   return 0;
 }
 //____________________________________________________________________________ 
@@ -451,18 +462,18 @@ Int_t AliPHOSLoader::ReadSDigits()
   if(treeS==0)
    {
      //May happen if file is truncated or new in LoadSDigits
-     //Error("ReadSDigits","There is no SDigit Tree");
+     //AliError("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 PHOS"); 
+    //AliError("Cannot find branch PHOS"); 
     return 0;
   }
     
-  branch->SetAddress(SDigitsRef());
+  branch->SetAddress(sdref);
   branch->GetEntry(0);
   return 0;
 }
@@ -487,14 +498,14 @@ Int_t AliPHOSLoader::ReadDigits()
   if(treeD==0)
    {
      //May happen if file is truncated or new in LoadSDigits
-     //Error("ReadDigits","There is no Digit Tree");
+     //AliError("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()); 
+    //AliError("Cannot find branch ",fDetectorName.Data()); 
     return 0;
    }
   
@@ -513,7 +524,7 @@ void AliPHOSLoader::Track(Int_t itrack)
    {
      if (LoadHits())
       {
-        Error("Track","Can not load hits.");
+        AliError("Can not load hits.");
         return;
       } 
    }
@@ -530,32 +541,6 @@ void AliPHOSLoader::Track(Int_t itrack)
   hitsbranch->GetEntry(itrack);
 
 }
-//____________________________________________________________________________ 
-void AliPHOSLoader::ReadTreeQA()
-{
-  // Read the digit tree gAlice->TreeQA()
-  // so far only PHOS knows about this Tree  
-
-  if(PHOS()->TreeQA()== 0){
-    cerr <<   "ERROR: AliPHOSLoader::ReadTreeQA: can not read TreeQA " << endl ;
-    return ;
-  }
-  
-  TBranch * qabranch = PHOS()->TreeQA()->GetBranch("PHOS");
-  if (!qabranch) { 
-    if (fDebug)
-      cout << "WARNING: AliPHOSLoader::ReadTreeQA -> Cannot find QA Alarms for PHOS" << endl ;
-    return ; 
-  }   
-  
-//  if(!Alarms()) PostQA();
-
-  qabranch->SetAddress(AlarmsRef()) ;
-
-  qabranch->GetEntry(0) ;
-  
-}
-
 
 //____________________________________________________________________________ 
 Int_t AliPHOSLoader::ReadRecPoints()
@@ -581,7 +566,8 @@ Int_t AliPHOSLoader::ReadRecPoints()
 
   if (emcbranch == 0x0)
    {
-     Error("ReadRecPoints","Can not get branch with EMC Rec. Points named %s",fgkEmcRecPointsBranchName.Data());
+     AliError(Form("Can not get branch with EMC Rec. Points named %s",
+                  fgkEmcRecPointsBranchName.Data()));
      retval = 1;
    }
   else
@@ -592,7 +578,8 @@ Int_t AliPHOSLoader::ReadRecPoints()
   TBranch * cpvbranch = treeR->GetBranch(fgkCpvRecPointsBranchName);
   if (cpvbranch == 0x0)
    {
-     Error("ReadRecPoints","Can not get branch with CPV Rec. Points named %s",fgkCpvRecPointsBranchName.Data());
+     AliError(Form("Can not get branch with CPV Rec. Points named %s",
+                  fgkCpvRecPointsBranchName.Data()));
      retval = 2;
    }
   else
@@ -602,13 +589,17 @@ Int_t AliPHOSLoader::ReadRecPoints()
    }
 
   Int_t ii ; 
-  Int_t maxemc = emca->GetEntries() ; 
-  for ( ii= 0 ; ii < maxemc ; ii++ ) 
-    EmcRecPoints()->Add(emca->At(ii)) ;
-  Int_t maxcpv = cpva->GetEntries() ;
-  for ( ii= 0 ; ii < maxcpv ; ii++ )
-    CpvRecPoints()->Add(cpva->At(ii)) ; 
+  if (emca != 0) {
+    Int_t maxemc = emca->GetEntries() ; 
+    for ( ii= 0 ; ii < maxemc ; ii++ ) 
+      EmcRecPoints()->Add(emca->At(ii)) ;
+  }
+
+  if (cpva != 0) {
+    Int_t maxcpv = cpva->GetEntries() ;
+    for ( ii= 0 ; ii < maxcpv ; ii++ )
+      CpvRecPoints()->Add(cpva->At(ii)) ; 
+  }
 
   return retval;
 }
@@ -631,14 +622,17 @@ Int_t AliPHOSLoader::ReadTracks()
    {
      //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");
+     //AliError("There is no Tree with Tracks");
      return 0;
    }
   
   TBranch * branch = treeT->GetBranch(fgkTrackSegmentsBranchName);
+//   AliInfo(Form("Branch named %s is opened: 0x%z",
+//               fgkTrackSegmentsBranchName.Data(),branch));
   if (branch == 0) 
    {//easy, maybe just a new tree
-    Error("ReadTracks"," Cannot find branch named %s",fgkTrackSegmentsBranchName.Data());
+    AliError(Form("Cannot find branch named %s",
+                 fgkTrackSegmentsBranchName.Data()));
     return 0;
   }
 
@@ -669,14 +663,15 @@ Int_t AliPHOSLoader::ReadRecParticles()
      //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");
+     //     AliError("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()); 
+    AliError(Form("Cannot find branch %s",
+                 fgkRecParticlesBranchName.Data())); 
     return 0;
   }
 
@@ -687,29 +682,16 @@ Int_t AliPHOSLoader::ReadRecParticles()
 }
 
 
-AliPHOSGeometry* AliPHOSLoader::GetPHOSGeometry()
-{
-  //returns PHOS geometry from gAlice 
-  //static Method used by some classes where it is not convienient to pass eventfoldername
-  if (gAlice == 0x0)
-    return 0x0;
-  AliPHOS* phos=dynamic_cast<AliPHOS*>(gAlice->GetDetector("PHOS"));
-  if (phos == 0x0)
-    return 0x0;
-  return phos->GetGeometry();
-}
 /***************************************************************************************/
 
 AliPHOSLoader* AliPHOSLoader::GetPHOSLoader(const  char* eventfoldername)
 {
   // Return PHOS loader
   AliRunLoader* rn  = AliRunLoader::GetRunLoader(eventfoldername);
-  if (rn == 0x0)
-   {
-     cerr<<"Error: <AliPHOSLoader::GetPHOSLoader>: "
-         << "Can not find Run Loader in folder "<<eventfoldername<<endl;
-     return 0x0;
-   }
+  if (rn == 0x0) {
+    printf("Can not find Run Loader in folder %s", eventfoldername);
+    return 0x0 ; 
+  }
   return dynamic_cast<AliPHOSLoader*>(rn->GetLoader("PHOSLoader"));
 }
 /***************************************************************************************/
@@ -767,11 +749,13 @@ Bool_t AliPHOSLoader::BranchExists(const TString& recName)
     TString branchName(branch->GetName() ) ; 
     TString branchTitle(branch->GetTitle() ) ;  
     if ( branchName.BeginsWith(dataname) && branchTitle.BeginsWith(fBranchTitle) ){  
-      Warning("BranchExists","branch %s  with title  %s ",dataname.Data(),fBranchTitle.Data());
+      AliWarning(Form("branch %s  with title  %s ",
+                     dataname.Data(),fBranchTitle.Data()));
       return kTRUE ;
     }
     if ( branchName.BeginsWith(zername) &&  branchTitle.BeginsWith(titleName) ){
-      Warning("BranchExists","branch AliPHOS... with title  %s ",branch->GetTitle());
+      AliWarning(Form("branch AliPHOS... with title  %s ",
+                     branch->GetTitle()));
       return kTRUE ; 
     }
   }
@@ -786,55 +770,57 @@ void AliPHOSLoader::SetBranchTitle(const TString& btitle)
   fBranchTitle = btitle;
   ReloadAll();
  }
 //____________________________________________________________________________ 
-
-void AliPHOSLoader::CleanHits()
+//Again, must be const not to hide virtual functions from AliLoader
+//but there are calls to non-const functions, so I have to const_cast this pointer
+void AliPHOSLoader::CleanHits()const
 {
   // Clean Hits array
   AliLoader::CleanHits();
   //Clear an array 
-  TClonesArray* hits = Hits();
+  TClonesArray* hits = const_cast<AliPHOSLoader *>(this)->Hits();
   if (hits) hits->Clear();
 }
 //____________________________________________________________________________ 
 
-void AliPHOSLoader::CleanSDigits()
+void AliPHOSLoader::CleanSDigits()const
 {
   // Clean SDigits array
   AliLoader::CleanSDigits();
-  TClonesArray* sdigits = SDigits();
+  TClonesArray* sdigits = const_cast<AliPHOSLoader *>(this)->SDigits();
   if (sdigits) sdigits->Clear();
   
 }
 //____________________________________________________________________________ 
 
-void AliPHOSLoader::CleanDigits()
+void AliPHOSLoader::CleanDigits()const
 {
   // Clean Digits array
   AliLoader::CleanDigits();
-  TClonesArray* digits = Digits();
+  TClonesArray* digits = const_cast<AliPHOSLoader *>(this)->Digits();
   if (digits) digits->Clear();
 }
 //____________________________________________________________________________ 
 
-void AliPHOSLoader::CleanRecPoints()
+void AliPHOSLoader::CleanRecPoints()const
 {
   // Clean RecPoints array
   AliLoader::CleanRecPoints();
-  TObjArray* recpoints = EmcRecPoints();
+  TObjArray* recpoints = const_cast<AliPHOSLoader *>(this)->EmcRecPoints();
   if (recpoints) recpoints->Clear();
-  recpoints = CpvRecPoints();
+  recpoints = const_cast<AliPHOSLoader *>(this)->CpvRecPoints();
   if (recpoints) recpoints->Clear();
 }
 //____________________________________________________________________________ 
 
-void AliPHOSLoader::CleanTracks()
+void AliPHOSLoader::CleanTracks()const
 {
   //Cleans Tracks stuff
   AliLoader::CleanTracks();//tree
   
   //and clear the array
-  TClonesArray* tracks = TrackSegments();
+  TClonesArray* tracks = const_cast<AliPHOSLoader *>(this)->TrackSegments();
   if (tracks) tracks->Clear();
 
 }
@@ -850,34 +836,6 @@ void AliPHOSLoader::CleanRecParticles()
  }
 //____________________________________________________________________________ 
 
-void AliPHOSLoader::ReadCalibrationDB(const char * database,const char * filename)
-{
-  // Read calibration data base from file
-  if(fcdb && (strcmp(database,fcdb->GetTitle())==0))
-    return ;
-
-  TFile * file = gROOT->GetFile(filename) ;
-  if(!file)
-    file = TFile::Open(filename);
-  if(!file){
-    Error ("ReadCalibrationDB", "Cannot open file %s", filename) ;
-    return ;
-  }
-  if(fcdb)
-    fcdb->Delete() ;
-  fcdb = dynamic_cast<AliPHOSCalibrationDB *>(file->Get("AliPHOSCalibrationDB")) ;
-  if(!fcdb)
-    Error ("ReadCalibrationDB", "No database %s in file %s", database, filename) ;
-}
-//____________________________________________________________________________ 
-
-// AliPHOSSDigitizer*  AliPHOSLoader::PHOSSDigitizer() 
-// { 
-// //return PHOS SDigitizer
-//  return  dynamic_cast<AliPHOSSDigitizer*>(SDigitizer()) ;
-// }
-
-//____________________________________________________________________________ 
 void AliPHOSLoader::MakeHitsArray()
 {
   // Add Hits array to the data folder
@@ -914,18 +872,18 @@ void AliPHOSLoader::MakeRecPointsArray()
   // Add RecPoints array to the data folder
   if ( EmcRecPoints() == 0x0)
    {
-    if (GetDebug()>9) Info("MakeRecPointsArray","Making array for EMC");
+     AliDebug(9, "Making array for EMC");
     TObjArray* emc = new TObjArray(100) ;
     emc->SetName(fgkEmcRecPointsName) ;
     GetDetectorDataFolder()->Add(emc);
    }
 
   if ( CpvRecPoints() == 0x0)
-   {
-    if (GetDebug()>9) Info("MakeRecPointsArray","Making array for CPV");
-    TObjArray* cpv = new TObjArray(100) ;
-    cpv->SetName(fgkCpvRecPointsName);
-    GetDetectorDataFolder()->Add(cpv);
+   { 
+     AliDebug(9, "Making array for CPV");
+     TObjArray* cpv = new TObjArray(100) ;
+     cpv->SetName(fgkCpvRecPointsName);
+     GetDetectorDataFolder()->Add(cpv);
    }
 }