Add includes missing after cleanup in root.
[u/mrichter/AliRoot.git] / 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 #include <TMath.h>
21 #include <TLorentzVector.h>
22
23 #include "AliRun.h"
24 #include "AliRunLoader.h"
25 #include "AliEMCALLoader.h"
26 #include "AliESDEvent.h"
27 #include "AliESDVertex.h"
28 #include "AliEMCAL.h"
29 #include "AliEMCALGeometry.h"
30 #include "AliEMCALHit.h"
31 #include "AliEMCALDigit.h"
32
33 #include "AliEMCALRecPoint.h"
34 #include "AliESDCaloCells.h"
35 #include "AliESDCaloCluster.h"
36
37 #include "AliEveEMCALData.h"
38 #include "AliEveEMCALSModule.h"
39 #include "AliEveEMCALSModuleData.h"
40
41 ClassImp(AliEveEMCALData)
42
43 //______________________________________________________________________________
44 AliEveEMCALData::AliEveEMCALData():
45   TObject(),
46   TEveRefCnt(),
47   fEmcal(0x0),
48   fGeom(0x0),
49   fNode(0x0),
50   fHMatrix(0),
51   fTree(0x0),
52   fESD(0x0),
53   fNsm(12),
54   fNsmfull(10),
55   fNsmhalf(2),
56   fSM(12),
57   fSMfull(10),
58   fSMhalf(2),
59   fRunLoader(0),
60   fDebug(0),
61   fPoint(0)
62 {
63   
64   //
65   // Constructor
66   //
67   //   for(Int_t i=0; i<12; i++)
68   //     fSM[i] = 0x0;
69   //   for(Int_t i=0; i<10; i++)
70   //     fSMfull[i] = 0x0;
71   //   fSMhalf[0] = fSMhalf[1] = 0x0;
72   //  InitEMCALGeom();
73   CreateAllSModules();
74
75
76 }
77
78 //______________________________________________________________________________
79 AliEveEMCALData::AliEveEMCALData(AliRunLoader* rl, TGeoNode* node, TGeoHMatrix* m):
80   TObject(),
81   TEveRefCnt(),
82   fEmcal(0x0),
83   fGeom(0x0),
84   fNode(node),
85   fHMatrix(m),
86   fTree(0x0),
87   fESD(0x0),
88   fNsm(12),
89   fNsmfull(10),
90   fNsmhalf(2),
91   fSM(12),
92   fSMfull(10),
93   fSMhalf(2),
94   fRunLoader(rl),
95   fDebug(0),
96   fPoint(0)
97 {
98   
99   //
100   // Constructor
101   //
102 //   for(Int_t i=0; i<12; i++)
103 //     fSM[i] = 0x0;
104 //   for(Int_t i=0; i<10; i++)
105 //     fSMfull[i] = 0x0;
106 //   fSMhalf[0] = fSMhalf[1] = 0x0;
107   InitEMCALGeom(rl);
108   CreateAllSModules();
109
110
111 }
112
113 //______________________________________________________________________________
114 AliEveEMCALData::~AliEveEMCALData()
115 {
116   //
117   // Destructor
118   //
119
120   DeleteSuperModules();
121   delete fTree;
122   // delete fEmcal; // deleted by run-loader
123   delete fGeom;
124   delete fNode;
125   delete fHMatrix;
126   delete fPoint;
127 }
128
129 //______________________________________________________________________________
130 void AliEveEMCALData::Reset()
131 {
132
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* 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* esd)
191 {
192   //
193   // Set esd
194   //
195
196   fESD = esd;
197 }
198
199 //______________________________________________________________________________
200 void AliEveEMCALData::SetNode(TGeoNode* node)
201 {
202   //
203   // Set node
204   //
205
206   fNode = node;
207 }
208
209 //______________________________________________________________________________
210 void AliEveEMCALData::InitEMCALGeom(AliRunLoader* 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* 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* emcl)
356 {
357   //
358   // Get hit information from EMCAL Loader
359   //
360
361   AliEMCALHit* hit;
362   
363   //Fill array of hits                                                                        
364   TClonesArray *hits = (TClonesArray*)emcl->Hits();
365
366   //Get hits from the list                                                                    
367   for(Int_t ihit = 0; ihit< hits->GetEntries();ihit++){
368
369     hit = static_cast<AliEMCALHit *>(hits->At(ihit)) ;
370     
371     if(hit != 0){
372       if(fDebug>1) cout << "Hit info " << hit->GetId() << " " << hit->GetEnergy() << endl;
373
374       Int_t id = hit->GetId();
375       // These are local coordinates
376       Double_t xl = 0.; Double_t yl = 0.; Double_t zl = 0.;
377       // Get global coordinates
378       Double_t x = hit->X();
379       Double_t y = hit->Y();
380       Double_t z = hit->Z();
381       Double_t amp = hit->GetEnergy();
382       Int_t iSupMod = 0;
383       // Get SM Id
384       GetGeomInfo(id,iSupMod,xl,yl,zl);
385       fSM[iSupMod]->RegisterHit(id,iSupMod,amp,x,y,z);
386     }
387   }
388   
389 }
390
391 //______________________________________________________________________________
392 void AliEveEMCALData::LoadDigits(TTree *t)
393 {
394   //
395   // Get digit information from RunLoader
396   //
397
398   TClonesArray *digits = 0;
399   t->SetBranchAddress("EMCAL", &digits);
400   t->GetEntry(0);
401
402   Int_t nEnt = digits->GetEntriesFast();
403   cout << "nEnt: " << nEnt << endl;
404   AliEMCALDigit * dig;
405
406   //  Double_t amp   = -1 ;
407   Double_t ampInt   = -1 ;
408   Int_t id      = -1 ;
409   Int_t iSupMod =  0 ;
410   Double_t x, y, z;
411
412   for (Int_t idig = 0; idig < nEnt; idig++)
413     {
414       dig = static_cast<AliEMCALDigit *>(digits->At(idig));
415       
416       if(dig != 0) {
417         id   = dig->GetId() ; //cell (digit) label
418         // adc
419         ampInt  = dig->GetAmp(); //amplitude in cell (digit)
420         // GeV
421         //      amp = ampInt*0.0153; // To be modified with correct OCDB conversion     
422
423         GetGeomInfo(id,iSupMod,x,y,z);
424
425 //      // GeV
426 //      fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
427 // //   fSM[iSupMod]->SaveDigit(dig);
428 // //   if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
429 // //   if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,amp,x,y,z);
430         fSM[iSupMod]->RegisterDigit(id,iSupMod,ampInt,x,y,z);
431 //      fSM[iSupMod]->SaveDigit(dig);
432 //      if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
433 //      if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,amp,x,y,z);
434       }
435       else {
436         cout << "Digit object empty" << endl;
437         return;
438       }
439     } // end loop digits
440   cout << "after loop on digits !" << endl;
441 }
442
443 //______________________________________________________________________________
444 void AliEveEMCALData::LoadDigitsFromEMCALLoader(AliEMCALLoader* emcl)
445 {
446
447   //
448   // Get digit information from EMCAL Loader
449   //
450
451   AliEMCALDigit* dig;
452   
453   //Fill array of digits                                                                        
454   TClonesArray *digits = (TClonesArray*)emcl->Digits();
455   
456   //Get digits from the list  
457   
458   //  Double_t amp   = -1 ;
459   Double_t ampInt   = -1 ;
460   Int_t id      = -1 ;
461   Int_t iSupMod =  0 ;
462   Double_t x, y, z;
463                                                
464    for(Int_t idig = 0; idig< digits->GetEntries();idig++){
465
466      dig = static_cast<AliEMCALDigit *>(digits->At(idig)) ;
467
468      if(dig != 0){
469        if(fDebug>1) cout << "Digit info " << dig->GetId() << " " << dig->GetAmp() << endl;
470        id   = dig->GetId() ; //cell (digit) label
471        // adc
472        ampInt  = dig->GetAmp(); //amplitude in cell (digit)
473        // GeV
474        //       amp = ampInt*0.0153.; // To be modified with correct OCDB conversion
475
476        GetGeomInfo(id,iSupMod,x,y,z);
477        
478        //       // GeV
479        //       fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
480        // adc
481        fSM[iSupMod]->RegisterDigit(id,iSupMod,ampInt,x,y,z);
482      }
483       else {
484         cout << "Digit object empty" << endl;
485         return;
486       }
487    } // end loop on digits
488    
489 }
490
491 //______________________________________________________________________________
492 void AliEveEMCALData::LoadDigitsFromESD()
493 {
494   //
495   // Get digit information from esd
496   //
497   
498   AliESDCaloCells &cells= *(fESD->GetEMCALCells());
499   Int_t ncell = cells.GetNumberOfCells() ;  
500   Int_t iSupMod =  0 ;
501   Double_t x, y, z;
502
503   // Extract digit information from the ESDs
504   for (Int_t icell=  0; icell <  ncell; icell++) 
505     {
506       Int_t id   = cells.GetCellNumber(icell);
507       // adc
508       Double_t ampInt  = cells.GetAmplitude(icell);
509       // GeV
510       //      Double_t amp = ampInt*0.0153; // To be modified with correct OCDB conversion
511
512       GetGeomInfo(id,iSupMod,x,y,z);
513
514 //       // GeV
515 //       fSM[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
516 //       if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,amp,x,y,z);
517 //       if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,amp,x,y,z);
518       // adc
519       fSM[iSupMod]->RegisterDigit(id,iSupMod,ampInt,x,y,z);
520       if(iSupMod<fNsmfull) fSMfull[iSupMod]->RegisterDigit(id,iSupMod,ampInt,x,y,z);
521       if(iSupMod>fNsmfull) fSMhalf[iSupMod-10]->RegisterDigit(id,iSupMod,ampInt,x,y,z);
522
523     } // end loop cells
524 }
525
526 //______________________________________________________________________________
527 void AliEveEMCALData::LoadRecPoints(TTree* t)
528 {
529   //
530   // Get rec point information from RunLoader
531   //
532
533   //*************************************************
534   // To be improved !!!!!
535   // Size and shape of cluster to be implemented
536   // 
537   //*************************************************
538         
539   // From TTreeR
540   TObjArray *carr=NULL;
541   TBranch *cbranch=t->GetBranch("EMCALECARP");
542   cbranch->SetAddress(&carr);
543   
544   if(cbranch->GetEvent(0)) {
545     for(Int_t ic = 0; ic < carr->GetEntriesFast(); ic++) {
546       AliEMCALRecPoint* rp =(AliEMCALRecPoint*)carr->UncheckedAt(ic);
547       if(rp){
548         if(fDebug>1) cout << "RecPoint info " << rp->GetAbsId() << " " << rp->GetEnergy() << endl;
549         Int_t iSupMod = rp->GetSuperModuleNumber();
550         // GeV
551         Double_t amp = (Double_t)rp->GetEnergy();
552         // adc
553         Double_t ampInt = amp/0.0153; // To be modified with correct OCDB conversion
554         TVector3 lpos;
555         rp->GetLocalPosition(lpos);
556
557 //      // GeV
558 //      fSM[iSupMod]->RegisterCluster(iSupMod,amp,lpos[0],lpos[1],lpos[2]);
559         // adc
560         fSM[iSupMod]->RegisterCluster(iSupMod,ampInt,lpos[0],lpos[1],lpos[2]);
561       }
562     }
563   }
564   
565 }
566
567 //______________________________________________________________________________
568 void AliEveEMCALData::LoadRecPointsFromEMCALLoader(AliEMCALLoader* emcl)
569 {
570   //
571   // Get rec point information from EMCAL Loader
572   //
573
574   //*************************************************
575   // To be improved !!!!!
576   // Size and shape of cluster to be implemented
577   // 
578   //*************************************************
579
580   // From EMCALLoader
581   AliEMCALRecPoint* rp;
582   
583   //Fill array of clusters                                                                        
584   TClonesArray *clusters = (TClonesArray*)emcl->RecPoints();
585   
586   //Get clusters from the list                                                                    
587   for(Int_t iclu = 0; iclu< clusters->GetEntries();iclu++){
588
589     rp = static_cast<AliEMCALRecPoint *>(clusters->At(iclu)) ;
590     
591     if(rp){
592        if(fDebug>1) cout << "RecPoint info " << rp->GetAbsId() << " " << rp->GetEnergy() << endl;
593        Int_t iSupMod = rp->GetSuperModuleNumber();
594        Double_t amp = (Double_t)rp->GetEnergy();
595        Double_t ampInt = amp/0.0153; // To be modified with correct OCDB conversion
596        TVector3 lpos;
597        rp->GetLocalPosition(lpos);
598        
599 //        // GeV
600 //        fSM[iSupMod]->RegisterCluster(iSupMod,amp,lpos[0],lpos[1],lpos[2]);
601        // adc
602        fSM[iSupMod]->RegisterCluster(iSupMod,ampInt,lpos[0],lpos[1],lpos[2]);
603     }
604   }
605   
606 }
607
608 //______________________________________________________________________________
609 void AliEveEMCALData::LoadRecPointsFromESD()
610 {
611   //
612   // Get cluster information from esd
613   //
614
615  Int_t iSupMod =  0 ;
616   Double_t x, y, z;
617   Int_t iSM =  0 ;
618   Int_t iT  =  0 ;
619   Int_t iIp   =  0 ;
620   Int_t iIe   =  0 ;
621   Double_t xd, yd, zd;
622   Float_t pos[3] ; 
623   
624   // Get reconstructed vertex position
625   AliESDVertex* primVertex =(AliESDVertex*) fESD->GetVertex();
626   Double_t vertex_position[3] ; 
627   primVertex->GetXYZ(vertex_position) ; 
628
629   //Get the CaloClusters
630   //select EMCAL clusters only 
631   TRefArray * caloClusters  = new TRefArray();
632   fESD->GetEMCALClusters(caloClusters);
633   Int_t nclus = caloClusters->GetEntries();
634   cout << "nclus: " << nclus << endl; 
635   
636   if(!caloClusters) return;
637
638   for (Int_t iclus =  0; iclus <  nclus; iclus++) 
639     {
640       AliESDCaloCluster *clus = (AliESDCaloCluster *) caloClusters->At(iclus) ; 
641       //Get the cluster info
642       
643       Double_t energy = clus->E() ;
644       // adc
645       //      Int_t   eneInt = (Int_t)energy*500+0.5;
646       Double_t eneInt = energy/0.0153; // To be modified with correct OCDB conversion
647       Double_t disp   = clus->GetClusterDisp() ;
648       
649       clus->GetPosition(pos) ; // Global position
650       TVector3 vpos(pos[0],pos[1],pos[2]) ;
651       TLorentzVector p4 ;
652       TVector3 p3;
653       clus->GetMomentum(p4,vertex_position);
654       p3.SetXYZ(p4[0],p4[1],p4[2]);
655       Double_t eta = p3.Eta();
656       Double_t phi = ( (p3.Phi()) < 0) ? (p3.Phi()) + 2. * TMath::Pi() : (p3.Phi());
657       
658       Int_t mult = clus->GetNCells() ;
659       if(fDebug>2) {
660         cout << "In cluster: " << iclus << ", ncells: " << mult << ", energy : " << energy << 
661           ", disp: " << disp << endl;
662         cout << "Cluster " << iclus << ", eta: " << eta << ", phi: " << phi << endl;
663       }
664
665       Int_t clusId = 0;
666       fGeom->GetAbsCellIdFromEtaPhi(eta,phi,clusId);
667       if(fDebug>2) {
668         cout << "Abs Cluster Id: " << clusId << ", xc: " << pos[0] << 
669           ", yc: " << pos[1] << ", zc: " << pos[2] << endl;
670       }
671
672       GetGeomInfo(clusId,iSupMod,x,y,z);
673       
674       //******** Not used yet but will come  ********
675       // AliESDCaloCells &cells= *(fESD->GetEMCALCells());
676       Int_t     digMult = clus->GetNCells() ;
677       UShort_t *digID   = clus->GetCellsAbsId() ;
678       for(Int_t i=0; i<digMult; i++){
679         // Float_t  digitAmp     = cells.GetCellAmplitude(digID[i]) ;
680         fGeom->RelPosCellInSModule(digID[i], xd, yd, zd);
681         //Geometry methods
682         fGeom->GetCellIndex(digID[i],iSM,iT,iIp,iIe);
683         //Gives SuperModule and Tower numbers
684
685       } // end digit loop
686       //*********************************************
687       //      // GeV
688       //      fSM[iSupMod]->RegisterCluster(iSM,energy,x,y,z);
689       // adc
690       fSM[iSupMod]->RegisterCluster(iSM,eneInt,x,y,z);
691
692     } // end cluster loop
693 }
694
695 //______________________________________________________________________________
696 AliEveEMCALSModuleData* AliEveEMCALData::GetSModuleData(Int_t sm)
697 {
698   //
699   // Return super module data
700   //
701
702   if (sm < 0 || sm > fNsm) 
703     {
704       printf("The number of super modules must be lower or equal to %d",fNsm);
705       return 0;
706     }
707   
708   return fSM[sm];
709 }
710
711 //______________________________________________________________________________
712 void AliEveEMCALData::LoadRaw()
713 {
714   //
715   // Get raw information
716   //
717
718   // To be implemented !
719 }
720