1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
16 //-------------------------------------------------------------------------
18 // AOD reader for jet analysis
19 // This is the reader which must be used if the jet analysis task
20 // is executed after the ESD filter task, in order to read its output
22 // Author: Davide Perrino <davide.perrino@cern.ch>
25 // implemented standard geometry (AliEMCALGeometry) instead of dummy one (AliJetDummyGeo)
26 // moved geometry definition in AliJetReader
27 // marco.bregant@subatech.in2p3.fr
28 //-------------------------------------------------------------------------
31 #include <Riostream.h>
33 #include <TLorentzVector.h>
38 #include <TGeoManager.h>
39 #include <TGeoMatrix.h>
41 #include "AliJetAODReader.h"
42 #include "AliJetAODReaderHeader.h"
43 #include "AliAODEvent.h"
44 #include "AliAODTrack.h"
45 #include "AliAODMCParticle.h"
46 #include "AliEMCALGeometry.h"
47 #include "AliJetAODFillUnitArrayTracks.h"
48 #include "AliJetAODFillUnitArrayEMCalDigits.h"
49 #include "AliJetHadronCorrectionv1.h"
50 #include "AliJetUnitArray.h"
51 #include "AliOADBContainer.h"
55 ClassImp(AliJetAODReader)
57 AliJetAODReader::AliJetAODReader():
71 fApplyElectronCorrection(kFALSE),
72 fApplyMIPCorrection(kTRUE),
73 fApplyFractionHadronicCorrection(kFALSE),
74 fFractionHadronicCorrection(0.3),
88 //____________________________________________________________________________
90 AliJetAODReader::~AliJetAODReader()
108 //____________________________________________________________________________
110 void AliJetAODReader::OpenInputFiles()
112 // Open the necessary input files
113 // chain for the AODs
114 fChain = new TChain("aodTree");
116 // get directory and pattern name from the header
117 const char* dirName=fReaderHeader->GetDirectory();
118 const char* pattern=fReaderHeader->GetPattern();
120 // // Add files matching patters to the chain
122 void *dir = gSystem->OpenDirectory(dirName);
123 const char *name = 0x0;
124 int naod = ((AliJetAODReaderHeader*) fReaderHeader)->GetNaod();
126 while ((name = gSystem->GetDirEntry(dir))){
127 if (a>=naod) continue;
129 if (strstr(name,pattern)){
130 fChain->AddFile(Form("%s/%s/aod.root",dirName,name));
135 gSystem->FreeDirectory(dir);
138 fChain->SetBranchAddress("AOD",&fAOD);
140 int nMax = fChain->GetEntries();
142 printf("\n AliJetAODReader: Total number of events in chain= %d \n",nMax);
144 // set number of events in header
145 if (fReaderHeader->GetLastEvent() == -1)
146 fReaderHeader->SetLastEvent(nMax);
148 Int_t nUsr = fReaderHeader->GetLastEvent();
149 fReaderHeader->SetLastEvent(TMath::Min(nMax,nUsr));
153 //____________________________________________________________________________
155 void AliJetAODReader::ConnectTree(TTree* tree, TObject* /*data*/) {
157 // For AOD reader it's needed only to set the number of events
158 fChain = (TChain*) tree;
160 Int_t nMax = fChain->GetEntries();
161 printf("\n AliJetAODReader: Total number of events in chain= %5d \n", nMax);
162 // set number of events in header
163 if (fReaderHeader->GetLastEvent() == -1)
164 fReaderHeader->SetLastEvent(nMax);
166 Int_t nUsr = fReaderHeader->GetLastEvent();
167 fReaderHeader->SetLastEvent(TMath::Min(nMax,nUsr));
172 Bool_t AliJetAODReader::AcceptAODMCParticle(AliAODMCParticle *mcP,Short_t flag){
175 // filter for charge and for charged and neutral, no detector
177 // physical priamries already selected
179 Int_t pdg = TMath::Abs(mcP->GetPdgCode());
181 // exclude neutrinos anyway
182 if((pdg == 12 || pdg == 14 || pdg == 16)) return kFALSE;
184 if(flag==AliJetAODReaderHeader::kAllMC)return kTRUE;
185 if(flag==AliJetAODReaderHeader::kChargedMC){
186 if(mcP->Charge()==0)return kFALSE;
195 Bool_t AliJetAODReader::FillMomentumArrayMC(){
198 // This routine fetches the MC particles from the AOD
199 // Depending on the flag all particles except neurinos are use
200 // or only charged particles
203 TClonesArray *mcArray = (TClonesArray*)fAOD->FindListObject(AliAODMCParticle::StdBranchName());
205 Printf("%s:%d No MC particle branch found",(char*)__FILE__,__LINE__);
209 Int_t nMC = mcArray->GetEntriesFast();
211 // get number of tracks in event (for the loop)
212 if(fDebug>0)printf("AOD MC tracks: %5d \t", nMC);
214 // temporary storage of signal and pt cut flag
215 Int_t* sflag = new Int_t[nMC];
216 Int_t* cflag = new Int_t[nMC];
218 // get cuts set by user
219 Float_t ptMin = fReaderHeader->GetPtCut();
220 Float_t etaMin = fReaderHeader->GetFiducialEtaMin();
221 Float_t etaMax = fReaderHeader->GetFiducialEtaMax();
226 Short_t readerFlag = ((AliJetAODReaderHeader*)fReaderHeader)->GetReadAODMC();
229 for (Int_t it = 0; it < nMC; it++) {
230 AliAODMCParticle *track = (AliAODMCParticle*)mcArray->At(it);
231 if(!track->IsPhysicalPrimary())continue;
233 p3.SetXYZ(track->Px(),track->Py(),track->Pz());
235 if ( (eta > etaMax) || (eta < etaMin)) continue; // checking eta cut
236 if(!AcceptAODMCParticle(track,readerFlag))continue;
243 fRef->Delete(); // make sure to delete before placement new...
244 new(fRef) TRefArray(TProcessID::GetProcessWithUID(track));
246 new ((*fMomentumArray)[mcTrack]) TLorentzVector(p3,p3.Mag());
248 cflag[mcTrack] = ( pt > ptMin ) ? 1: 0;
252 if(fDebug>0)printf("Used MC tracks: %5d \n", mcTrack);
253 // set the signal flags
254 fSignalFlag.Set(mcTrack,sflag);
255 fCutFlag.Set(mcTrack,cflag);
263 //____________________________________________________________________________
265 Bool_t AliJetAODReader::FillMomentumArray()
267 // Clear momentum array
270 fDebug = fReaderHeader->GetDebug();
276 // get cuts set by user
277 Float_t ptMin = fReaderHeader->GetPtCut();
278 Float_t etaMin = fReaderHeader->GetFiducialEtaMin();
279 Float_t etaMax = fReaderHeader->GetFiducialEtaMax();
280 UInt_t filterMask = ((AliJetAODReaderHeader*)fReaderHeader)->GetTestFilterMask();
282 // ----- number of tracks -----
283 Int_t nTracksStd = 0;
284 Short_t mcReaderFlag = ((AliJetAODReaderHeader*)fReaderHeader)->GetReadAODMC();
285 TClonesArray *mcArray = 0x0;
286 // check if we have to read from MC branch
287 if (((AliJetAODReaderHeader*)fReaderHeader)->GetReadStdBranch()) {
289 mcArray = (TClonesArray*)fAOD->FindListObject(AliAODMCParticle::StdBranchName());
291 Printf("%s:%d No MC particle branch found",(char*)__FILE__,__LINE__);
293 nTracksStd = mcArray->GetEntriesFast();
296 nTracksStd = fAOD->GetNTracks();
297 // printf("no. of standard tracks: %i\n", nTracksStd);
300 Int_t nTracksNonStd = 0;
301 TClonesArray *nonStdTracks = 0x0;
302 if (((AliJetAODReaderHeader*)fReaderHeader)->GetReadNonStdBranch()) {
304 (TClonesArray*) fAOD->FindListObject(((AliJetAODReaderHeader*)fReaderHeader)->GetNonStdBranch());
306 nTracksNonStd = nonStdTracks->GetEntries();
307 // printf("no. of non-standard tracks: %i\n", nTracksNonStd);
309 Int_t nTracks = nTracksStd + nTracksNonStd;
311 // temporary storage of signal and pt cut flag
312 Int_t* sflag = new Int_t[nTracks];
313 Int_t* cflag = new Int_t[nTracks];
320 // ----- looping over standard branch -----
322 for (Int_t iTrack = 0; iTrack < nTracksStd; iTrack++) {
323 AliAODMCParticle *track = (AliAODMCParticle*)mcArray->At(iTrack);
324 if(!track->IsPhysicalPrimary())continue;
326 p3.SetXYZ(track->Px(),track->Py(),track->Pz());
328 if ( (eta > etaMax) || (eta < etaMin)) continue; // checking eta cut
329 if(!AcceptAODMCParticle(track,mcReaderFlag))continue;
333 fRef->Delete(); // make sure to delete before placement new...
334 new(fRef) TRefArray(TProcessID::GetProcessWithUID(track));
336 new ((*fMomentumArray)[aodTrack]) TLorentzVector(p3,p3.Mag());
338 cflag[aodTrack] = ( pt > ptMin ) ? 1: 0;
344 for (Int_t iTrack = 0; iTrack < nTracksStd; iTrack++) {
345 AliAODTrack *track = fAOD->GetTrack(iTrack);
346 UInt_t status = track->GetStatus();
348 Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
349 p3.SetXYZ(mom[0],mom[1],mom[2]);
352 if (status == 0) continue;
353 if((filterMask>0)&&!(track->TestFilterBit(filterMask)))continue;
354 if ( (eta > etaMax) || (eta < etaMin)) continue; // checking eta cut
357 fRef->Delete(); // make sure to delete before placement new...
358 new(fRef) TRefArray(TProcessID::GetProcessWithUID(track));
360 new ((*fMomentumArray)[aodTrack]) TLorentzVector(p3,p3.Mag());
361 sflag[aodTrack] = (TMath::Abs(track->GetLabel()) < 10000) ? 1 : 0;
362 cflag[aodTrack] = ( pt > ptMin ) ? 1: 0;
368 // ----- reading of non-standard branch -----
369 for (Int_t iTrack = 0; iTrack < nTracksNonStd; iTrack++) {
370 AliVParticle *track = dynamic_cast<AliVParticle*> ((*nonStdTracks)[iTrack]);
374 Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
375 p3.SetXYZ(mom[0],mom[1],mom[2]);
379 // which cuts to apply if not AOD track (e.g. MC) ???
380 AliAODTrack *trackAOD = dynamic_cast<AliAODTrack*> (track);
382 if (trackAOD->GetStatus() == 0)
384 if ((filterMask > 0) && !(trackAOD->TestFilterBit(filterMask)))
387 if ((eta > etaMax) || (eta < etaMin)) continue; // checking eta cut
390 fRef->Delete(); // make sure to delete before placement new...
391 new(fRef) TRefArray(TProcessID::GetProcessWithUID(track));
393 new ((*fMomentumArray)[aodTrack]) TLorentzVector(p3,p3.Mag());
394 sflag[aodTrack] = (TMath::Abs(track->GetLabel()) < 10000) ? 1 : 0;
395 cflag[aodTrack] = ( pt > ptMin ) ? 1 : 0;
398 // printf("added non-standard track\n");
401 // set the signal flags
402 fSignalFlag.Set(aodTrack,sflag);
403 fCutFlag.Set(aodTrack,cflag);
411 //__________________________________________________________
412 void AliJetAODReader::SetApplyMIPCorrection(Bool_t val)
415 // Set flag to apply MIP correction fApplyMIPCorrection
416 // - exclusive with fApplyFractionHadronicCorrection
419 fApplyMIPCorrection = val;
420 if(fApplyMIPCorrection == kTRUE)
422 SetApplyFractionHadronicCorrection(kFALSE);
423 printf("Enabling MIP Correction \n");
427 printf("Disabling MIP Correction \n");
431 //__________________________________________________________
432 void AliJetAODReader::SetApplyFractionHadronicCorrection(Bool_t val)
435 // Set flag to apply EMC hadronic correction fApplyFractionHadronicCorrection
436 // - exclusive with fApplyMIPCorrection
439 fApplyFractionHadronicCorrection = val;
440 if(fApplyFractionHadronicCorrection == kTRUE)
442 SetApplyMIPCorrection(kFALSE);
443 printf("Enabling Fraction Hadronic Correction \n");
447 printf("Disabling Fraction Hadronic Correction \n");
451 //__________________________________________________________
452 void AliJetAODReader::SetFractionHadronicCorrection(Double_t val)
455 // Set value to fFractionHadronicCorrection (default is 0.3)
456 // apply EMC hadronic correction fApplyFractionHadronicCorrection
457 // - exclusive with fApplyMIPCorrection
460 fFractionHadronicCorrection = val;
461 if(fFractionHadronicCorrection > 0.0 && fFractionHadronicCorrection <= 1.0)
463 SetApplyFractionHadronicCorrection(kTRUE);
464 printf("Fraction Hadronic Correction %1.3f \n",fFractionHadronicCorrection);
468 SetApplyFractionHadronicCorrection(kFALSE);
472 //____________________________________________________________________________
473 void AliJetAODReader::CreateTasks(TChain* tree)
476 // For reader task initialization
479 fDebug = fReaderHeader->GetDebug();
480 fDZ = fReaderHeader->GetDZ();
483 // Init EMCAL geometry, if needed
486 else Info(" SetEMCALGeometry","was already done.. it's called just once !!");
491 fFillUnitArray = new TTask("fFillUnitArray","Fill unit array jet finder");
492 fFillUAFromTracks = new AliJetAODFillUnitArrayTracks();
493 fFillUAFromTracks->SetReaderHeader(fReaderHeader);
494 fFillUAFromTracks->SetGeom(fGeom);
495 fFillUAFromTracks->SetTPCGrid(fTpcGrid);
496 fFillUAFromTracks->SetEMCalGrid(fEmcalGrid);
500 fFillUAFromTracks->SetGrid0(fGrid0);
501 fFillUAFromTracks->SetGrid1(fGrid1);
502 fFillUAFromTracks->SetGrid2(fGrid2);
503 fFillUAFromTracks->SetGrid3(fGrid3);
504 fFillUAFromTracks->SetGrid4(fGrid4);
506 fFillUAFromTracks->SetApplyMIPCorrection(fApplyMIPCorrection);
507 fFillUAFromTracks->SetHadCorrector(fHadCorr);
508 fFillUAFromEMCalDigits = new AliJetAODFillUnitArrayEMCalDigits();
509 fFillUAFromEMCalDigits->SetReaderHeader(fReaderHeader);
510 fFillUAFromEMCalDigits->SetGeom(fGeom);
511 fFillUAFromEMCalDigits->SetTPCGrid(fTpcGrid);
512 fFillUAFromEMCalDigits->SetEMCalGrid(fEmcalGrid);
513 fFillUAFromEMCalDigits->SetApplyFractionHadronicCorrection(fApplyFractionHadronicCorrection);
514 fFillUAFromEMCalDigits->SetFractionHadronicCorrection(fFractionHadronicCorrection);
515 fFillUAFromEMCalDigits->SetApplyElectronCorrection(fApplyElectronCorrection);
516 // Add the task to global task
517 fFillUnitArray->Add(fFillUAFromTracks);
518 fFillUnitArray->Add(fFillUAFromEMCalDigits);
519 fFillUAFromTracks->SetActive(kFALSE);
520 fFillUAFromEMCalDigits->SetActive(kFALSE);
522 cout << "Tasks instantiated at that stage ! " << endl;
523 cout << "You can loop over events now ! " << endl;
527 //____________________________________________________________________________
528 Bool_t AliJetAODReader::ExecTasks(Bool_t procid, TRefArray* refArray)
532 // Fill the reader part
536 fRefArray = refArray;
537 //(not used ?) Int_t nEntRef = fRefArray->GetEntries();
538 //(not used ?) Int_t nEntUnit = fUnitArray->GetEntries();
540 // clear momentum array
544 fDebug = fReaderHeader->GetDebug();
545 fOpt = fReaderHeader->GetDetector();
551 // TPC only or Digits+TPC or Clusters+TPC
552 if(fOpt%2==!0 && fOpt!=0){
553 fFillUAFromTracks->SetAOD(fAOD);
554 fFillUAFromTracks->SetActive(kTRUE);
555 fFillUAFromTracks->SetUnitArray(fUnitArray);
556 fFillUAFromTracks->SetRefArray(fRefArray);
557 fFillUAFromTracks->SetReferences(fRef);
558 fFillUAFromTracks->SetSignalFlag(fSignalFlag);
559 fFillUAFromTracks->SetCutFlag(fCutFlag);
560 fFillUAFromTracks->SetProcId(fProcId);
561 // fFillUAFromTracks->ExecuteTask("tpc"); // => Temporarily changed
562 fFillUAFromTracks->Exec("tpc");
564 fNumCandidate = fFillUAFromTracks->GetMult();
565 fNumCandidateCut = fFillUAFromTracks->GetMultCut();
567 fSignalFlag = fFillUAFromTracks->GetSignalFlag();
568 fCutFlag = fFillUAFromTracks->GetCutFlag();
571 // Digits only or Digits+TPC
572 if(fOpt>=2 && fOpt<=3){
573 fFillUAFromEMCalDigits->SetAOD(fAOD);
574 fFillUAFromEMCalDigits->SetActive(kTRUE);
575 fFillUAFromEMCalDigits->SetUnitArray(fUnitArray);
576 fFillUAFromEMCalDigits->SetRefArray(fRefArray);
577 fFillUAFromEMCalDigits->SetProcId(fFillUAFromTracks->GetProcId());
578 fFillUAFromEMCalDigits->SetInitMult(fFillUAFromTracks->GetMult());
579 fFillUAFromEMCalDigits->SetInitMultCut(fFillUAFromTracks->GetMultCut());
580 fFillUAFromEMCalDigits->Exec("digits"); // => Temporarily added
581 fNumCandidate = fFillUAFromEMCalDigits->GetMult();
582 fNumCandidateCut = fFillUAFromEMCalDigits->GetMultCut();
585 // fFillUnitArray->ExecuteTask(); // => Temporarily commented
592 //____________________________________________________________________________
593 void AliJetAODReader::InitParameters()
595 // Initialise parameters
596 fOpt = fReaderHeader->GetDetector();
597 fNumUnits = fGeom->GetEMCGeometry()->GetNCells(); // Number of cells in EMCAL
598 if(fDebug>1) printf("\n EMCal parameters initiated ! \n");
601 //____________________________________________________________________________
602 void AliJetAODReader::InitUnitArray()
604 //Initialises unit arrays
605 Int_t nElements = fTpcGrid->GetNEntries();
606 Float_t eta = 0., phi = 0., deltaEta = 0., deltaPhi = 0.;
607 if(fArrayInitialised) fUnitArray->Delete();
609 if(fTpcGrid->GetGridType()==0)
610 { // Fill the following quantities :
611 // Good track ID, (Eta,Phi) position ID, eta, phi, energy, px, py, pz, deltaEta, deltaPhi,
612 // detector flag, in/out jet, pt cut, mass, cluster ID)
613 for(Int_t nBin = 1; nBin < nElements+1; nBin++)
615 // fTpcGrid->GetEtaPhiFromIndex2(nBin,eta,phi);
616 fTpcGrid->GetEtaPhiFromIndex2(nBin,phi,eta);
617 phi = ((phi < 0) ? phi + 2. * TMath::Pi() : phi);
618 deltaEta = fTpcGrid->GetDeta();
619 deltaPhi = fTpcGrid->GetDphi();
620 new ((*fUnitArray)[nBin-1]) AliJetUnitArray(nBin-1,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
624 if(fTpcGrid->GetGridType()==1)
627 Int_t n0 = 0, n1 = 0, n2 = 0, n3 = 0, n4 = 0;
631 // Define a grid of cell for the gaps between SM
632 Double_t phimin0 = 0., phimin1 = 0., phimin2 = 0., phimin3 = 0., phimin4 = 0.;
633 Double_t phimax0 = 0., phimax1 = 0., phimax2 = 0., phimax3 = 0., phimax4 = 0.;
634 fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(0,phimin0,phimax0);
635 fGrid0 = new AliJetGrid(0,95,phimin0,phimax0,-0.7,0.7); // 0.015 x 0.015
636 fGrid0->SetGridType(0);
637 fGrid0->SetMatrixIndexes();
638 fGrid0->SetIndexIJ();
639 n0 = fGrid0->GetNEntries();
640 fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(1,phimin1,phimax1);
641 fGrid1 = new AliJetGrid(0,95,phimin1,phimax1,-0.7,0.7); // 0.015 x 0.015
642 fGrid1->SetGridType(0);
643 fGrid1->SetMatrixIndexes();
644 fGrid1->SetIndexIJ();
645 n1 = fGrid1->GetNEntries();
646 fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(2,phimin2,phimax2);
647 fGrid2 = new AliJetGrid(0,95,phimin2,phimax2,-0.7,0.7); // 0.015 x 0.015
648 fGrid2->SetGridType(0);
649 fGrid2->SetMatrixIndexes();
650 fGrid2->SetIndexIJ();
651 n2 = fGrid2->GetNEntries();
652 fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(3,phimin3,phimax3);
653 fGrid3 = new AliJetGrid(0,95,phimin3,phimax3,-0.7,0.7); // 0.015 x 0.015
654 fGrid3->SetGridType(0);
655 fGrid3->SetMatrixIndexes();
656 fGrid3->SetIndexIJ();
657 n3 = fGrid3->GetNEntries();
658 fGeom->GetEMCGeometry()->GetPhiBoundariesOfSMGap(4,phimin4,phimax4);
659 fGrid4 = new AliJetGrid(0,95,phimin4,phimax4,-0.7,0.7); // 0.015 x 0.015
660 fGrid4->SetGridType(0);
661 fGrid4->SetMatrixIndexes();
662 fGrid4->SetIndexIJ();
663 n4 = fGrid4->GetNEntries();
665 nGaps = n0+n1+n2+n3+n4;
669 for(Int_t nBin = 0; nBin < fNumUnits+nElements+nGaps; nBin++)
673 fGeom->EtaPhiFromIndex(nBin, eta, phi); // From EMCal geometry
674 // fEmcalGrid->GetEtaPhiFromIndex2(nBin,phi,eta); // My function from Grid
675 phi = ((phi < 0) ? phi + 2. * TMath::Pi() : phi);
676 deltaEta = fEmcalGrid->GetDeta(); // Modify with the exact detector values
677 deltaPhi = fEmcalGrid->GetDphi(); // Modify with the exact detector values
678 new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
681 if(nBin>=fNumUnits && nBin<fNumUnits+nElements){
682 fTpcGrid->GetEtaPhiFromIndex2(nBin+1-fNumUnits,phi,eta);
683 phi = ((phi < 0) ? phi + 2. * TMath::Pi() : phi);
684 deltaEta = fTpcGrid->GetDeta();
685 deltaPhi = fTpcGrid->GetDphi();
686 new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
690 if(nBin>=fNumUnits+nElements && nBin<fNumUnits+nElements+nGaps){
691 if(nBin<fNumUnits+nElements+n0)
694 fGrid0->GetEtaPhiFromIndex2(nBin+1-(fNumUnits+nElements),phi,eta);
695 deltaEta = fGrid0->GetDeta();
696 deltaPhi = fGrid0->GetDphi();
697 new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
699 else if(nBin>=fNumUnits+nElements+n0 && nBin<fNumUnits+nElements+n0+n1)
702 fGrid1->GetEtaPhiFromIndex2(nBin+1-(fNumUnits+nElements+n0),phi,eta);
703 deltaEta = fGrid1->GetDeta();
704 deltaPhi = fGrid1->GetDphi();
705 new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
707 else if(nBin>=fNumUnits+nElements+n0+n1 && nBin<fNumUnits+nElements+n0+n1+n2)
710 fGrid2->GetEtaPhiFromIndex2(nBin+1-(fNumUnits+nElements+n0+n1),phi,eta);
711 deltaEta = fGrid2->GetDeta();
712 deltaPhi = fGrid2->GetDphi();
713 new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
715 else if(nBin>=fNumUnits+nElements+n0+n1+n2 && nBin<fNumUnits+nElements+n0+n1+n2+n3)
718 fGrid3->GetEtaPhiFromIndex2(nBin+1-(fNumUnits+nElements+n0+n1+n2),phi,eta);
719 deltaEta = fGrid3->GetDeta();
720 deltaPhi = fGrid3->GetDphi();
721 new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
723 else if(nBin>=fNumUnits+nElements+n0+n1+n2+n3 && nBin<fNumUnits+nElements+nGaps)
726 fGrid4->GetEtaPhiFromIndex2(nBin+1-(fNumUnits+nElements+n0+n1+n2+n3),phi,eta);
727 deltaEta = fGrid4->GetDeta();
728 deltaPhi = fGrid4->GetDphi();
729 new ((*fUnitArray)[nBin]) AliJetUnitArray(nBin,0,eta,phi,0.,deltaEta,deltaPhi,kTpc,kOutJet,kPtSmaller,kPtSmaller,kBad,0.,-1);
735 } // end loop on nBin
736 } // end grid type == 1
737 fArrayInitialised = 1;