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