Compatibility with ROOT trunk
[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveEMCALData.cxx
index e4e8439..ea40eaf 100644 (file)
@@ -1,40 +1,49 @@
-//*********************************************************************
-// - AliEVE implementation -
+//
 // Fill containers for visualisation of EMCAL data structures
-//    - read and store MC Hits
-//    - read and store digits from esds or runloader
+//    - read and store MC Hits    - read and store digits from esds or runloader
 //    - read and store clusters from esds or runloader 
 //
 // Author: Magali Estienne (magali.estienne@cern.ch)
 // June 30 2008
-//*********************************************************************
+//
+
+//#include <Riostream.h>
+//#include <vector>
 
-#include <TObject.h>
-#include <TEveUtil.h>
 #include <TTree.h>
 #include <TBranch.h>
 #include <TObjArray.h>
 #include <TRefArray.h>
 #include <TClonesArray.h>
-#include <TEvePointSet.h>
+#include <TMath.h>
+#include <TLorentzVector.h>
 
-#include "AliRun.h"
 #include "AliRunLoader.h"
+#include "AliEMCAL.h"
 #include "AliEMCALLoader.h"
-#include "AliESDEvent.h"
 #include "AliESDVertex.h"
-#include "AliEMCAL.h"
-#include "AliEMCALGeometry.h"
 #include "AliEMCALHit.h"
 #include "AliEMCALDigit.h"
+
 #include "AliEMCALRecPoint.h"
 #include "AliESDCaloCells.h"
 #include "AliESDCaloCluster.h"
 
 #include "AliEveEMCALData.h"
-#include "AliEveEMCALSModule.h"
 #include "AliEveEMCALSModuleData.h"
 
+class Riostream;
+class TObject;
+class TEveUtil;
+class TEvePointSet;
+class AliRun;
+class AliESDEvent;
+class AliEMCAL;
+class AliEMCALGeometry;
+class AliEveEMCALSModule;
+
+using std::cout;
+using std::endl;
 ClassImp(AliEveEMCALData)
 
 //______________________________________________________________________________
@@ -116,7 +125,7 @@ AliEveEMCALData::~AliEveEMCALData()
 
   DeleteSuperModules();
   delete fTree;
-  delete fEmcal;
+  // delete fEmcal; // deleted by run-loader
   delete fGeom;
   delete fNode;
   delete fHMatrix;
@@ -124,12 +133,6 @@ AliEveEMCALData::~AliEveEMCALData()
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::Reset()
-{
-
-}
-
-//______________________________________________________________________________
 AliEveEMCALData::AliEveEMCALData(const AliEveEMCALData &edata) :
   TObject(edata),
   TEveRefCnt(edata),
@@ -172,34 +175,44 @@ AliEveEMCALData& AliEveEMCALData::operator=(const AliEveEMCALData &edata)
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::SetTree(TTree* tree)
+void AliEveEMCALData::SetTree(TTree* const tree)
 {
-
-  // Set digit-tree to be used for digit retrieval. Data is loaded on
-  // demand.
+  //
+  // Set digit-tree to be used for digit retrieval. 
+  // Data is loaded on demand.
+  // 
 
   fTree = tree;
 
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::SetESD(AliESDEvent* esd)
+void AliEveEMCALData::SetESD(AliESDEvent* const esd)
 {
+  //
+  // Set esd
+  //
+
   fESD = esd;
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::SetNode(TGeoNode* node)
+void AliEveEMCALData::SetNode(TGeoNode* const node)
 {
+  //
+  // Set node
+  //
+
   fNode = node;
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::InitEMCALGeom(AliRunLoader* rl)
+void AliEveEMCALData::InitEMCALGeom(AliRunLoader* const rl)
 {
-//   // Handle an individual point selection from GL.
+  //
+  // Set data members for EMCAL geometry
+  //
 
-//   fParent->SpawnEditor();
   fEmcal = (AliEMCAL*) rl->GetAliRun()->GetDetector("EMCAL");
   fGeom  = (AliEMCALGeometry*) fEmcal->GetGeometry();
 
@@ -208,13 +221,13 @@ void AliEveEMCALData::InitEMCALGeom(AliRunLoader* rl)
 //______________________________________________________________________________
 void AliEveEMCALData::GetGeomInfo(Int_t id, Int_t &iSupMod, Double_t& x, Double_t& y, Double_t& z)
 {
+  //
   // Get geometrical information from hit/digit/cluster absolute id
+  //
 
   Int_t iTower  =  0 ;
   Int_t iIphi   =  0 ;
   Int_t iIeta   =  0 ;
-  Int_t iphi    =  0 ;
-  Int_t ieta    =  0 ;
 
   //Geometry methods
   fGeom->GetCellIndex(id,iSupMod,iTower,iIphi,iIeta);
@@ -226,8 +239,10 @@ void AliEveEMCALData::GetGeomInfo(Int_t id, Int_t &iSupMod, Double_t& x, Double_
 //______________________________________________________________________________
 void  AliEveEMCALData::CreateAllSModules()
 {
-
+  //
   // Create all fNsm super modules
+  //
+
   for(Int_t sm = 0; sm < fNsm; sm++)
     CreateSModule(sm);
 
@@ -236,7 +251,10 @@ void  AliEveEMCALData::CreateAllSModules()
 //______________________________________________________________________________
 void  AliEveEMCALData::CreateSModule(Int_t sm)
 {
-  // Create super-module-data for sm if it does not exist already.
+  //
+  // Create super-module-data for SM if it does not exist already.
+  //
+
   if(fSM[sm] == 0) fSM[sm] = new AliEveEMCALSModuleData(sm,fGeom,fNode,fHMatrix);
   if(fSMfull[sm] == 0 && sm < 10) fSMfull[sm] = new AliEveEMCALSModuleData(sm,fGeom,fNode,fHMatrix);
   if(fSMhalf[sm-10] == 0 && sm > 10) fSMhalf[sm-10] = new AliEveEMCALSModuleData(sm,fGeom,fNode,fHMatrix);
@@ -245,7 +263,9 @@ void  AliEveEMCALData::CreateSModule(Int_t sm)
 //______________________________________________________________________________
 void AliEveEMCALData::DropAllSModules()
 {
+  //
   // Drop data of all existing sectors.
+  //
 
   for (Int_t sm = 0; sm < fNsm; sm++) {
     if (fSM[sm] != 0)
@@ -257,7 +277,7 @@ void AliEveEMCALData::DropAllSModules()
 void AliEveEMCALData::DeleteSuperModules()
 {
   //
-  // delete all super module data
+  // Delete all super module data
   //
 
   for (Int_t sm = 0; sm < fNsm; sm++)
@@ -281,11 +301,13 @@ void AliEveEMCALData::DeleteSuperModules()
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::LoadHits(TTree* t)
+void AliEveEMCALData::LoadHits(TTree* const t)
 {
+  //
+  // Get hit information from RunLoader
+  //
 
-  // With TTreeH
-
+  /*
   // These are global coordinates !
   char form[1000];
   const char *selection = "";
@@ -301,62 +323,86 @@ void AliEveEMCALData::LoadHits(TTree* t)
     delete fPoint;
     //    return 0;
   }
+  */
 
-
-//   TObjArray *harr=NULL;
-//   TBranch *hbranch=t->GetBranch("EMCAL");
-//   hbranch->SetAddress(&harr);
+  TObjArray *harr=NULL;
+  TBranch *hbranch=t->GetBranch("EMCAL");
+  hbranch->SetAddress(&harr);
   
-//   if(hbranch->GetEvent(0)) {
-//     for(Int_t ih = 0; ih < harr->GetEntriesFast(); ih++) {
-//       AliEMCALHit* hit =(AliEMCALHit*)harr->UncheckedAt(ih);
-//       if(hit != 0){
-//     cout << "Hit info " << hit->GetId() << " " << hit->GetEnergy() << endl;
-//     fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
-//       }
-//     }
-//   }
-//   //********************************
-//   // To be completed !!!
-//   //********************************
-
+  if(hbranch->GetEvent(0)) {
+    for(Int_t ih = 0; ih < harr->GetEntriesFast(); ih++) {
+      AliEMCALHit* hit =(AliEMCALHit*)harr->UncheckedAt(ih);
+      if(hit != 0){
+       if(fDebug>1) cout << "Hit info " << hit->GetId() << " " << hit->GetEnergy() << endl;
+       Int_t id = hit->GetId();
+       // These are local coordinates
+       Double_t xl = 0.; Double_t yl = 0.; Double_t zl = 0.;
+       // Get global coordinates
+       Double_t x = hit->X();
+       Double_t y = hit->Y();
+       Double_t z = hit->Z();
+       Double_t amp = hit->GetEnergy();
+       Int_t iSupMod = 0;
+       // Get SM Id
+       GetGeomInfo(id,iSupMod,xl,yl,zl);
+       fSM[iSupMod]->RegisterHit(id,iSupMod,amp,x,y,z);
+      }
+    }
+  }
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::LoadHitsFromEMCALLoader(AliEMCALLoader* emcl)
+void AliEveEMCALData::LoadHitsFromEMCALLoader(AliEMCALLoader* const emcl)
 {
+  //
+  // Get hit information from EMCAL Loader
+  //
 
-  // Need to know the local position in each sm
-
-  // With EMCALLoader
-  AliEMCALHit* hit;
+       AliEMCALHit* hit;
   
-  //Fill array of hits                                                                        
-  TClonesArray *hits = (TClonesArray*)emcl->Hits();
-
-  //Get hits from the list                                                                    
-  for(Int_t ihit = 0; ihit< hits->GetEntries();ihit++){
-    //cout<<">> idig "<<idig<<endl;                                                             
-    hit = static_cast<AliEMCALHit *>(hits->At(ihit)) ;
+       //Fill array of hits                                                                        
+       TClonesArray *hits = 0;//(TClonesArray*)emcl->Hits();
+       TTree *treeH = emcl->TreeH();   
+       if (treeH) {
+               Int_t nTrack = treeH->GetEntries();  // TreeH has array of hits for every primary
+               TBranch * branchH = treeH->GetBranch("EMCAL");
+               //if(fHits)fHits->Clear();
+               branchH->SetAddress(&hits);
+               for (Int_t iTrack = 0; iTrack < nTrack; iTrack++) {
+                       branchH->GetEntry(iTrack);
+                       
+                       //Get hits from the list                                                                    
+                       for(Int_t ihit = 0; ihit< hits->GetEntries();ihit++){
+
+                               hit = static_cast<AliEMCALHit *>(hits->At(ihit)) ;
     
-    if(hit != 0){
-      cout << "Hit info " << hit->GetId() << " " << hit->GetEnergy() << endl;
-    }
-  }
-  
-  //********************************
-  // To be completed !!!
-  //********************************
-
-
-
+                               if(hit != 0){
+                                       if(fDebug>1) cout << "Hit info " << hit->GetId() << " " << hit->GetEnergy() << endl;
+
+                                       Int_t id = hit->GetId();
+                                       // These are local coordinates
+                                       Double_t xl = 0.; Double_t yl = 0.; Double_t zl = 0.;
+                                       // Get global coordinates
+                                       Double_t x = hit->X();
+                                       Double_t y = hit->Y();
+                                       Double_t z = hit->Z();
+                                       Double_t amp = hit->GetEnergy();
+                                       Int_t iSupMod = 0;
+                                       // Get SM Id
+                                       GetGeomInfo(id,iSupMod,xl,yl,zl);
+                                       fSM[iSupMod]->RegisterHit(id,iSupMod,amp,x,y,z);
+                               }//hit exists
+                       }//hit loop
+                       hits->Clear();
+               }// track loop
+       }//treeH exists
 }
 
 //______________________________________________________________________________
 void AliEveEMCALData::LoadDigits(TTree *t)
 {
   //
-  // load digits from the TreeD
+  // Get digit information from RunLoader
   //
 
   TClonesArray *digits = 0;
@@ -367,7 +413,8 @@ void AliEveEMCALData::LoadDigits(TTree *t)
   cout << "nEnt: " << nEnt << endl;
   AliEMCALDigit * dig;
 
-  Float_t amp   = -1 ;
+  //  Double_t amp   = -1 ;
+  Double_t ampFlo   = -1 ;
   Int_t id      = -1 ;
   Int_t iSupMod =  0 ;
   Double_t x, y, z;
@@ -378,11 +425,19 @@ void AliEveEMCALData::LoadDigits(TTree *t)
       
       if(dig != 0) {
        id   = dig->GetId() ; //cell (digit) label
-       amp  = dig->GetAmp(); //amplitude in cell (digit)
-       
+       // adc
+       ampFlo  = dig->GetAmplitude(); //amplitude in cell (digit)
+       // GeV
+       //      amp = ampFlo*0.0153; // To be modified with correct OCDB conversion     
+
        GetGeomInfo(id,iSupMod,x,y,z);
 
-       fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
+//     // GeV
+//     fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
+// //  fSM[iSupMod]->SaveDigit(dig);
+// //  if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
+// //  if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,amp,x,y,z);
+       fSM[iSupMod]->RegisterDigit(id,iSupMod,ampFlo,x,y,z);
 //     fSM[iSupMod]->SaveDigit(dig);
 //     if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
 //     if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,amp,x,y,z);
@@ -396,11 +451,11 @@ void AliEveEMCALData::LoadDigits(TTree *t)
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::LoadDigitsFromEMCALLoader(AliEMCALLoader* emcl)
+void AliEveEMCALData::LoadDigitsFromEMCALLoader(AliEMCALLoader* const emcl)
 {
 
   //
-  // load digits from EMCAL Loader
+  // Get digit information from EMCAL Loader
   //
 
   AliEMCALDigit* dig;
@@ -410,7 +465,8 @@ void AliEveEMCALData::LoadDigitsFromEMCALLoader(AliEMCALLoader* emcl)
   
   //Get digits from the list  
   
-  Float_t amp   = -1 ;
+  //  Double_t amp   = -1 ;
+  Double_t ampFlo   = -1 ;
   Int_t id      = -1 ;
   Int_t iSupMod =  0 ;
   Double_t x, y, z;
@@ -420,13 +476,19 @@ void AliEveEMCALData::LoadDigitsFromEMCALLoader(AliEMCALLoader* emcl)
      dig = static_cast<AliEMCALDigit *>(digits->At(idig)) ;
 
      if(dig != 0){
-       if(fDebug>1) cout << "Digit info " << dig->GetId() << " " << dig->GetAmp() << endl;
+       if(fDebug>1) cout << "Digit info " << dig->GetId() << " " << dig->GetAmplitude() << endl;
        id   = dig->GetId() ; //cell (digit) label
-       amp  = dig->GetAmp(); //amplitude in cell (digit)
-       
+       // adc
+       ampFlo  = dig->GetAmplitude(); //amplitude in cell (digit)
+       // GeV
+       //       amp = ampFlo*0.0153.; // To be modified with correct OCDB conversion
+
        GetGeomInfo(id,iSupMod,x,y,z);
        
-       fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
+       //       // GeV
+       //       fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
+       // adc
+       fSM[iSupMod]->RegisterDigit(id,iSupMod,ampFlo,x,y,z);
      }
       else {
        cout << "Digit object empty" << endl;
@@ -445,8 +507,6 @@ void AliEveEMCALData::LoadDigitsFromESD()
   
   AliESDCaloCells &cells= *(fESD->GetEMCALCells());
   Int_t ncell = cells.GetNumberOfCells() ;  
-  Int_t type = cells.GetType();
-  Float_t pos[3] ; 
   Int_t iSupMod =  0 ;
   Double_t x, y, z;
 
@@ -454,20 +514,32 @@ void AliEveEMCALData::LoadDigitsFromESD()
   for (Int_t icell=  0; icell <  ncell; icell++) 
     {
       Int_t id   = cells.GetCellNumber(icell);
-      Float_t amp  = cells.GetAmplitude(icell);
+      // adc
+      Double_t ampFlo  = cells.GetAmplitude(icell);
+      // GeV
+      //      Double_t amp = ampFlo*0.0153; // To be modified with correct OCDB conversion
 
       GetGeomInfo(id,iSupMod,x,y,z);
 
-      fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
-      if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
-      if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,amp,x,y,z);
+//       // GeV
+//       fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
+//       if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
+//       if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,amp,x,y,z);
+      // adc
+      fSM[iSupMod]->RegisterDigit(id,iSupMod,ampFlo,x,y,z);
+      if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,ampFlo,x,y,z);
+      if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,ampFlo,x,y,z);
 
     } // end loop cells
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::LoadRecPoints(TTree* t)
+void AliEveEMCALData::LoadRecPoints(TTree* const t)
 {
+  //
+  // Get rec point information from RunLoader
+  //
+
   //*************************************************
   // To be improved !!!!!
   // Size and shape of cluster to be implemented
@@ -483,13 +555,19 @@ void AliEveEMCALData::LoadRecPoints(TTree* t)
     for(Int_t ic = 0; ic < carr->GetEntriesFast(); ic++) {
       AliEMCALRecPoint* rp =(AliEMCALRecPoint*)carr->UncheckedAt(ic);
       if(rp){
-       cout << "RecPoint info " << rp->GetAbsId() << " " << rp->GetEnergy() << endl;
+       if(fDebug>1) cout << "RecPoint info " << rp->GetAbsId() << " " << rp->GetEnergy() << endl;
        Int_t iSupMod = rp->GetSuperModuleNumber();
-       Float_t amp = rp->GetEnergy();
+       // GeV
+       Double_t amp = (Double_t)rp->GetEnergy();
+       // adc
+       Double_t ampFlo = amp/0.0153; // To be modified with correct OCDB conversion
        TVector3 lpos;
        rp->GetLocalPosition(lpos);
 
-       fSM[iSupMod]->RegisterCluster(iSupMod,amp,lpos[0],lpos[1],lpos[2]);
+//     // GeV
+//     fSM[iSupMod]->RegisterCluster(iSupMod,amp,lpos[0],lpos[1],lpos[2]);
+        // adc
+       fSM[iSupMod]->RegisterCluster(iSupMod,ampFlo,lpos[0],lpos[1],lpos[2]);
       }
     }
   }
@@ -497,8 +575,12 @@ void AliEveEMCALData::LoadRecPoints(TTree* t)
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::LoadRecPointsFromEMCALLoader(AliEMCALLoader* emcl)
+void AliEveEMCALData::LoadRecPointsFromEMCALLoader(AliEMCALLoader* const emcl)
 {
+  //
+  // Get rec point information from EMCAL Loader
+  //
+
   //*************************************************
   // To be improved !!!!!
   // Size and shape of cluster to be implemented
@@ -517,13 +599,17 @@ void AliEveEMCALData::LoadRecPointsFromEMCALLoader(AliEMCALLoader* emcl)
     rp = static_cast<AliEMCALRecPoint *>(clusters->At(iclu)) ;
     
     if(rp){
-       cout << "RecPoint info " << rp->GetAbsId() << " " << rp->GetEnergy() << endl;
+       if(fDebug>1) cout << "RecPoint info " << rp->GetAbsId() << " " << rp->GetEnergy() << endl;
        Int_t iSupMod = rp->GetSuperModuleNumber();
-       Float_t amp = rp->GetEnergy();
+       Double_t amp = (Double_t)rp->GetEnergy();
+       Double_t ampFlo = amp/0.0153; // To be modified with correct OCDB conversion
        TVector3 lpos;
        rp->GetLocalPosition(lpos);
        
-       fSM[iSupMod]->RegisterCluster(iSupMod,amp,lpos[0],lpos[1],lpos[2]);
+//        // GeV
+//        fSM[iSupMod]->RegisterCluster(iSupMod,amp,lpos[0],lpos[1],lpos[2]);
+       // adc
+       fSM[iSupMod]->RegisterCluster(iSupMod,ampFlo,lpos[0],lpos[1],lpos[2]);
     }
   }
   
@@ -532,21 +618,23 @@ void AliEveEMCALData::LoadRecPointsFromEMCALLoader(AliEMCALLoader* emcl)
 //______________________________________________________________________________
 void AliEveEMCALData::LoadRecPointsFromESD()
 {
-  Int_t iSupMod =  0 ;
+  //
+  // Get cluster information from esd
+  //
+
+ Int_t iSupMod =  0 ;
   Double_t x, y, z;
   Int_t iSM =  0 ;
   Int_t iT  =  0 ;
   Int_t iIp   =  0 ;
   Int_t iIe   =  0 ;
-  Int_t ip    =  0 ;
-  Int_t ie    =  0 ;
   Double_t xd, yd, zd;
   Float_t pos[3] ; 
   
   // Get reconstructed vertex position
   AliESDVertex* primVertex =(AliESDVertex*) fESD->GetVertex();
-  Double_t vertex_position[3] ; 
-  primVertex->GetXYZ(vertex_position) ; 
+  Double_t vertexPosition[3] ; 
+  primVertex->GetXYZ(vertexPosition) ; 
 
   //Get the CaloClusters
   //select EMCAL clusters only 
@@ -555,37 +643,36 @@ void AliEveEMCALData::LoadRecPointsFromESD()
   Int_t nclus = caloClusters->GetEntries();
   cout << "nclus: " << nclus << endl; 
   
-  if(!caloClusters) return;
-
   for (Int_t iclus =  0; iclus <  nclus; iclus++) 
     {
       AliESDCaloCluster *clus = (AliESDCaloCluster *) caloClusters->At(iclus) ; 
       //Get the cluster info
       
-      Float_t energy = clus->E() ;
-      Int_t   eneInt = (Int_t) energy*500+0.5;
-      Float_t disp   = clus->GetClusterDisp() ;
-      Int_t   iprim  = clus->GetLabel();
+      Double_t energy = clus->E() ;
+      // adc
+      //      Int_t   eneInt = (Int_t)energy*500+0.5;
+      Double_t eneInt = energy/0.0153; // To be modified with correct OCDB conversion
+      Double_t disp   = clus->GetDispersion() ;
       
       clus->GetPosition(pos) ; // Global position
       TVector3 vpos(pos[0],pos[1],pos[2]) ;
       TLorentzVector p4 ;
       TVector3 p3;
-      clus->GetMomentum(p4,vertex_position);
+      clus->GetMomentum(p4,vertexPosition);
       p3.SetXYZ(p4[0],p4[1],p4[2]);
-      Float_t eta = p3.Eta();
-      Float_t phi = ( (p3.Phi()) < 0) ? (p3.Phi()) + 2. * TMath::Pi() : (p3.Phi());
+      Double_t eta = p3.Eta();
+      Double_t phi = ( (p3.Phi()) < 0) ? (p3.Phi()) + 2. * TMath::Pi() : (p3.Phi());
       
       Int_t mult = clus->GetNCells() ;
-      if(fDebug>1) {
-       cout << "In cluster: " << iclus << ", ncells: " << mult << ", energy: " << 
-         eneInt << ", disp: " << disp << endl;
+      if(fDebug>2) {
+       cout << "In cluster: " << iclus << ", ncells: " << mult << ", energy : " << energy << 
+         ", disp: " << disp << endl;
        cout << "Cluster " << iclus << ", eta: " << eta << ", phi: " << phi << endl;
       }
 
       Int_t clusId = 0;
       fGeom->GetAbsCellIdFromEtaPhi(eta,phi,clusId);
-      if(fDebug>1) {
+      if(fDebug>2) {
        cout << "Abs Cluster Id: " << clusId << ", xc: " << pos[0] << 
          ", yc: " << pos[1] << ", zc: " << pos[2] << endl;
       }
@@ -593,9 +680,11 @@ void AliEveEMCALData::LoadRecPointsFromESD()
       GetGeomInfo(clusId,iSupMod,x,y,z);
       
       //******** Not used yet but will come  ********
+      // AliESDCaloCells &cells= *(fESD->GetEMCALCells());
       Int_t     digMult = clus->GetNCells() ;
       UShort_t *digID   = clus->GetCellsAbsId() ;
       for(Int_t i=0; i<digMult; i++){
+       // Float_t  digitAmp     = cells.GetCellAmplitude(digID[i]) ;
        fGeom->RelPosCellInSModule(digID[i], xd, yd, zd);
        //Geometry methods
        fGeom->GetCellIndex(digID[i],iSM,iT,iIp,iIe);
@@ -603,8 +692,10 @@ void AliEveEMCALData::LoadRecPointsFromESD()
 
       } // end digit loop
       //*********************************************
-
-      fSM[iSupMod]->RegisterCluster(iSM,energy,x,y,z);
+      //      // GeV
+      //      fSM[iSupMod]->RegisterCluster(iSM,energy,x,y,z);
+      // adc
+      fSM[iSupMod]->RegisterCluster(iSM,eneInt,x,y,z);
 
     } // end cluster loop
 }
@@ -613,7 +704,7 @@ void AliEveEMCALData::LoadRecPointsFromESD()
 AliEveEMCALSModuleData* AliEveEMCALData::GetSModuleData(Int_t sm)
 {
   //
-  // return super module data
+  // Return super module data
   //
 
   if (sm < 0 || sm > fNsm) 
@@ -626,8 +717,12 @@ AliEveEMCALSModuleData* AliEveEMCALData::GetSModuleData(Int_t sm)
 }
 
 //______________________________________________________________________________
-void AliEveEMCALData::LoadRaw()
+void AliEveEMCALData::LoadRaw() const
 {
+  //
+  // Get raw information
+  //
 
+  // To be implemented !
 }