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