JETAN/AliJetESDFillUnitArrayTracks.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, 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
  17 //======================================================================
  18 // ***July 2006
  19 // Fill Unit Array class
  20 // Class used by AliJetESDReader to fill a UnitArray from the information extracted
  21 // from the particle tracks
  22 // Author: magali.estienne@ires.in2p3.fr
  23 //======================================================================
  24
  25
  26 // --- ROOT system ---
  27 #include <TVector3.h>
  28 #include <TProcessID.h>
  29
  30 // --- AliRoot header files ---
  31 #include "AliJetUnitArray.h"
  32 #include "AliJetESDFillUnitArrayTracks.h"
  33
  34 // --- ROOT system ---
  35 class TSystem;
  36 class TLorentzVector;
  37 class TGeoManager;
  38
  39 // --- AliRoot header files ---
  40 class AliJetFinder;
  41 class AliJetReader;
  42 class AliJetESDReader;
  43
  44 ClassImp(AliJetESDFillUnitArrayTracks)
  45
  46 //_____________________________________________________________________________
  47 AliJetESDFillUnitArrayTracks::AliJetESDFillUnitArrayTracks()
  48   : AliJetFillUnitArray(),
  49     fNumUnits(0),
  50     fHadCorr(0),
  51     fApplyMIPCorrection(kTRUE),
  52     fESD(0x0),
  53     fGrid0(0x0),
  54     fGrid1(0x0),
  55     fGrid2(0x0),
  56     fGrid3(0x0),
  57     fGrid4(0x0)
  58 {
  59   // constructor
  60 }
  61
  62 //_____________________________________________________________________________
  63 AliJetESDFillUnitArrayTracks::AliJetESDFillUnitArrayTracks(AliESDEvent* esd)
  64   : AliJetFillUnitArray(),
  65     fNumUnits(0),
  66     fHadCorr(0),
  67     fApplyMIPCorrection(kTRUE),
  68     fESD(esd),
  69     fGrid0(0x0),
  70     fGrid1(0x0),
  71     fGrid2(0x0),
  72     fGrid3(0x0),
  73     fGrid4(0x0)
  74 {
  75   // constructor
  76 }
  77
  78 //_____________________________________________________________________________
  79 AliJetESDFillUnitArrayTracks::AliJetESDFillUnitArrayTracks(const AliJetESDFillUnitArrayTracks &det)
  80   : AliJetFillUnitArray(det),
  81     fNumUnits(det.fNumUnits),
  82     fHadCorr(det.fHadCorr),
  83     fApplyMIPCorrection(det.fApplyMIPCorrection),
  84     fESD(det.fESD),
  85     fGrid0(det.fGrid0),
  86     fGrid1(det.fGrid1),
  87     fGrid2(det.fGrid2),
  88     fGrid3(det.fGrid3),
  89     fGrid4(det.fGrid4)
  90 {
  91   // Copy constructor
  92 }
  93
  94 //------------------------------------------------------------------
  95 AliJetESDFillUnitArrayTracks& AliJetESDFillUnitArrayTracks::operator=(const AliJetESDFillUnitArrayTracks& other)
  96 {
  97   // Assignment
  98
  99     fNumUnits = other.fNumUnits;
 100     fHadCorr = other.fHadCorr;
 101     fApplyMIPCorrection = other.fApplyMIPCorrection;
 102     fESD = other.fESD;
 103     fGrid0 = other.fGrid0;
 104     fGrid1 = other.fGrid1;
 105     fGrid2 = other.fGrid2;
 106     fGrid3 = other.fGrid3;
 107     fGrid4 = other.fGrid4;
 108
 109     return (*this);
 110 }
 111
 112 //____________________________________________________________________________
 113 void AliJetESDFillUnitArrayTracks::InitParameters()
 114 {
 115   fHadCorr        = 0;                 // For hadron correction
 116   fNumUnits = fGeom->GetNCells();      // Number of towers in EMCAL
 117   cout << "In AliJetESDFillUnitArrayTracks:InitParameters(), Ncells : " << fNumUnits << endl;
 118
 119   fTPCGrid->GetAccParam(fNphi,fNeta,fPhiMin,
 120                         fPhiMax,fEtaMin,fEtaMax);
 121   fTPCGrid->GetBinParam(fPhiBinInTPCAcc,fEtaBinInTPCAcc,
 122                         fPhiBinInEMCalAcc,fEtaBinInEMCalAcc,fNbinPhi);
 123
 124   fIndex = fTPCGrid->GetIndexObject();
 125
 126   if(fDebug>20){
 127     for(Int_t i=0; i<fNphi+1; i++)
 128       for(Int_t j=0; j<fNeta+1; j++) {cout << "fIndex[" << i << "," << j << "] : " <<
 129           (*fIndex)(i,j) << endl; }
 130   }
 131   if(fDebug>1) printf("\n Parameters initiated ! \n");
 132 }
 133
 134 //_____________________________________________________________________________
 135 AliJetESDFillUnitArrayTracks::~AliJetESDFillUnitArrayTracks()
 136 {
 137   // destructor
 138 }
 139
 140 //_____________________________________________________________________________
 141 void AliJetESDFillUnitArrayTracks::Exec(Option_t* const /*option*/)
 142 {
 143   //
 144   // Main method.
 145   // Fill the unit array with the charged particle information in ESD
 146   //
 147
 148   fDebug = fReaderHeader->GetDebug();
 149
 150   // Set parameters
 151   InitParameters();
 152
 153   // get number of tracks in event (for the loop)
 154   Int_t goodTrack = 0;
 155   Int_t nt = 0;
 156 //(not used ?)  Int_t nt2 = 0;
 157   Int_t nmax = 0;
 158   Float_t pt,eta,phi;
 159   //  Int_t sflag = 0;
 160   TVector3 p3;
 161
 162   if(fDebug>1) cout << "fESD in Fill array : " << fESD << endl;
 163
 164   nt = fESD->GetNumberOfTracks();
 165   if(fDebug>1) cout << "Number of Tracks in ESD : " << nt << endl;
 166
 167   // temporary storage of signal and pt cut flag
 168   Int_t* sflag  = new Int_t[nt];
 169   Int_t* cflag  = new Int_t[nt];
 170
 171   // get cuts set by user
 172   Float_t ptMin  = fReaderHeader->GetPtCut();
 173   Float_t etaMin = fReaderHeader->GetFiducialEtaMin();
 174   Float_t etaMax = fReaderHeader->GetFiducialEtaMax();
 175   fOpt = fReaderHeader->GetDetector();
 176   fDZ  = fReaderHeader->GetDZ();
 177
 178   Int_t nTracksEmcal      = 0;
 179   Int_t nTracksEmcalDZ    = 0;
 180   Int_t nTracksTpc        = 0;
 181   Int_t nTracksTpcOnly    = 0;
 182   Int_t nTracksEmcalCut   = 0;
 183   Int_t nTracksEmcalDZCut = 0;
 184   Int_t nTracksTpcCut     = 0;
 185   Int_t nTracksTpcOnlyCut = 0;
 186
 187 //(not used ?)  Int_t nElements  = fTPCGrid->GetNEntries();
 188 //(not used ?)  Int_t nElements2 = fEMCalGrid->GetNEntries();
 189   fGrid = fTPCGrid->GetGridType();
 190
 191 //(not used ?)  Int_t nEntries = fUnitArray->GetEntries();
 192
 193 //(not used ?)  Int_t nRefEnt = fRefArray->GetEntries();
 194
 195   //loop over tracks
 196     nmax = nt;
 197     for (Int_t it = 0; it < nmax; it++) {
 198       AliESDtrack *track;
 199       track = fESD->GetTrack(it);
 200       UInt_t status = track->GetStatus();
 201
 202       Double_t mom[3];
 203       track->GetPxPyPz(mom);
 204
 205       p3.SetXYZ(mom[0],mom[1],mom[2]);
 206       pt = p3.Pt();
 207
 208       Float_t mass = 0.;
 209       mass = track->GetMass();
 210
 211       if ((status & AliESDtrack::kTPCrefit) == 0)    continue;      // quality check
 212       if ((status & AliESDtrack::kITSrefit) == 0)    continue;      // quality check
 213       if (((AliJetESDReaderHeader*) fReaderHeader)->ReadSignalOnly()
 214           && TMath::Abs(track->GetLabel()) > 10000)  continue;   // quality check
 215       if (((AliJetESDReaderHeader*) fReaderHeader)->ReadBkgdOnly()
 216           && TMath::Abs(track->GetLabel()) < 10000)  continue;   // quality check
 217        eta = p3.Eta();
 218        phi = ( (p3.Phi()) < 0) ? (p3.Phi()) + 2. * TMath::Pi() : (p3.Phi());
 219
 220       if ( (eta > etaMax) || (eta < etaMin)) continue;           // checking eta cut
 221
 222       sflag[goodTrack]=0;
 223       if (TMath::Abs(track->GetLabel()) < 10000) sflag[goodTrack]=1;
 224       cflag[goodTrack]=0;
 225       if (pt > ptMin) cflag[goodTrack]=1;                       // pt cut
 226
 227       if(fGrid==0)
 228         {
 229           // Only TPC filled from its grid in its total acceptance
 230
 231           Int_t idTPC = fTPCGrid->GetIndex(phi,eta);
 232           Bool_t ok = kFALSE;
 233           Bool_t ref = kFALSE;
 234
 235           AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(idTPC-1);
 236           TRefArray *reference = uArray->GetUnitTrackRef();
 237           if (reference->GetEntries() == 0)  {
 238               new(reference) TRefArray(TProcessID::GetProcessWithUID(track));
 239           }
 240
 241           reference->Add(track);
 242
 243           Float_t unitEnergy = 0.;
 244           unitEnergy = uArray->GetUnitEnergy();
 245           // nTracksTpcOnly is necessary to count the number of candidate cells
 246           // but it doesn't give the real multiplicity -> it will be extracted
 247           // in the jet finder through the reference to tracks
 248           if(unitEnergy==0.){
 249             nTracksTpcOnly++;
 250             ok = kTRUE;
 251             ref = kTRUE;
 252           }
 253
 254           // Fill energy in TPC acceptance
 255           uArray->SetUnitEnergy(unitEnergy + pt);
 256           uArray->SetUnitMass(mass);
 257
 258           // Pt cut flag
 259           if(uArray->GetUnitEnergy()<ptMin){
 260             uArray->SetUnitCutFlag(kPtSmaller);
 261           }
 262           else {
 263             uArray->SetUnitCutFlag(kPtHigher);
 264             if(ok) nTracksTpcOnlyCut++;
 265           }
 266
 267           // Signal flag
 268           if(sflag[goodTrack] == 1) {
 269             uArray->SetUnitSignalFlag(kGood);
 270             uArray->SetUnitSignalFlagC(kFALSE,kGood);
 271           } else uArray->SetUnitSignalFlagC(kFALSE,kBad);
 272
 273           if(uArray->GetUnitEnergy()>0 && ref){
 274             if(!fProcId) {
 275               fProcId = kTRUE;
 276               new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
 277             }
 278             fRefArray->Add(uArray);
 279           }
 280         }
 281
 282       if(fGrid==1)
 283         {
 284           Int_t nElements = fTPCGrid->GetNEntries();
 285           // Fill track information in EMCAL acceptance
 286             if((eta >= fEtaMin && eta <= fEtaMax) &&
 287              (phi >= fPhiMin && phi <= fPhiMax))// &&
 288             {
 289
 290               // Include dead-zones
 291               if(fDZ)
 292                 {
 293                   Double_t phimin0 = 0., phimin1 = 0., phimin2 = 0., phimin3 = 0., phimin4 = 0.;
 294                   Double_t phimax0 = 0., phimax1 = 0., phimax2 = 0., phimax3 = 0., phimax4 = 0.;
 295                   fGeom->GetPhiBoundariesOfSMGap(0,phimin0,phimax0);
 296                   fGeom->GetPhiBoundariesOfSMGap(1,phimin1,phimax1);
 297                   fGeom->GetPhiBoundariesOfSMGap(2,phimin2,phimax2);
 298                   fGeom->GetPhiBoundariesOfSMGap(3,phimin3,phimax3);
 299                   fGeom->GetPhiBoundariesOfSMGap(4,phimin4,phimax4);
 300                   Int_t n0 = fGrid0->GetNEntries();
 301                   Int_t n1 = fGrid1->GetNEntries();
 302                   Int_t n2 = fGrid2->GetNEntries();
 303                   Int_t n3 = fGrid3->GetNEntries();
 304 //(not used ?)            Int_t n4 = fGrid4->GetNEntries();
 305
 306                   if(phi >= phimin0 && phi <= phimax0){
 307                     Int_t id0 = fGrid0->GetIndex(phi,eta)-1;
 308                     AliJetUnitArray *uArray0 = (AliJetUnitArray*)fUnitArray->At(id0+fNumUnits+nElements);
 309                     TRefArray *reference0 = uArray0->GetUnitTrackRef();
 310                     if (reference0->GetEntries() == 0)  {
 311                         new(reference0) TRefArray(TProcessID::GetProcessWithUID(track));
 312                     }
 313
 314                     reference0->Add(track);
 315
 316                     Float_t uEnergy0 = uArray0->GetUnitEnergy();
 317                     Bool_t ok0 = kFALSE;
 318                     Bool_t ref0 = kFALSE;
 319                     if(uEnergy0==0.){
 320                       nTracksEmcalDZ++;
 321                       ok0 = kTRUE;
 322                       ref0 = kTRUE;
 323                     }
 324                     uArray0->SetUnitEnergy(uEnergy0+pt);
 325
 326                     if(uArray0->GetUnitEnergy()<ptMin)
 327                       uArray0->SetUnitCutFlag(kPtSmaller);
 328                     else {
 329                       uArray0->SetUnitCutFlag(kPtHigher);
 330                       if(ok0) nTracksEmcalDZCut++;
 331                     }
 332                     if(sflag[goodTrack] == 1) {
 333                       uArray0->SetUnitSignalFlag(kGood);
 334                       uArray0->SetUnitSignalFlagC(kFALSE,kGood);
 335                     } else uArray0->SetUnitSignalFlagC(kFALSE,kBad);
 336
 337                     if(uArray0->GetUnitEnergy()>0 && ref0){
 338                       if(!fProcId){
 339                         new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray0));
 340                         fProcId = kTRUE;
 341                       }
 342                       fRefArray->Add(uArray0);
 343                     }
 344                   }
 345
 346                   if(phi >= phimin1 && phi <= phimax1){
 347                     Int_t id1 = fGrid1->GetIndex(phi,eta)-1+n0;
 348                     AliJetUnitArray *uArray1 = (AliJetUnitArray*)fUnitArray->At(id1+fNumUnits+nElements);
 349                     TRefArray *reference1 = uArray1->GetUnitTrackRef();
 350                     if (reference1->GetEntries() == 0)  {
 351                         new(reference1) TRefArray(TProcessID::GetProcessWithUID(track));
 352                     }
 353
 354                     reference1->Add(track);
 355
 356                     Float_t uEnergy1 = uArray1->GetUnitEnergy();
 357                     Bool_t ok1 = kFALSE;
 358                     Bool_t ref1 = kFALSE;
 359                     if(uEnergy1==0.){
 360                       nTracksEmcalDZ++;
 361                       ok1 = kTRUE;
 362                       ref1 = kTRUE;
 363                     }
 364                     uArray1->SetUnitEnergy(uEnergy1+pt);
 365
 366                     if(uArray1->GetUnitEnergy()<ptMin)
 367                       uArray1->SetUnitCutFlag(kPtSmaller);
 368                     else {
 369                       uArray1->SetUnitCutFlag(kPtHigher);
 370                       if(ok1) nTracksEmcalDZCut++;
 371                     }
 372                     if(sflag[goodTrack] == 1) {
 373                       uArray1->SetUnitSignalFlag(kGood);
 374                       uArray1->SetUnitSignalFlagC(kFALSE,kGood);
 375                     } else uArray1->SetUnitSignalFlagC(kFALSE,kBad);
 376
 377                     if(uArray1->GetUnitEnergy()>0 && ref1){
 378                       if(!fProcId){
 379                         new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray1));
 380                         fProcId = kTRUE;
 381                       }
 382                       fRefArray->Add(uArray1);
 383                     }
 384                   }
 385
 386                   if(phi >= phimin2 && phi <= phimax2){
 387                     Int_t id2 = fGrid2->GetIndex(phi,eta)-1+n0+n1;
 388                     AliJetUnitArray *uArray2 = (AliJetUnitArray*)fUnitArray->At(id2+fNumUnits+nElements);
 389                     TRefArray *reference2 = uArray2->GetUnitTrackRef();
 390                     if (reference2->GetEntries() == 0)  {
 391                         new(reference2) TRefArray(TProcessID::GetProcessWithUID(track));
 392                     }
 393
 394                     reference2->Add(track);
 395
 396                     Float_t uEnergy2 = uArray2->GetUnitEnergy();
 397                     Bool_t ok2 = kFALSE;
 398                     Bool_t ref2 = kFALSE;
 399                     if(uEnergy2==0.){
 400                       nTracksEmcalDZ++;
 401                       ok2 = kTRUE;
 402                       ref2 = kTRUE;
 403                     }
 404                     uArray2->SetUnitEnergy(uEnergy2+pt);
 405
 406                     if(uArray2->GetUnitEnergy()<ptMin)
 407                       uArray2->SetUnitCutFlag(kPtSmaller);
 408                     else {
 409                       uArray2->SetUnitCutFlag(kPtHigher);
 410                       if(ok2) nTracksEmcalDZCut++;
 411                     }
 412                     if(sflag[goodTrack] == 1) {
 413                       uArray2->SetUnitSignalFlag(kGood);
 414                       uArray2->SetUnitSignalFlagC(kFALSE,kGood);
 415                     } else uArray2->SetUnitSignalFlagC(kFALSE,kBad);
 416
 417                     if(uArray2->GetUnitEnergy()>0 && ref2){
 418                       if(!fProcId){
 419                         new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray2));
 420                         fProcId = kTRUE;
 421                       }
 422                       fRefArray->Add(uArray2);
 423                     }
 424                   }
 425
 426                   if(phi >= phimin3 && phi <= phimax3){
 427                     Int_t id3 = fGrid3->GetIndex(phi,eta)-1+n0+n1+n2;
 428                     AliJetUnitArray *uArray3 = (AliJetUnitArray*)fUnitArray->At(id3+fNumUnits+nElements);
 429                     TRefArray *reference3 = uArray3->GetUnitTrackRef();
 430                     if (reference3->GetEntries() == 0)  {
 431                         new(reference3) TRefArray(TProcessID::GetProcessWithUID(track));
 432                     }
 433
 434                     reference3->Add(track);
 435
 436                     Float_t uEnergy3 = uArray3->GetUnitEnergy();
 437                     Bool_t ok3 = kFALSE;
 438                     Bool_t ref3 = kFALSE;
 439                     if(uEnergy3==0.){
 440                       nTracksEmcalDZ++;
 441                       ok3 = kTRUE;
 442                       ref3 = kTRUE;
 443                     }
 444                     uArray3->SetUnitEnergy(uEnergy3+pt);
 445
 446                     if(uArray3->GetUnitEnergy()<ptMin)
 447                       uArray3->SetUnitCutFlag(kPtSmaller);
 448                     else {
 449                       uArray3->SetUnitCutFlag(kPtHigher);
 450                       if(ok3) nTracksEmcalDZCut++;
 451                     }
 452                     if(sflag[goodTrack] == 1) {
 453                       uArray3->SetUnitSignalFlag(kGood);
 454                       uArray3->SetUnitSignalFlagC(kFALSE,kGood);
 455                     } else uArray3->SetUnitSignalFlagC(kFALSE,kBad);
 456
 457                     if(uArray3->GetUnitEnergy()>0 && ref3){
 458                       if(!fProcId){
 459                         new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray3));
 460                         fProcId = kTRUE;
 461                       }
 462                       fRefArray->Add(uArray3);
 463                     }
 464                   }
 465
 466                   if(phi >= phimin4 && phi <= phimax4){
 467                     Int_t id4 = fGrid4->GetIndex(phi,eta)-1+n0+n1+n2+n3;
 468                     AliJetUnitArray *uArray4 = (AliJetUnitArray*)fUnitArray->At(id4+fNumUnits+nElements);
 469                     TRefArray *reference4 = uArray4->GetUnitTrackRef();
 470                     if (reference4->GetEntries() == 0)  {
 471                         new(reference4) TRefArray(TProcessID::GetProcessWithUID(track));
 472                     }
 473
 474                     reference4->Add(track);
 475
 476                     Float_t uEnergy4 = uArray4->GetUnitEnergy();
 477                     Bool_t ok4 = kFALSE;
 478                     Bool_t ref4 = kFALSE;
 479                     if(uEnergy4==0.){
 480                       nTracksEmcalDZ++;
 481                       ok4 = kTRUE;
 482                       ref4 = kTRUE;
 483                     }
 484                     uArray4->SetUnitEnergy(uEnergy4+pt);
 485
 486                     if(uArray4->GetUnitEnergy()<ptMin)
 487                       uArray4->SetUnitCutFlag(kPtSmaller);
 488                     else {
 489                       uArray4->SetUnitCutFlag(kPtHigher);
 490                       if(ok4) nTracksEmcalDZCut++;
 491                     }
 492                     if(sflag[goodTrack] == 1) {
 493                       uArray4->SetUnitSignalFlag(kGood);
 494                       uArray4->SetUnitSignalFlagC(kFALSE,kGood);
 495                     } else uArray4->SetUnitSignalFlagC(kFALSE,kBad);
 496
 497                     if(uArray4->GetUnitEnergy()>0 && ref4){
 498                       if(!fProcId){
 499                         new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray4));
 500                         fProcId = kTRUE;
 501                       }
 502                       fRefArray->Add(uArray4);
 503                     }
 504                   }
 505                 } // end fDZ
 506
 507               Int_t towerID = 0;
 508               fGeom->GetAbsCellIdFromEtaPhi(eta,phi,towerID);
 509               if(towerID==-1) continue;
 510
 511               AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(towerID);
 512               TRefArray *reference = uArray->GetUnitTrackRef();
 513               if (reference->GetEntries() == 0)  {
 514                   new(reference) TRefArray(TProcessID::GetProcessWithUID(track));
 515               }
 516
 517               reference->Add(track);
 518
 519               Float_t unitEnergy = uArray->GetUnitEnergy();
 520               Bool_t ok = kFALSE;
 521               Bool_t ref = kFALSE;
 522               if(unitEnergy==0.){
 523                 nTracksEmcal++;
 524                 ok=kTRUE;
 525                 ref=kTRUE;
 526               }
 527
 528               // Do Hadron Correction
 529               // This is under construction !!!!!!!!!!!!!!!!!!!!!!!
 530               // Parametrization to be added
 531               if (fApplyMIPCorrection != 0)
 532                 {
 533 //                Float_t   hCEnergy = fHadCorr->GetEnergy(p3.Mag(), (Double_t)eta,0);
 534 //                unitEnergy -= hCEnergy*TMath::Sin(2.0*TMath::ATan(TMath::Exp(-eta)));
 535                 } //end Hadron Correction loop
 536
 537               uArray->SetUnitEnergy(unitEnergy + pt);
 538
 539               // Put a pt cut flag
 540               if(uArray->GetUnitEnergy()<ptMin){
 541                 uArray->SetUnitCutFlag(kPtSmaller);
 542               }
 543               else {
 544                 uArray->SetUnitCutFlag(kPtHigher);
 545                 if(ok) nTracksEmcalCut++;
 546               }
 547
 548               // Signal flag
 549               if(sflag[goodTrack] == 1) {
 550                 uArray->SetUnitSignalFlag(kGood);
 551                 uArray->SetUnitSignalFlagC(kFALSE,kGood);
 552               } else uArray->SetUnitSignalFlagC(kFALSE,kBad);
 553
 554
 555               if(uArray->GetUnitEnergy()>0 && ref){
 556                 if(!fProcId){
 557                   new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
 558                   fProcId = kTRUE;
 559                 }
 560                 fRefArray->Add(uArray);
 561               }
 562             } // end loop on EMCal acceptance cut + tracks quality
 563           else{
 564             // Outside EMCal acceptance
 565
 566             Int_t idTPC = fTPCGrid->GetIndex(phi,eta);
 567
 568             AliJetUnitArray *uArray = (AliJetUnitArray*)fUnitArray->At(fNumUnits-1+idTPC);
 569             TRefArray *reference = uArray->GetUnitTrackRef();
 570             if (reference->GetEntries() == 0)  {
 571                 new(reference) TRefArray(TProcessID::GetProcessWithUID(track));
 572             }
 573
 574             reference->Add(track);
 575
 576             Float_t unitEnergy2 = uArray->GetUnitEnergy();
 577             Bool_t okout = kFALSE;
 578             Bool_t refout = kFALSE;
 579             if(unitEnergy2==0.){
 580               nTracksTpc++;
 581               okout=kTRUE;
 582               refout=kTRUE;
 583             }
 584             // Fill energy outside emcal acceptance
 585             uArray->SetUnitEnergy(unitEnergy2 + pt);
 586
 587             // Pt cut flag
 588             if(uArray->GetUnitEnergy()<ptMin){
 589               uArray->SetUnitCutFlag(kPtSmaller);
 590             }
 591             else {
 592               uArray->SetUnitCutFlag(kPtHigher);
 593               if(okout) nTracksTpcCut++;
 594             }
 595             // Signal flag
 596             if(sflag[goodTrack] == 1) {
 597               uArray->SetUnitSignalFlag(kGood);
 598               uArray->SetUnitSignalFlagC(kFALSE,kGood);
 599             } else uArray->SetUnitSignalFlagC(kFALSE,kBad);
 600
 601
 602             if(uArray->GetUnitEnergy()>0 && refout){
 603               if(!fProcId){
 604                 new(fRefArray) TRefArray(TProcessID::GetProcessWithUID(uArray));
 605                 fProcId = kTRUE;
 606               }
 607               fRefArray->Add(uArray);
 608             }
 609           }
 610         } // end fGrid==1
 611
 612       goodTrack++;
 613
 614     } // end loop on entries (tpc tracks)
 615
 616   if(fDebug>0)
 617     {
 618       cout << "End of Tracks %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%" << endl;
 619       cout << "goodTracks: " << goodTrack << endl;
 620     }
 621
 622   delete[] sflag;
 623   delete[] cflag;
 624
 625   if(fGrid==0) {
 626     fNTracks = nTracksTpcOnly;
 627     fNTracksCut = nTracksTpcOnlyCut;
 628     if(fDebug>10){
 629       cout << "fNTracks : " << fNTracks << endl;
 630       cout << "fNTracksCut : " << fNTracksCut << endl;
 631     }
 632   }
 633   if(fGrid==1) {
 634     fNTracks = nTracksEmcal+nTracksEmcalDZ+nTracksTpc;
 635     fNTracksCut = nTracksEmcalCut+nTracksEmcalDZCut+nTracksTpcCut;
 636     if(fDebug>10){
 637       cout << "fNTracks : " << fNTracks << endl;
 638       cout << "fNTracksCut : " << fNTracksCut << endl;
 639     }
 640   }
 641
 642 }
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656