Compatibility with ROOT trunk
[u/mrichter/AliRoot.git] / JETAN / AliJetGrid.cxx
1 /**************************************************************************
2  * Copyright(c) 2001-2002, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id: AliJetGrid.cxx,v 1.0 07/09/2006 */
17
18 //=========================================================================
19 //  *** 07 September 2006
20 //  This class allows to fill a really general grid in (eta,phi) 
21 //  Two types of grid can be setted : 
22 //     if fGrid==0 -> the complete acceptance of a rectangular detector acceptance is filled
23 //     if fGrid==1 -> the previous grid - an other rectangular detector acceptance is filled 
24 //  A (eta,phi(rad)) position can be extracted from an index value without looping over all entries
25 //  An index position can be extracted from a (eta,phi(rad)) position without looping over all entries
26 //
27 //  How to run it :
28 //  > AliJetGrid *grid = new AliJetGrid((NbinPhi-1),(NbinEta-1),PhiMin,PhiMax,EtaMin,EtaMax);
29 //  > grid->SetGridType(...); // 0 or 1 for the moment
30 //  > grid->SetMatrixIndexes();
31 //  > grid->SetIndexIJ();
32 //
33 //  Author : magali.estienne@subatech.in2p3.fr
34 //=========================================================================
35
36 // Standard headers 
37 #include <Riostream.h>
38 // Root headers
39 #include <TMath.h>
40 #include <TMatrixD.h>
41 #include <TArrayD.h>
42 #include <TArrayI.h>
43 // AliRoot headers
44 #include "AliJetGrid.h"
45
46 using std::cout;
47 using std::endl;
48 ClassImp(AliJetGrid)
49
50 //__________________________________________________________
51 AliJetGrid::AliJetGrid():
52   fGrid(0),
53   fNphi(0),        
54   fNeta(0),      
55   fPhi(0),       
56   fEta(0),       
57   fIndex(0),     
58   fIndexI(0),    
59   fIndexJ(0),    
60   fPhiMin(0),    
61   fPhiMax(0),    
62   fEtaMin(0),    
63   fEtaMax(0),    
64   fEtaBinInTPCAcc(0),   
65   fPhiBinInTPCAcc(0),   
66   fEtaBinInEMCalAcc(0), 
67   fPhiBinInEMCalAcc(0), 
68   fNbinEta(0),
69   fNbinPhi(0),
70   fMaxPhi(0),
71   fMinPhi(0),
72   fMaxEta(0),
73   fMinEta(0),
74   fDebug(1)
75 {
76   // Default constructor
77 }
78
79 //__________________________________________________________
80 AliJetGrid::AliJetGrid(Int_t nphi,Int_t neta,Double_t phiMin,Double_t phiMax,Double_t etaMin,Double_t etaMax):
81   fGrid(0),
82   fNphi(nphi),        
83   fNeta(neta),      
84   fPhi(0),       
85   fEta(0),       
86   fIndex(0),     
87   fIndexI(0),    
88   fIndexJ(0),    
89   fPhiMin(0),    
90   fPhiMax(0),    
91   fEtaMin(0),    
92   fEtaMax(0),    
93   fEtaBinInTPCAcc(0),   
94   fPhiBinInTPCAcc(0),   
95   fEtaBinInEMCalAcc(0), 
96   fPhiBinInEMCalAcc(0), 
97   fNbinEta(0),
98   fNbinPhi(0),
99   fMaxPhi(phiMax),
100   fMinPhi(phiMin),
101   fMaxEta(etaMax),
102   fMinEta(etaMin),
103   fDebug(1)
104 {
105   // Standard constructor
106   fPhi    = new TArrayD(fNphi+1);
107   fEta    = new TArrayD(fNeta+1);
108   fIndexI = new TArrayI((fNeta+1)*(fNphi+1)+1);
109   fIndexJ = new TArrayI((fNeta+1)*(fNphi+1)+1);
110   
111   for(Int_t i=0; i<fNphi+1; i++) {
112           if(fNphi!=0) (*fPhi)[i] = (phiMax-phiMin)/fNphi*i+phiMin;
113           else (*fPhi)[i] = phiMin+(phiMax-phiMin)/2;
114   }
115   for(Int_t i=0; i<fNeta+1; i++) {
116           if(fNeta!=0) (*fEta)[i] = (etaMax-etaMin)/fNeta*i+etaMin;
117           else (*fEta)[i] = etaMin+(etaMax-etaMin)/2;
118   }
119   
120   if(fDebug > 3){
121       for(Int_t i=0; i<(fNphi+1); i++)  cout << (*fPhi)[i] << endl;
122       for(Int_t i=0; i<(fNeta+1); i++)  cout << (*fEta)[i] << endl;
123   }
124   
125   fIndex = new TMatrixD(fNphi+1,fNeta+1);
126   
127 }
128
129 //__________________________________________________________
130 AliJetGrid::AliJetGrid(const AliJetGrid& grid) : 
131   TNamed(grid),
132   fGrid(grid.fGrid),
133   fNphi(grid.fNphi),        
134   fNeta(grid.fNeta),      
135   fPhi(0),       
136   fEta(0),       
137   fIndex(0),     
138   fIndexI(grid.fIndexI),    
139   fIndexJ(grid.fIndexJ),    
140   fPhiMin(grid.fPhiMin),    
141   fPhiMax(grid.fPhiMax),    
142   fEtaMin(grid.fEtaMin),    
143   fEtaMax(grid.fEtaMax),    
144   fEtaBinInTPCAcc(grid.fEtaBinInTPCAcc),   
145   fPhiBinInTPCAcc(grid.fPhiBinInTPCAcc),   
146   fEtaBinInEMCalAcc(grid.fEtaBinInEMCalAcc), 
147   fPhiBinInEMCalAcc(grid.fPhiBinInEMCalAcc), 
148   fNbinEta(grid.fNbinEta),
149   fNbinPhi(grid.fNbinPhi),
150   fMaxPhi(grid.fMaxPhi),
151   fMinPhi(grid.fMinPhi),
152   fMaxEta(grid.fMaxEta),
153   fMinEta(grid.fMinEta),
154   fDebug(grid.fDebug) 
155 {
156
157   // Copy constructor
158
159   fPhi = new TArrayD(fNphi+1);
160   for(Int_t i=0; i<fNphi+1; i++) (*fPhi)[i] = grid.fPhi->At(i);
161   fEta = new TArrayD(fNeta+1);
162   for(Int_t i=0; i<fNeta+1; i++) (*fEta)[i] = grid.fEta->At(i);
163
164   fIndex = new TMatrixD(fNphi+1,fNeta+1);
165   for(Int_t i=0; i<fNphi+1; i++) {
166     for(Int_t j=0; j<fNeta+1; j++) (*fIndex)(i,j)=(*grid.fIndex)(i,j);
167   }
168 }
169
170
171 AliJetGrid& AliJetGrid::operator=(const AliJetGrid& other)
172 {
173   // Assignment
174     if (this != &other) {
175         fGrid = other.fGrid;
176         fNphi = other.fNphi;        
177         fNeta = other.fNeta;      
178         fPhi    = 0;       
179         fEta    = 0;       
180         fIndex  = 0;     
181         fIndexI = other.fIndexI;    
182         fIndexJ = other.fIndexJ;    
183         fPhiMin = other.fPhiMin;    
184         fPhiMax = other.fPhiMax;    
185         fEtaMin = other.fEtaMin;    
186         fEtaMax = other.fEtaMax;    
187         fEtaBinInTPCAcc   = other.fEtaBinInTPCAcc;   
188         fPhiBinInTPCAcc   = other.fPhiBinInTPCAcc;   
189         fEtaBinInEMCalAcc = other.fEtaBinInEMCalAcc; 
190         fPhiBinInEMCalAcc = other.fPhiBinInEMCalAcc; 
191         fNbinEta = other.fNbinEta;
192         fNbinPhi = other.fNbinPhi;
193         fMaxPhi  = other.fMaxPhi;
194         fMinPhi  = other.fMinPhi;
195         fMaxEta  = other.fMaxEta;
196         fMinEta  = other.fMinEta;
197         fDebug   = other.fDebug;
198         fPhi = new TArrayD(fNphi+1);
199         for(Int_t i=0; i<fNphi+1; i++) (*fPhi)[i] = other.fPhi->At(i);
200         fEta = new TArrayD(fNeta+1);
201         for(Int_t i=0; i<fNeta+1; i++) (*fEta)[i] = other.fEta->At(i);
202   
203         fIndex = new TMatrixD(fNphi+1,fNeta+1);
204         for(Int_t i=0; i<fNphi+1; i++) {
205             for(Int_t j=0; j<fNeta+1; j++) (*fIndex)(i,j)=(*other.fIndex)(i,j);
206         }
207     }
208     
209     return *this;
210 }
211
212 //__________________________________________________________
213 AliJetGrid::~AliJetGrid() {
214
215   // Destructor
216   delete fPhi;
217   delete fEta;
218   delete fIndexI;
219   delete fIndexJ;
220   delete fIndex;
221 }
222
223 //__________________________________________________________
224 void AliJetGrid::InitParams(Double_t phiMinCal,Double_t phiMaxCal,Double_t etaMinCal,Double_t etaMaxCal) 
225
226 // To set initial parameters
227
228   fPhiMin = phiMinCal; // rad
229   fPhiMax = phiMaxCal; // rad
230   fEtaMin = etaMinCal;
231   fEtaMax = etaMaxCal;
232   fNbinPhi = static_cast<int>(fPhiMin/(2*TMath::Pi()/fNphi));
233
234   // Define some binning numbers
235   if(fGrid==0){
236     for(Int_t i=0; i<fNphi+1; i++) fPhiBinInTPCAcc++;
237     fPhiBinInEMCalAcc = 0;
238     
239     for(Int_t i=0; i<fNeta+1; i++) fEtaBinInTPCAcc++;
240     fEtaBinInEMCalAcc = 0;
241   }
242
243   if(fGrid==1){
244     for(Int_t i=0; i<fNphi+1; i++) {
245       fPhiBinInTPCAcc++;
246       if(fPhi->At(i) >= fPhiMin &&
247          fPhi->At(i) <= fPhiMax)
248         fPhiBinInEMCalAcc++;
249     }
250     for(Int_t i=0; i<fNeta+1; i++) {
251       fEtaBinInTPCAcc++;
252       if((fEta->At(i) >= fEtaMin) &&
253          (fEta->At(i) <= fEtaMax))
254         fEtaBinInEMCalAcc++;
255     }
256   }
257
258 }
259
260 //__________________________________________________________
261 TArrayD* AliJetGrid::GetArrayEta() 
262
263 // Returns an array with the eta points
264
265   return fEta;
266
267 }
268
269 //__________________________________________________________
270 TArrayD* AliJetGrid::GetArrayPhi() 
271
272 // Returns an array with the phi points
273
274   return fPhi;
275
276 }
277
278 //__________________________________________________________
279 TMatrixD* AliJetGrid::GetIndexObject()
280
281 // Returns a pointer to the matrix
282
283   return fIndex;
284
285 }
286
287 //__________________________________________________________
288 void AliJetGrid::GetAccParam(Int_t &nphi, Int_t &neta, Float_t &minphi, Float_t &maxphi, 
289                                 Float_t &mineta, Float_t &maxeta) const
290
291 // Returns EMCAL acceptance initially setted
292
293   nphi = fNphi;
294   neta = fNeta;
295   minphi = fPhiMin;
296   maxphi = fPhiMax;
297   mineta = fEtaMin;
298   maxeta = fEtaMax;
299 }
300
301 //__________________________________________________________
302 void AliJetGrid::GetBinParam(Int_t &phibintpc, Int_t &etabintpc, 
303                                 Int_t &phibinemc, Int_t &etabinemc, Int_t &nbinphi) const
304
305 // Returns number of bins in TPC and EMCAL geometry
306
307   etabintpc = fEtaBinInTPCAcc;
308   phibintpc = fPhiBinInTPCAcc;
309   etabinemc = fEtaBinInEMCalAcc;
310   phibinemc = fPhiBinInEMCalAcc;
311   nbinphi = fNbinPhi;
312 }
313
314 //__________________________________________________________
315 Int_t AliJetGrid::GetIndexFromEtaPhi(Double_t phi,Double_t eta) const 
316
317 // Tells the index value of a corresponding (eta,phi) real position
318 // Loop over all entries -> takes time.
319 // Used one time at the begining to fill the grids
320
321   /*   this is how bins are numbered
322    
323        in all TPC        or      in TPC - EMCAL
324                                 ... ... ... ..
325                                 ---------------
326           ...  ... .            10 |   |   | 11
327           ---+---+---           ---------------
328     ^      6 | 7 | 8     or      8 |   |   | 9 
329     |     ---+---+---           --------------- 
330            3 | 4 | 5             4 | 5 | 6 | 7
331    phi    ---+---+---           ---------------
332            0 | 1 | 2             0 | 1 | 2 | 3  
333
334        
335              eta ->
336   */
337
338   Int_t etaBin=0,phiBin=0,absID=0;
339   Int_t etaBin2=0,etaBin3=0;
340
341   // Fill all the grid in eta/phi (all TPC acceptance)
342   //-----------------------------------------------------
343   if(fGrid==0){ 
344     if(eta <= fEta->At(0)) {
345       etaBin = 0;
346     } else if(eta >= fEta->At(fNeta)) {
347       etaBin = fNeta;
348     } else {
349       for(Int_t i=0; i<fNeta+1; i++) {
350         if(eta < fEta->At(i)) {
351           etaBin = i-1;
352           break;
353         } 
354       }
355     }
356     if(phi <= fPhi->At(0)) {
357       phiBin = 0;
358     } else if(phi >= fPhi->At(fNphi)) {
359       phiBin = fNphi;
360     } else {
361       for(Int_t i=0; i<fNphi+1; i++) {
362         if(phi < fPhi->At(i)) {
363           phiBin = i-1;
364           break;
365         } 
366       }
367     }
368     
369     // Calculate absolute id
370     absID = phiBin*(fNeta+1) + etaBin;
371
372   }
373
374   // Fill the grid but do not count id in EMCal acceptance
375   //------------------------------------------------------
376   if((eta >= fEtaMin && eta <= fEtaMax) &&
377      (phi >= fPhiMin && phi <= fPhiMax)){
378     etaBin = etaBin2 = etaBin3 = -1;
379     phiBin = -1;
380   }  
381
382   if(fGrid == 1){ 
383     if(phi<fPhiMin) {
384       if(eta <= fEta->At(0)) {
385         etaBin = 0;
386       } else if(eta >= fEta->At(fNeta)) {
387         etaBin = fNeta;
388       } else {
389         for(Int_t i=0; i<fNeta+1; i++) {
390           if(eta < fEta->At(i)) {
391             etaBin = i-1;
392             break;
393           } 
394         }
395       }
396     }
397     else {
398       if((phi>=fPhiMin) && (phi<=fPhiMax)) {
399         if(eta <= fEta->At(0)) {
400           etaBin2 = 0;
401         } else if(eta >= fEta->At(fNeta)) {
402           etaBin2 = fNeta-fEtaBinInEMCalAcc;
403         } else {
404           for(Int_t i=0; i<fNeta+1; i++) {
405             if(eta < fEta->At(i) && ((fEta->At(0)<eta && eta<fEtaMin) || 
406                                      (fEtaMax<eta && eta<fEta->At(fNeta)))) {
407               //                 cout << "i : " << i << endl;
408               if(eta<fEtaMin)
409                 etaBin2 = i-1;
410               else etaBin2 = i-1-fEtaBinInEMCalAcc;
411               break;
412             } 
413           }
414         }
415       }
416       else {
417         if(eta <= fEta->At(0)) {
418           etaBin3 = 0;
419         } else if(eta >= fEta->At(fNeta)) {
420           etaBin3 = fNeta;
421         } else {
422           for(Int_t i=0; i<fNeta+1; i++) {
423             if(eta < fEta->At(i)) {
424               etaBin3 = i-1;
425               break;
426             } 
427           }
428         }
429       }
430     }
431     
432     if(phi <= fPhi->At(0)) {
433       phiBin = 0;
434     } else if(phi >= fPhi->At(fNphi)) {
435       phiBin = fNphi;
436     } else {
437       for(Int_t i=0; i<fNphi+1; i++) {
438         if(phi < fPhi->At(i)) {
439           phiBin = i-1;
440           break;
441         } 
442       }
443     }
444
445     // Calculate absID
446     //-------------------------------------------------------
447     if(phi<fPhiMin)      
448       absID = phiBin*(fNeta+1) + etaBin;
449     if(phi>=fPhiMin && phi<=fPhiMax) {
450       if(eta >= fEtaMin && eta <= fEtaMax) absID = -1;
451       else{
452         absID = (fNbinPhi+1)*(fNeta+1)
453           + (phiBin-fNbinPhi-1)*((fEtaBinInTPCAcc-fEtaBinInEMCalAcc))
454           + etaBin2;
455       }
456     }
457     if(phi>fPhiMax)
458       absID = (fNbinPhi+1)*(fNeta+1)
459         + fPhiBinInEMCalAcc*((fEtaBinInTPCAcc-fEtaBinInEMCalAcc)) 
460         + (phiBin-(fNbinPhi+1+fPhiBinInEMCalAcc))*(fNeta+1)
461         + etaBin3;
462     
463   } // END OPTION==1    
464   
465   return absID;
466   
467 }
468
469 //__________________________________________________________
470 void AliJetGrid::GetEtaPhiFromIndex(Int_t index, Float_t &eta, Float_t &phi)
471
472 // Get (eta,phi) position for a given index BUT loop over all entries (takes time)
473
474   for(Int_t j=0; j<fNphi+1; j++) {
475     for(Int_t i=0; i<fNeta+1; i++) {
476
477       // TPC grid only 
478       //-------------------------------------
479       if(fGrid==0) {    
480         if(j*(fNeta+1)+i == index) {
481           eta = fEta->At(i); 
482           phi = fPhi->At(j);
483         }
484       }
485
486       // TPC-EMCAL grid
487       //-------------------------------------
488       Int_t ii = 0;
489       if(i==0) ii = 0;
490       if(i>0 && i<(fEtaBinInTPCAcc-fEtaBinInEMCalAcc)/2) ii = i; 
491       if(i>=(fEtaBinInTPCAcc+fEtaBinInEMCalAcc)/2 && i<fNeta+1) ii = i-fEtaBinInEMCalAcc;
492
493       if(fGrid==1) {
494         if(j<(fNbinPhi+1) && j*(fNeta+1)+i == index) {
495           eta = fEta->At(i);
496           phi = fPhi->At(j);
497         }  
498
499         if((j>=(fNbinPhi+1) && j<(fNbinPhi+1+fPhiBinInEMCalAcc)) && 
500            ((fNbinPhi+1)*(fNeta+1) + (j-fNbinPhi-1)*(fEtaBinInTPCAcc-fEtaBinInEMCalAcc) + ii)== index ) {
501           if(ii==0) {Int_t ind = 0; eta = fEta->At(ind);}
502           else eta = fEta->At(i);
503           phi = fPhi->At(j);
504         }
505
506         if(j>=(fNbinPhi+1+fPhiBinInEMCalAcc) && 
507            ((fNbinPhi+1)*(fNeta+1)+fPhiBinInEMCalAcc*((fEtaBinInTPCAcc-fEtaBinInEMCalAcc))
508             +(j-(fNbinPhi+1+fPhiBinInEMCalAcc))*(fNeta+1)+i == index)) {
509           eta = fEta->At(i);
510           phi = fPhi->At(j);
511         }
512       }
513     }
514   }
515 }
516
517 //__________________________________________________________
518 Int_t AliJetGrid::GetIndex(Double_t phi, Double_t eta) 
519
520 // Get index value for a (eta,phi) position - Direct value
521
522   Int_t ieta = GetIndexJFromEta(eta);
523   Int_t iphi = GetIndexIFromPhi(phi);
524
525   Int_t index = GetMatrixIndex(iphi,ieta);
526
527   if(fDebug>10){
528     cout << "(phi,eta) : " << phi << ", " << eta << endl;
529     cout << "index : " << index << endl;
530   }
531   return index;
532
533 }
534
535 //__________________________________________________________
536 Int_t AliJetGrid::GetIndexJFromEta(Double_t eta)
537
538 // Get eta id
539 // Eta discretized
540
541   Int_t idEta =0;
542   Double_t temp = (eta+fMaxEta)/(fMaxEta-fMinEta)*fNeta;
543   if(fDebug>20)
544     {
545       cout << "eta : " << eta << endl;
546       cout << "fMaxEta : " << fMaxEta << endl;
547       cout << "fMinEta : " << fMinEta << endl;
548       cout << "fNeta : " << fNeta << endl;
549       cout << "temp eta before cast : " << temp << endl;
550     }
551   idEta = static_cast<Int_t>(temp+0.5);
552   if(fDebug>20) cout << "temp eta after cast : " << idEta << endl;
553   return idEta;
554 }
555 //__________________________________________________________
556 Int_t AliJetGrid::GetIndexIFromPhi(Double_t phi)
557
558 // Get phi id
559 // Phi discretized
560
561   Int_t idPhi = 0;
562   Double_t temp = 0.;
563   if(fMinPhi==0) temp = phi/(fMaxPhi-fMinPhi)*fNphi;
564   else temp = (phi-fMinPhi)/(fMaxPhi-fMinPhi)*fNphi;
565
566   if(fDebug>20)
567     {
568       cout << "phi : " << phi << endl;
569       cout << "fMaxPhi : " << fMaxPhi << endl;
570       cout << "fMinPhi : " << fMinPhi << endl;
571       cout << "fNphi : " << fNphi << endl;
572       cout << "temp phi before cast : " << temp << endl;
573     }
574   idPhi = static_cast<Int_t>(temp+0.5);
575   if(fDebug>20) cout << "temp phi after cast : " << idPhi << endl;
576   return idPhi;
577
578
579 }
580
581 //__________________________________________________________
582 void AliJetGrid::SetMatrixIndex(Int_t i,Double_t par) 
583
584 // Allows to set parameters using only one index (if fGrid==0) !!
585 // Not used !
586
587   Int_t iphi = (Int_t)i/fNeta;
588   Int_t ieta = i-iphi*fNeta;
589   SetMatrixIndex(iphi,ieta,par);
590
591   return;
592 }
593
594 //__________________________________________________________
595 void AliJetGrid::SetMatrixIndexes() 
596
597 // Fill the final matrix object with the corresponding index in eta/phi
598
599   for(Int_t i=0; i<fNphi+1; i++){
600     for(Int_t j=0; j<fNeta+1; j++){
601       (*fIndex)(i,j) = GetIndexFromEtaPhi(fPhi->At(i),fEta->At(j))+1;
602       if(fDebug>2){
603         cout << "(*fIndex)(" << i << "," << j << ") : " << (*fIndex)(i,j) << 
604           ", phi : " << fPhi->At(i) << ", eta : " << fEta->At(j) << endl;
605       }
606     }
607   }
608   printf("##########################################################\n");
609   printf("TMatrix object filled !\n");  
610   printf("Size of the object : phi x eta = (fNphi+1) x (fNeta+1) = %d\n",(fNphi+1)*(fNeta+1));
611   printf("##########################################################\n");
612 }
613
614 //__________________________________________________________
615 void AliJetGrid::SetIndexIJ()
616
617 // Set the grid index
618
619   for(Int_t i=0; i<fNphi+1; i++){
620     for(Int_t j=0; j<fNeta+1; j++){
621       Int_t id = static_cast<Int_t>((*fIndex)(i,j));
622
623       if(id!=-1)
624         {
625           (*fIndexI)[id] = i;
626           (*fIndexJ)[id] = j;
627         }
628     }
629   }
630
631   printf("##########################################################\n");
632   printf("     In SetIndexIJ - Grid indexes setted !\n");
633   printf("##########################################################\n");
634 }
635
636 //__________________________________________________________
637 void AliJetGrid::GetIJFromIndex(Int_t index, Int_t& i, Int_t& j) const
638
639 // Returns i position id of eta and j position id of phi for a given grid index
640   i = (*fIndexI)[index];
641   j = (*fIndexJ)[index];
642 }
643
644 //__________________________________________________________
645 void AliJetGrid::GetEtaPhiFromIndex2(Int_t index, Float_t &phi, Float_t &eta)
646
647 // Returns eta, phi values for a given grid index
648
649   phi = fPhi->At((*fIndexI)[index]);
650   eta = fEta->At((*fIndexJ)[index]);
651 }
652
653 //__________________________________________________________
654 Int_t AliJetGrid::GetNEntries()
655
656 // Returns the number of entries of the grid
657
658   if(fDebug>20){
659     cout << "fMaxPhi : " << fMaxPhi << endl;
660     cout << "fMaxEta : " << fMaxEta << endl;
661   }
662
663   Int_t indexNum = GetIndex(fMaxPhi,fMaxEta);
664   if(fDebug>20) cout << "indexNum : " << indexNum << endl;
665   return indexNum;
666
667 }
668
669 //__________________________________________________________
670 Int_t AliJetGrid::GetNEntries2()
671
672 // Returns the number of entries of the grid
673
674   Int_t indexNum = GetIndex(fMaxPhi-1.,fMaxEta-0.5);
675     if(fDebug>20) cout << "indexNum : " << indexNum << endl;
676   return indexNum;
677
678 }
679
680
681
682
683
684