EVE/EveDet/AliEveEMCALData.cxx

   1 //
   2 // Fill containers for visualisation of EMCAL data structures
   3 //    - read and store MC Hits    - read and store digits from esds or runloader
   4 //    - read and store clusters from esds or runloader
   5 //
   6 // Author: Magali Estienne (magali.estienne@cern.ch)
   7 // June 30 2008
   8 //
   9
  10 //#include <Riostream.h>
  11 //#include <vector>
  12
  13 #include <TTree.h>
  14 #include <TBranch.h>
  15 #include <TObjArray.h>
  16 #include <TRefArray.h>
  17 #include <TClonesArray.h>
  18 #include <TMath.h>
  19 #include <TLorentzVector.h>
  20
  21 #include "AliRunLoader.h"
  22 #include "AliEMCAL.h"
  23 #include "AliEMCALLoader.h"
  24 #include "AliESDVertex.h"
  25 #include "AliEMCALHit.h"
  26 #include "AliEMCALDigit.h"
  27
  28 #include "AliEMCALRecPoint.h"
  29 #include "AliESDCaloCells.h"
  30 #include "AliESDCaloCluster.h"
  31
  32 #include "AliEveEMCALData.h"
  33 #include "AliEveEMCALSModuleData.h"
  34
  35 class Riostream;
  36 class TObject;
  37 class TEveUtil;
  38 class TEvePointSet;
  39 class AliRun;
  40 class AliESDEvent;
  41 class AliEMCAL;
  42 class AliEMCALGeometry;
  43 class AliEveEMCALSModule;
  44
  45 using std::cout;
  46 using std::endl;
  47 ClassImp(AliEveEMCALData)
  48
  49 //______________________________________________________________________________
  50 AliEveEMCALData::AliEveEMCALData():
  51   TObject(),
  52   TEveRefCnt(),
  53   fEmcal(0x0),
  54   fGeom(0x0),
  55   fNode(0x0),
  56   fHMatrix(0),
  57   fTree(0x0),
  58   fESD(0x0),
  59   fNsm(12),
  60   fNsmfull(10),
  61   fNsmhalf(2),
  62   fSM(12),
  63   fSMfull(10),
  64   fSMhalf(2),
  65   fRunLoader(0),
  66   fDebug(0),
  67   fPoint(0)
  68 {
  69
  70   //
  71   // Constructor
  72   //
  73   //   for(Int_t i=0; i<12; i++)
  74   //     fSM[i] = 0x0;
  75   //   for(Int_t i=0; i<10; i++)
  76   //     fSMfull[i] = 0x0;
  77   //   fSMhalf[0] = fSMhalf[1] = 0x0;
  78   //  InitEMCALGeom();
  79   CreateAllSModules();
  80
  81
  82 }
  83
  84 //______________________________________________________________________________
  85 AliEveEMCALData::AliEveEMCALData(AliRunLoader* rl, TGeoNode* node, TGeoHMatrix* m):
  86   TObject(),
  87   TEveRefCnt(),
  88   fEmcal(0x0),
  89   fGeom(0x0),
  90   fNode(node),
  91   fHMatrix(m),
  92   fTree(0x0),
  93   fESD(0x0),
  94   fNsm(12),
  95   fNsmfull(10),
  96   fNsmhalf(2),
  97   fSM(12),
  98   fSMfull(10),
  99   fSMhalf(2),
 100   fRunLoader(rl),
 101   fDebug(0),
 102   fPoint(0)
 103 {
 104
 105   //
 106   // Constructor
 107   //
 108 //   for(Int_t i=0; i<12; i++)
 109 //     fSM[i] = 0x0;
 110 //   for(Int_t i=0; i<10; i++)
 111 //     fSMfull[i] = 0x0;
 112 //   fSMhalf[0] = fSMhalf[1] = 0x0;
 113   InitEMCALGeom(rl);
 114   CreateAllSModules();
 115
 116
 117 }
 118
 119 //______________________________________________________________________________
 120 AliEveEMCALData::~AliEveEMCALData()
 121 {
 122   //
 123   // Destructor
 124   //
 125
 126   DeleteSuperModules();
 127   delete fTree;
 128   // delete fEmcal; // deleted by run-loader
 129   delete fGeom;
 130   delete fNode;
 131   delete fHMatrix;
 132   delete fPoint;
 133 }
 134
 135 //______________________________________________________________________________
 136 AliEveEMCALData::AliEveEMCALData(const AliEveEMCALData &edata) :
 137   TObject(edata),
 138   TEveRefCnt(edata),
 139   fEmcal(edata.fEmcal),
 140   fGeom(edata.fGeom),
 141   fNode(edata.fNode),
 142   fHMatrix(edata.fHMatrix),
 143   fTree(edata.fTree),
 144   fESD(edata.fESD),
 145   fNsm(edata.fNsm),
 146   fNsmfull(edata.fNsmfull),
 147   fNsmhalf(edata.fNsmhalf),
 148   fSM(edata.fSM),
 149   fSMfull(edata.fSMfull),
 150   fSMhalf(edata.fSMhalf),
 151   fRunLoader(edata.fRunLoader),
 152   fDebug(edata.fDebug),
 153   fPoint(edata.fPoint)
 154 {
 155   //
 156   // Copy constructor
 157   //
 158   InitEMCALGeom(edata.fRunLoader);
 159   CreateAllSModules();
 160 }
 161
 162 //______________________________________________________________________________
 163 AliEveEMCALData& AliEveEMCALData::operator=(const AliEveEMCALData &edata)
 164 {
 165   //
 166   // Assignment operator
 167   //
 168
 169   if (this != &edata) {
 170
 171   }
 172
 173   return *this;
 174
 175 }
 176
 177 //______________________________________________________________________________
 178 void AliEveEMCALData::SetTree(TTree* const tree)
 179 {
 180   //
 181   // Set digit-tree to be used for digit retrieval.
 182   // Data is loaded on demand.
 183   //
 184
 185   fTree = tree;
 186
 187 }
 188
 189 //______________________________________________________________________________
 190 void AliEveEMCALData::SetESD(AliESDEvent* const esd)
 191 {
 192   //
 193   // Set esd
 194   //
 195
 196   fESD = esd;
 197 }
 198
 199 //______________________________________________________________________________
 200 void AliEveEMCALData::SetNode(TGeoNode* const node)
 201 {
 202   //
 203   // Set node
 204   //
 205
 206   fNode = node;
 207 }
 208
 209 //______________________________________________________________________________
 210 void AliEveEMCALData::InitEMCALGeom(AliRunLoader* const rl)
 211 {
 212   //
 213   // Set data members for EMCAL geometry
 214   //
 215
 216   fEmcal = (AliEMCAL*) rl->GetAliRun()->GetDetector("EMCAL");
 217   fGeom  = (AliEMCALGeometry*) fEmcal->GetGeometry();
 218
 219 }
 220
 221 //______________________________________________________________________________
 222 void AliEveEMCALData::GetGeomInfo(Int_t id, Int_t &iSupMod, Double_t& x, Double_t& y, Double_t& z)
 223 {
 224   //
 225   // Get geometrical information from hit/digit/cluster absolute id
 226   //
 227
 228   Int_t iTower  =  0 ;
 229   Int_t iIphi   =  0 ;
 230   Int_t iIeta   =  0 ;
 231
 232   //Geometry methods
 233   fGeom->GetCellIndex(id,iSupMod,iTower,iIphi,iIeta);
 234   //Gives SuperModule and Tower numbers
 235   fGeom->RelPosCellInSModule(id, x, y, z);
 236
 237 }
 238
 239 //______________________________________________________________________________
 240 void  AliEveEMCALData::CreateAllSModules()
 241 {
 242   //
 243   // Create all fNsm super modules
 244   //
 245
 246   for(Int_t sm = 0; sm < fNsm; sm++)
 247     CreateSModule(sm);
 248
 249 }
 250
 251 //______________________________________________________________________________
 252 void  AliEveEMCALData::CreateSModule(Int_t sm)
 253 {
 254   //
 255   // Create super-module-data for SM if it does not exist already.
 256   //
 257
 258   if(fSM[sm] == 0) fSM[sm] = new AliEveEMCALSModuleData(sm,fGeom,fNode,fHMatrix);
 259   if(fSMfull[sm] == 0 && sm < 10) fSMfull[sm] = new AliEveEMCALSModuleData(sm,fGeom,fNode,fHMatrix);
 260   if(fSMhalf[sm-10] == 0 && sm > 10) fSMhalf[sm-10] = new AliEveEMCALSModuleData(sm,fGeom,fNode,fHMatrix);
 261 }
 262
 263 //______________________________________________________________________________
 264 void AliEveEMCALData::DropAllSModules()
 265 {
 266   //
 267   // Drop data of all existing sectors.
 268   //
 269
 270   for (Int_t sm = 0; sm < fNsm; sm++) {
 271     if (fSM[sm] != 0)
 272       fSM[sm]->DropData();
 273   }
 274 }
 275
 276 //______________________________________________________________________________
 277 void AliEveEMCALData::DeleteSuperModules()
 278 {
 279   //
 280   // Delete all super module data
 281   //
 282
 283   for (Int_t sm = 0; sm < fNsm; sm++)
 284     {
 285       fSM[sm] = 0;
 286       delete fSM[sm];
 287     }
 288
 289   for(Int_t smf = 0; smf < fNsmfull; smf++)
 290     {
 291       fSMfull[smf] = 0;
 292       delete fSMfull[smf];
 293     }
 294
 295   for(Int_t smh = 0; smh < fNsmhalf; smh++)
 296     {
 297       fSMhalf[smh] = 0;
 298       delete fSMhalf[smh];
 299     }
 300
 301 }
 302
 303 //______________________________________________________________________________
 304 void AliEveEMCALData::LoadHits(TTree* const t)
 305 {
 306   //
 307   // Get hit information from RunLoader
 308   //
 309
 310   /*
 311   // These are global coordinates !
 312   char form[1000];
 313   const char *selection = "";
 314   const char *varexp = "fX:fY:fZ";
 315   sprintf(form,"EMCAL Hits '%s'", selection);
 316   fPoint = new TEvePointSet(form);
 317
 318   TEvePointSelector ps(t, fPoint, varexp, selection);
 319   ps.Select();
 320
 321   if (fPoint->Size() == 0) {
 322     Warning("emcal_hits", Form("No hits match '%s'", selection));
 323     delete fPoint;
 324     //    return 0;
 325   }
 326   */
 327
 328   TObjArray *harr=NULL;
 329   TBranch *hbranch=t->GetBranch("EMCAL");
 330   hbranch->SetAddress(&harr);
 331
 332   if(hbranch->GetEvent(0)) {
 333     for(Int_t ih = 0; ih < harr->GetEntriesFast(); ih++) {
 334       AliEMCALHit* hit =(AliEMCALHit*)harr->UncheckedAt(ih);
 335       if(hit != 0){
 336         if(fDebug>1) cout << "Hit info " << hit->GetId() << " " << hit->GetEnergy() << endl;
 337         Int_t id = hit->GetId();
 338         // These are local coordinates
 339         Double_t xl = 0.; Double_t yl = 0.; Double_t zl = 0.;
 340         // Get global coordinates
 341         Double_t x = hit->X();
 342         Double_t y = hit->Y();
 343         Double_t z = hit->Z();
 344         Double_t amp = hit->GetEnergy();
 345         Int_t iSupMod = 0;
 346         // Get SM Id
 347         GetGeomInfo(id,iSupMod,xl,yl,zl);
 348         fSM[iSupMod]->RegisterHit(id,iSupMod,amp,x,y,z);
 349       }
 350     }
 351   }
 352 }
 353
 354 //______________________________________________________________________________
 355 void AliEveEMCALData::LoadHitsFromEMCALLoader(AliEMCALLoader* const emcl)
 356 {
 357   //
 358   // Get hit information from EMCAL Loader
 359   //
 360
 361         AliEMCALHit* hit;
 362
 363         //Fill array of hits
 364         TClonesArray *hits = 0;//(TClonesArray*)emcl->Hits();
 365         TTree *treeH = emcl->TreeH();
 366         if (treeH) {
 367                 Int_t nTrack = treeH->GetEntries();  // TreeH has array of hits for every primary
 368                 TBranch * branchH = treeH->GetBranch("EMCAL");
 369                 //if(fHits)fHits->Clear();
 370                 branchH->SetAddress(&hits);
 371                 for (Int_t iTrack = 0; iTrack < nTrack; iTrack++) {
 372                         branchH->GetEntry(iTrack);
 373
 374                         //Get hits from the list
 375                         for(Int_t ihit = 0; ihit< hits->GetEntries();ihit++){
 376
 377                                 hit = static_cast<AliEMCALHit *>(hits->At(ihit)) ;
 378
 379                                 if(hit != 0){
 380                                         if(fDebug>1) cout << "Hit info " << hit->GetId() << " " << hit->GetEnergy() << endl;
 381
 382                                         Int_t id = hit->GetId();
 383                                         // These are local coordinates
 384                                         Double_t xl = 0.; Double_t yl = 0.; Double_t zl = 0.;
 385                                         // Get global coordinates
 386                                         Double_t x = hit->X();
 387                                         Double_t y = hit->Y();
 388                                         Double_t z = hit->Z();
 389                                         Double_t amp = hit->GetEnergy();
 390                                         Int_t iSupMod = 0;
 391                                         // Get SM Id
 392                                         GetGeomInfo(id,iSupMod,xl,yl,zl);
 393                                         fSM[iSupMod]->RegisterHit(id,iSupMod,amp,x,y,z);
 394                                 }//hit exists
 395                         }//hit loop
 396                         hits->Clear();
 397                 }// track loop
 398         }//treeH exists
 399 }
 400
 401 //______________________________________________________________________________
 402 void AliEveEMCALData::LoadDigits(TTree *t)
 403 {
 404   //
 405   // Get digit information from RunLoader
 406   //
 407
 408   TClonesArray *digits = 0;
 409   t->SetBranchAddress("EMCAL", &digits);
 410   t->GetEntry(0);
 411
 412   Int_t nEnt = digits->GetEntriesFast();
 413   cout << "nEnt: " << nEnt << endl;
 414   AliEMCALDigit * dig;
 415
 416   //  Double_t amp   = -1 ;
 417   Double_t ampFlo   = -1 ;
 418   Int_t id      = -1 ;
 419   Int_t iSupMod =  0 ;
 420   Double_t x, y, z;
 421
 422   for (Int_t idig = 0; idig < nEnt; idig++)
 423     {
 424       dig = static_cast<AliEMCALDigit *>(digits->At(idig));
 425
 426       if(dig != 0) {
 427         id   = dig->GetId() ; //cell (digit) label
 428         // adc
 429         ampFlo  = dig->GetAmplitude(); //amplitude in cell (digit)
 430         // GeV
 431         //      amp = ampFlo*0.0153; // To be modified with correct OCDB conversion
 432
 433         GetGeomInfo(id,iSupMod,x,y,z);
 434
 435 //      // GeV
 436 //      fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
 437 // //   fSM[iSupMod]->SaveDigit(dig);
 438 // //   if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
 439 // //   if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,amp,x,y,z);
 440         fSM[iSupMod]->RegisterDigit(id,iSupMod,ampFlo,x,y,z);
 441 //      fSM[iSupMod]->SaveDigit(dig);
 442 //      if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
 443 //      if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,amp,x,y,z);
 444       }
 445       else {
 446         cout << "Digit object empty" << endl;
 447         return;
 448       }
 449     } // end loop digits
 450   cout << "after loop on digits !" << endl;
 451 }
 452
 453 //______________________________________________________________________________
 454 void AliEveEMCALData::LoadDigitsFromEMCALLoader(AliEMCALLoader* const emcl)
 455 {
 456
 457   //
 458   // Get digit information from EMCAL Loader
 459   //
 460
 461   AliEMCALDigit* dig;
 462
 463   //Fill array of digits
 464   TClonesArray *digits = (TClonesArray*)emcl->Digits();
 465
 466   //Get digits from the list
 467
 468   //  Double_t amp   = -1 ;
 469   Double_t ampFlo   = -1 ;
 470   Int_t id      = -1 ;
 471   Int_t iSupMod =  0 ;
 472   Double_t x, y, z;
 473
 474    for(Int_t idig = 0; idig< digits->GetEntries();idig++){
 475
 476      dig = static_cast<AliEMCALDigit *>(digits->At(idig)) ;
 477
 478      if(dig != 0){
 479        if(fDebug>1) cout << "Digit info " << dig->GetId() << " " << dig->GetAmplitude() << endl;
 480        id   = dig->GetId() ; //cell (digit) label
 481        // adc
 482        ampFlo  = dig->GetAmplitude(); //amplitude in cell (digit)
 483        // GeV
 484        //       amp = ampFlo*0.0153.; // To be modified with correct OCDB conversion
 485
 486        GetGeomInfo(id,iSupMod,x,y,z);
 487
 488        //       // GeV
 489        //       fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
 490        // adc
 491        fSM[iSupMod]->RegisterDigit(id,iSupMod,ampFlo,x,y,z);
 492      }
 493       else {
 494         cout << "Digit object empty" << endl;
 495         return;
 496       }
 497    } // end loop on digits
 498
 499 }
 500
 501 //______________________________________________________________________________
 502 void AliEveEMCALData::LoadDigitsFromESD()
 503 {
 504   //
 505   // Get digit information from esd
 506   //
 507
 508   AliESDCaloCells &cells= *(fESD->GetEMCALCells());
 509   Int_t ncell = cells.GetNumberOfCells() ;
 510   Int_t iSupMod =  0 ;
 511   Double_t x, y, z;
 512
 513   // Extract digit information from the ESDs
 514   for (Int_t icell=  0; icell <  ncell; icell++)
 515     {
 516       Int_t id   = cells.GetCellNumber(icell);
 517       // adc
 518       Double_t ampFlo  = cells.GetAmplitude(icell);
 519       // GeV
 520       //      Double_t amp = ampFlo*0.0153; // To be modified with correct OCDB conversion
 521
 522       GetGeomInfo(id,iSupMod,x,y,z);
 523
 524 //       // GeV
 525 //       fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
 526 //       if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
 527 //       if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,amp,x,y,z);
 528       // adc
 529       fSM[iSupMod]->RegisterDigit(id,iSupMod,ampFlo,x,y,z);
 530       if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,ampFlo,x,y,z);
 531       if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,ampFlo,x,y,z);
 532
 533     } // end loop cells
 534 }
 535
 536 //______________________________________________________________________________
 537 void AliEveEMCALData::LoadRecPoints(TTree* const t)
 538 {
 539   //
 540   // Get rec point information from RunLoader
 541   //
 542
 543   //*************************************************
 544   // To be improved !!!!!
 545   // Size and shape of cluster to be implemented
 546   //
 547   //*************************************************
 548
 549   // From TTreeR
 550   TObjArray *carr=NULL;
 551   TBranch *cbranch=t->GetBranch("EMCALECARP");
 552   cbranch->SetAddress(&carr);
 553
 554   if(cbranch->GetEvent(0)) {
 555     for(Int_t ic = 0; ic < carr->GetEntriesFast(); ic++) {
 556       AliEMCALRecPoint* rp =(AliEMCALRecPoint*)carr->UncheckedAt(ic);
 557       if(rp){
 558         if(fDebug>1) cout << "RecPoint info " << rp->GetAbsId() << " " << rp->GetEnergy() << endl;
 559         Int_t iSupMod = rp->GetSuperModuleNumber();
 560         // GeV
 561         Double_t amp = (Double_t)rp->GetEnergy();
 562         // adc
 563         Double_t ampFlo = amp/0.0153; // To be modified with correct OCDB conversion
 564         TVector3 lpos;
 565         rp->GetLocalPosition(lpos);
 566
 567 //      // GeV
 568 //      fSM[iSupMod]->RegisterCluster(iSupMod,amp,lpos[0],lpos[1],lpos[2]);
 569         // adc
 570         fSM[iSupMod]->RegisterCluster(iSupMod,ampFlo,lpos[0],lpos[1],lpos[2]);
 571       }
 572     }
 573   }
 574
 575 }
 576
 577 //______________________________________________________________________________
 578 void AliEveEMCALData::LoadRecPointsFromEMCALLoader(AliEMCALLoader* const emcl)
 579 {
 580   //
 581   // Get rec point information from EMCAL Loader
 582   //
 583
 584   //*************************************************
 585   // To be improved !!!!!
 586   // Size and shape of cluster to be implemented
 587   //
 588   //*************************************************
 589
 590   // From EMCALLoader
 591   AliEMCALRecPoint* rp;
 592
 593   //Fill array of clusters
 594   TClonesArray *clusters = (TClonesArray*)emcl->RecPoints();
 595
 596   //Get clusters from the list
 597   for(Int_t iclu = 0; iclu< clusters->GetEntries();iclu++){
 598
 599     rp = static_cast<AliEMCALRecPoint *>(clusters->At(iclu)) ;
 600
 601     if(rp){
 602        if(fDebug>1) cout << "RecPoint info " << rp->GetAbsId() << " " << rp->GetEnergy() << endl;
 603        Int_t iSupMod = rp->GetSuperModuleNumber();
 604        Double_t amp = (Double_t)rp->GetEnergy();
 605        Double_t ampFlo = amp/0.0153; // To be modified with correct OCDB conversion
 606        TVector3 lpos;
 607        rp->GetLocalPosition(lpos);
 608
 609 //        // GeV
 610 //        fSM[iSupMod]->RegisterCluster(iSupMod,amp,lpos[0],lpos[1],lpos[2]);
 611        // adc
 612        fSM[iSupMod]->RegisterCluster(iSupMod,ampFlo,lpos[0],lpos[1],lpos[2]);
 613     }
 614   }
 615
 616 }
 617
 618 //______________________________________________________________________________
 619 void AliEveEMCALData::LoadRecPointsFromESD()
 620 {
 621   //
 622   // Get cluster information from esd
 623   //
 624
 625  Int_t iSupMod =  0 ;
 626   Double_t x, y, z;
 627   Int_t iSM =  0 ;
 628   Int_t iT  =  0 ;
 629   Int_t iIp   =  0 ;
 630   Int_t iIe   =  0 ;
 631   Double_t xd, yd, zd;
 632   Float_t pos[3] ;
 633
 634   // Get reconstructed vertex position
 635   AliESDVertex* primVertex =(AliESDVertex*) fESD->GetVertex();
 636   Double_t vertexPosition[3] ;
 637   primVertex->GetXYZ(vertexPosition) ;
 638
 639   //Get the CaloClusters
 640   //select EMCAL clusters only
 641   TRefArray * caloClusters  = new TRefArray();
 642   fESD->GetEMCALClusters(caloClusters);
 643   Int_t nclus = caloClusters->GetEntries();
 644   cout << "nclus: " << nclus << endl;
 645
 646   for (Int_t iclus =  0; iclus <  nclus; iclus++)
 647     {
 648       AliESDCaloCluster *clus = (AliESDCaloCluster *) caloClusters->At(iclus) ;
 649       //Get the cluster info
 650
 651       Double_t energy = clus->E() ;
 652       // adc
 653       //      Int_t   eneInt = (Int_t)energy*500+0.5;
 654       Double_t eneInt = energy/0.0153; // To be modified with correct OCDB conversion
 655       Double_t disp   = clus->GetDispersion() ;
 656
 657       clus->GetPosition(pos) ; // Global position
 658       TVector3 vpos(pos[0],pos[1],pos[2]) ;
 659       TLorentzVector p4 ;
 660       TVector3 p3;
 661       clus->GetMomentum(p4,vertexPosition);
 662       p3.SetXYZ(p4[0],p4[1],p4[2]);
 663       Double_t eta = p3.Eta();
 664       Double_t phi = ( (p3.Phi()) < 0) ? (p3.Phi()) + 2. * TMath::Pi() : (p3.Phi());
 665
 666       Int_t mult = clus->GetNCells() ;
 667       if(fDebug>2) {
 668         cout << "In cluster: " << iclus << ", ncells: " << mult << ", energy : " << energy <<
 669           ", disp: " << disp << endl;
 670         cout << "Cluster " << iclus << ", eta: " << eta << ", phi: " << phi << endl;
 671       }
 672
 673       Int_t clusId = 0;
 674       fGeom->GetAbsCellIdFromEtaPhi(eta,phi,clusId);
 675       if(fDebug>2) {
 676         cout << "Abs Cluster Id: " << clusId << ", xc: " << pos[0] <<
 677           ", yc: " << pos[1] << ", zc: " << pos[2] << endl;
 678       }
 679
 680       GetGeomInfo(clusId,iSupMod,x,y,z);
 681
 682       //******** Not used yet but will come  ********
 683       // AliESDCaloCells &cells= *(fESD->GetEMCALCells());
 684       Int_t     digMult = clus->GetNCells() ;
 685       UShort_t *digID   = clus->GetCellsAbsId() ;
 686       for(Int_t i=0; i<digMult; i++){
 687         // Float_t  digitAmp     = cells.GetCellAmplitude(digID[i]) ;
 688         fGeom->RelPosCellInSModule(digID[i], xd, yd, zd);
 689         //Geometry methods
 690         fGeom->GetCellIndex(digID[i],iSM,iT,iIp,iIe);
 691         //Gives SuperModule and Tower numbers
 692
 693       } // end digit loop
 694       //*********************************************
 695       //      // GeV
 696       //      fSM[iSupMod]->RegisterCluster(iSM,energy,x,y,z);
 697       // adc
 698       fSM[iSupMod]->RegisterCluster(iSM,eneInt,x,y,z);
 699
 700     } // end cluster loop
 701 }
 702
 703 //______________________________________________________________________________
 704 AliEveEMCALSModuleData* AliEveEMCALData::GetSModuleData(Int_t sm)
 705 {
 706   //
 707   // Return super module data
 708   //
 709
 710   if (sm < 0 || sm > fNsm)
 711     {
 712       printf("The number of super modules must be lower or equal to %d",fNsm);
 713       return 0;
 714     }
 715
 716   return fSM[sm];
 717 }
 718
 719 //______________________________________________________________________________
 720 void AliEveEMCALData::LoadRaw() const
 721 {
 722   //
 723   // Get raw information
 724   //
 725
 726   // To be implemented !
 727 }
 728