EVE/EveDet/AliEveEMCALData.cxx

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