PWG/CaloTrackCorrBase/AliIsolationCut.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 // Class containing methods for the isolation cut.
  18 // An AOD candidate (AliAODPWG4ParticleCorrelation type)
  19 // is passed. Look in a cone around the candidate and study
  20 // the hadronic activity inside to decide if the candidate is isolated
  21 //
  22 //
  23 //*-- Author: Gustavo Conesa (LNF-INFN)
  24
  25 //-Yaxian Mao (add the possibility for different IC method with different pt range, 01/10/2010)
  26 //-Yaxian Mao (check the candidate particle is the leading particle or not at the same hemishere)
  27
  28 //////////////////////////////////////////////////////////////////////////////
  29
  30
  31 // --- ROOT system ---
  32 #include <TLorentzVector.h>
  33 #include <TObjArray.h>
  34
  35 // --- AliRoot system ---
  36 #include "AliIsolationCut.h"
  37 #include "AliAODPWG4ParticleCorrelation.h"
  38 #include "AliEMCALGeometry.h"
  39 #include "AliEMCALGeoParams.h"
  40 #include "AliCalorimeterUtils.h"
  41 #include "AliAODTrack.h"
  42 #include "AliVCluster.h"
  43 #include "AliCaloTrackReader.h"
  44 #include "AliMixedEvent.h"
  45 #include "AliCaloPID.h"
  46
  47 ClassImp(AliIsolationCut)
  48
  49 //____________________________________
  50 AliIsolationCut::AliIsolationCut() :
  51 TObject(),
  52 fConeSize(0.),
  53 fPtThreshold(0.),
  54 fPtThresholdMax(10000.),
  55 fSumPtThreshold(0.),
  56 fSumPtThresholdMax(10000.),
  57 fPtFraction(0.),
  58 fICMethod(0),
  59 fPartInCone(0),
  60 fDebug(-1),
  61 fFracIsThresh(1)
  62 {
  63   //default ctor
  64
  65   //Initialize parameters
  66   InitParameters();
  67
  68 }
  69
  70 //_________________________________________________________________________________________________________________________________
  71 void AliIsolationCut::CalculateUEBandClusterNormalization(AliCaloTrackReader * /*reader*/, Float_t   etaC, Float_t /*phiC*/,
  72                                                            Float_t   phiUEptsumCluster,     Float_t   etaUEptsumCluster,
  73                                                            Float_t & phiUEptsumClusterNorm, Float_t & etaUEptsumClusterNorm,
  74                                                            Float_t & excessFracEta,         Float_t & excessFracPhi         ) const
  75 {
  76   // Normalize cluster background band
  77
  78   Float_t coneA     = fConeSize*fConeSize*TMath::Pi(); // A = pi R^2, isolation cone area
  79
  80   //Careful here if EMCal limits changed .. 2010 (4 SM) to 2011-12 (10 SM), for the moment consider 100 deg in phi
  81   Float_t emcEtaSize = 0.7*2; // TO FIX
  82   Float_t emcPhiSize = TMath::DegToRad()*100.; // TO FIX
  83
  84   /* //Catherine code
  85    if(((((2*fConeSize*emcPhiSize)-coneA))*phiBandBadCellsCoeff)!=0)phiUEptsumClusterNorm = phiUEptsumCluster*(coneA*coneBadCellsCoeff / (((2*fConeSize*emcPhiSize)-coneA))*phiBandBadCellsCoeff); // pi * R^2 / (2 R * 2 100 deg) -  trigger cone
  86    if(((((2*(fConeSize-excess)*emcPhiSize)-(coneA-excessFracEta))*etaBandBadCellsCoeff))!=0)phiUEptsumClusterNorm = phiUEptsumCluster*(coneA *coneBadCellsCoeff/ (((2*(fConeSize-excess)*emcPhiSize)-(coneA/excessFracEta))*etaBandBadCellsCoeff));
  87    if(((2*(fConeSize-excess)*emcEtaSize)-(coneA-excessFracPhi))*phiBandBadCellsCoeff!=0) etaUEptsumClusterNorm = etaUEptsumCluster*(coneA*coneBadCellsCoeff / (((2*(fConeSize-excess)*emcEtaSize)-(coneA/excessFracPhi))*phiBandBadCellsCoeff));
  88    */
  89
  90   if((2*fConeSize*emcPhiSize-coneA)!=0) phiUEptsumClusterNorm = phiUEptsumCluster*(coneA / (((2*fConeSize*emcPhiSize)-coneA))); // pi * R^2 / (2 R * 2 100 deg) -  trigger cone
  91   if((2*fConeSize*emcEtaSize-coneA)!=0) etaUEptsumClusterNorm = etaUEptsumCluster*(coneA / (((2*fConeSize*emcEtaSize)-coneA))); // pi * R^2 / (2 R * 2*0.7)  -  trigger cone
  92
  93   //out of eta acceptance
  94   excessFracEta = 1;
  95   excessFracPhi = 1;
  96
  97   if(TMath::Abs(etaC)+fConeSize > emcEtaSize/2.)
  98   {
  99     Float_t excess = TMath::Abs(etaC) + fConeSize - emcEtaSize/2.;
 100     excessFracEta  = CalculateExcessAreaFraction(excess);
 101
 102     if ( excessFracEta != 0) coneA /=  excessFracEta;
 103
 104     //UE band is also out of acceptance, need to estimate corrected area
 105     if(((2*fConeSize-excess)*emcPhiSize-coneA) != 0 ) phiUEptsumClusterNorm = phiUEptsumCluster*(coneA / ((((2*fConeSize-excess)*emcPhiSize)-coneA)));
 106     if(( 2*fConeSize        *emcEtaSize-coneA) != 0 ) etaUEptsumClusterNorm = etaUEptsumCluster*(coneA / ((( 2*fConeSize        *emcEtaSize)-coneA)));
 107   }
 108
 109 }
 110
 111 //________________________________________________________________________________________________________________________________
 112 void AliIsolationCut::CalculateUEBandTrackNormalization  (AliCaloTrackReader * reader,    Float_t   etaC, Float_t /*phiC*/,
 113                                                           Float_t   phiUEptsumTrack,      Float_t   etaUEptsumTrack,
 114                                                           Float_t & phiUEptsumTrackNorm,  Float_t & etaUEptsumTrackNorm,
 115                                                           Float_t & excessFracEta,        Float_t & excessFracPhi          ) const
 116 {
 117   // Normalize track background band
 118
 119   Float_t coneA     = fConeSize*fConeSize*TMath::Pi(); // A = pi R^2, isolation cone area
 120
 121   // Get the cut used for the TPC tracks in the reader, +-0.8, +-0.9 ...
 122   // Only valid in simple fidutial cut case and if the cut is applied, careful!
 123   Float_t tpcEtaSize = reader->GetFiducialCut()->GetCTSFidCutMaxEtaArray()->At(0) -
 124   reader->GetFiducialCut()->GetCTSFidCutMinEtaArray()->At(0) ;
 125   Float_t tpcPhiSize = TMath::TwoPi();
 126
 127   /*//Catherine code
 128    //phiUEptsumTrackNorm = phiUEptsumTrack*(coneA*coneBadCellsCoeff / (((2*fConeSize*tpcPhiSize)-coneA))*phiBandBadCellsCoeff); // pi * R^2 / (2 R * 2 pi) -  trigger cone
 129    //etaUEptsumTrackNorm = etaUEptsumTrack*(coneA*coneBadCellsCoeff / (((2*fConeSize*tpcEtaSize)-coneA))*etaBandBadCellsCoeff); // pi * R^2 / (2 R * 1.6)  -  trigger cone
 130    if((2*fConeSize*tpcPhiSize-coneA)!=0)phiUEptsumTrackNorm = phiUEptsumTrack*(coneA / (((2*fConeSize*tpcPhiSize)-coneA))); // pi * R^2 / (2 R * 2 pi) -  trigger cone
 131    if((2*fConeSize*tpcEtaSize-coneA)!=0)etaUEptsumTrackNorm = etaUEptsumTrack*(coneA / (((2*fConeSize*tpcEtaSize)-coneA))); // pi * R^2 / (2 R * 1.6)  -  trigger cone
 132    if((2*(fConeSize-excess)*tpcPhiSize)-(coneA-excessFracEta)!=0)phiUEptsumTrackNorm = phiUEptsumTrack*(coneA / (((2*(fConeSize-excess)*tpcPhiSize)-(coneA/excessFracEta))));
 133    */ //end Catherine code
 134
 135   //correct out of eta acceptance
 136   excessFracEta = 1;
 137   excessFracPhi = 1;
 138
 139   if((2*fConeSize*tpcPhiSize-coneA)!=0) phiUEptsumTrackNorm = phiUEptsumTrack*(coneA / (((2*fConeSize*tpcPhiSize)-coneA))); // pi * R^2 / (2 R * 2 pi) -  trigger cone
 140   if((2*fConeSize*tpcEtaSize-coneA)!=0) etaUEptsumTrackNorm = etaUEptsumTrack*(coneA / (((2*fConeSize*tpcEtaSize)-coneA))); // pi * R^2 / (2 R * 1.6)  -  trigger cone
 141
 142   if(TMath::Abs(etaC)+fConeSize > tpcEtaSize/2.)
 143   {
 144     Float_t excess = TMath::Abs(etaC) + fConeSize - tpcEtaSize/2.;
 145     excessFracEta  = CalculateExcessAreaFraction(excess);
 146     if (excessFracEta != 0) coneA /=  excessFracEta;
 147
 148     //UE band is also out of acceptance, need to estimate corrected area
 149     if(((2*fConeSize-excess)*tpcPhiSize - coneA) !=0 ) phiUEptsumTrackNorm = phiUEptsumTrack*(coneA / ((((2*fConeSize-excess)*tpcPhiSize)-coneA)));
 150     if(( 2*fConeSize        *tpcEtaSize - coneA) !=0 ) etaUEptsumTrackNorm = etaUEptsumTrack*(coneA / ((( 2*fConeSize        *tpcEtaSize)-coneA)));
 151   }
 152
 153 }
 154
 155 //________________________________________________________________________
 156 Float_t AliIsolationCut::CalculateExcessAreaFraction(Float_t excess) const
 157 {
 158   // Area of a circunference segment segment 1/2 R^2 (angle-sin(angle)), angle = 2*ACos((R-excess)/R)
 159
 160
 161   Float_t angle   = 2*TMath::ACos( (fConeSize-excess) / fConeSize );
 162
 163   Float_t coneA   = fConeSize*fConeSize*TMath::Pi(); // A = pi R^2, isolation cone area
 164
 165   Float_t excessA = fConeSize*fConeSize / 2 * (angle-TMath::Sin(angle));
 166
 167   if(coneA > excessA) return coneA / (coneA-excessA);
 168   else
 169   {
 170     printf("AliIsolationCut::CalculateExcessAreaFraction() - Please Check : Excess Track %2.3f, coneA %2.2f,  excessA %2.2f, angle %2.2f,factor %2.2f\n",
 171            excess,coneA, excessA, angle*TMath::RadToDeg(), coneA / (coneA-excessA));
 172     return  1;
 173   }
 174 }
 175
 176 //_______________________________________________________________________________________
 177 Float_t AliIsolationCut::GetCellDensity(AliAODPWG4ParticleCorrelation * pCandidate,
 178                                         AliCaloTrackReader * reader) const
 179 {
 180   // Get good cell density (number of active cells over all cells in cone)
 181
 182   Double_t coneCells    = 0.; //number of cells in cone with radius fConeSize
 183   Double_t coneCellsBad = 0.; //number of bad cells in cone with radius fConeSize
 184   Double_t cellDensity  = 1.;
 185
 186   Float_t phiC  = pCandidate->Phi() ;
 187   if(phiC<0) phiC+=TMath::TwoPi();
 188   Float_t etaC  = pCandidate->Eta() ;
 189
 190   if(pCandidate->GetDetector()=="EMCAL")
 191   {
 192     AliEMCALGeometry* eGeom = AliEMCALGeometry::GetInstance();
 193     AliCalorimeterUtils *cu = reader->GetCaloUtils();
 194
 195     Int_t absId = -999;
 196     if (eGeom->GetAbsCellIdFromEtaPhi(etaC,phiC,absId))
 197     {
 198       //Get absolute (col,row) of candidate
 199       Int_t iEta=-1, iPhi=-1, iRCU = -1;
 200       Int_t nSupMod = cu->GetModuleNumberCellIndexes(absId, pCandidate->GetDetector(), iEta, iPhi, iRCU);
 201
 202       Int_t colC = iEta;
 203       if (nSupMod % 2) colC =  AliEMCALGeoParams::fgkEMCALCols + iEta ;
 204       Int_t rowC = iPhi + AliEMCALGeoParams::fgkEMCALRows*int(nSupMod/2);
 205
 206       Int_t sqrSize = int(fConeSize/0.0143) ; // Size of cell in radians
 207       //loop on cells in a square of side fConeSize to check cells in cone
 208       for(Int_t icol = colC-sqrSize; icol < colC+sqrSize;icol++)
 209       {
 210         for(Int_t irow = rowC-sqrSize; irow < rowC+sqrSize; irow++)
 211         {
 212           if (Radius(colC, rowC, icol, irow) < sqrSize)
 213           {
 214             coneCells += 1.;
 215
 216             Int_t cellSM  = -999;
 217             Int_t cellEta = -999;
 218             Int_t cellPhi = -999;
 219             if(icol > AliEMCALGeoParams::fgkEMCALCols-1)
 220             {
 221               cellSM = 0+int(irow/AliEMCALGeoParams::fgkEMCALRows)*2;
 222               cellEta = icol-AliEMCALGeoParams::fgkEMCALCols;
 223               cellPhi = irow-AliEMCALGeoParams::fgkEMCALRows*int(cellSM/2);
 224             }
 225             if(icol < AliEMCALGeoParams::fgkEMCALCols)
 226             {
 227               cellSM = 1+int(irow/AliEMCALGeoParams::fgkEMCALRows)*2;
 228               cellEta = icol;
 229               cellPhi = irow-AliEMCALGeoParams::fgkEMCALRows*int(cellSM/2);
 230             }
 231
 232             //Count as bad "cells" out of EMCAL acceptance
 233             if(icol < 0 || icol > AliEMCALGeoParams::fgkEMCALCols*2 ||
 234                irow < 0 || irow > AliEMCALGeoParams::fgkEMCALRows*16./3) //5*nRows+1/3*nRows
 235             {
 236               coneCellsBad += 1.;
 237             }
 238             //Count as bad "cells" marked as bad in the DataBase
 239             else if (cu->GetEMCALChannelStatus(cellSM,cellEta,cellPhi)==1)
 240             {
 241               coneCellsBad += 1. ;
 242             }
 243           }
 244         }
 245       }//end of cells loop
 246     }
 247
 248     else if(fDebug>0) printf("cluster with bad (eta,phi) in EMCal for energy density calculation\n");
 249
 250     if (coneCells > 0.)
 251     {
 252       cellDensity = (coneCells-coneCellsBad)/coneCells;
 253       //printf("Energy density = %f\n", cellDensity);
 254     }
 255   }
 256
 257   return cellDensity;
 258
 259 }
 260
 261 //__________________________________________________________________________________
 262 void AliIsolationCut::GetCoeffNormBadCell(AliAODPWG4ParticleCorrelation * pCandidate,
 263                                           AliCaloTrackReader * reader,
 264                                           Float_t &  coneBadCellsCoeff,
 265                                           Float_t &  etaBandBadCellsCoeff,
 266                                           Float_t & phiBandBadCellsCoeff)
 267 {
 268   // Get good cell density (number of active cells over all cells in cone)
 269
 270   Double_t coneCells    = 0.; //number of cells in cone with radius fConeSize
 271   Double_t phiBandCells = 0.; //number of cells in band phi
 272   Double_t etaBandCells = 0.; //number of cells in band eta
 273
 274   Float_t phiC  = pCandidate->Phi() ;
 275   if(phiC<0) phiC+=TMath::TwoPi();
 276   Float_t etaC  = pCandidate->Eta() ;
 277
 278   if(pCandidate->GetDetector()=="EMCAL")
 279   {
 280     AliEMCALGeometry* eGeom = AliEMCALGeometry::GetInstance();
 281     AliCalorimeterUtils *cu = reader->GetCaloUtils();
 282
 283     Int_t absId = -999;
 284     if (eGeom->GetAbsCellIdFromEtaPhi(etaC,phiC,absId))
 285     {
 286       //Get absolute (col,row) of candidate
 287       Int_t iEta=-1, iPhi=-1, iRCU = -1;
 288       Int_t nSupMod = cu->GetModuleNumberCellIndexes(absId, pCandidate->GetDetector(),
 289                                                      iEta, iPhi, iRCU);
 290
 291       Int_t colC = iEta;
 292       if (nSupMod % 2) colC =  AliEMCALGeoParams::fgkEMCALCols + iEta ;
 293       Int_t rowC = iPhi + AliEMCALGeoParams::fgkEMCALRows*int(nSupMod/2);
 294
 295       Int_t sqrSize = int(fConeSize/0.0143) ; // Size of cell in radians
 296       for(Int_t icol = 0; icol < 2*AliEMCALGeoParams::fgkEMCALCols-1;icol++)
 297       {
 298         for(Int_t irow = 0; irow < 5*AliEMCALGeoParams::fgkEMCALRows -1; irow++)
 299         {
 300           //loop on cells in a square of side fConeSize to check cells in cone
 301           if     ( Radius(colC, rowC, icol, irow) < sqrSize ) { coneCells    += 1.; }
 302           else if( icol>colC-sqrSize  &&  icol<colC+sqrSize ) { phiBandCells += 1 ; }
 303           else if( irow>rowC-sqrSize  &&  irow<rowC+sqrSize ) { etaBandCells += 1 ; }
 304
 305           Int_t cellSM  = -999;
 306           Int_t cellEta = -999;
 307           Int_t cellPhi = -999;
 308           if(icol > AliEMCALGeoParams::fgkEMCALCols-1)
 309           {
 310             cellSM = 0+int(irow/AliEMCALGeoParams::fgkEMCALRows)*2;
 311             cellEta = icol-AliEMCALGeoParams::fgkEMCALCols;
 312             cellPhi = irow-AliEMCALGeoParams::fgkEMCALRows*int(cellSM/2);
 313           }
 314           if(icol < AliEMCALGeoParams::fgkEMCALCols)
 315           {
 316             cellSM = 1+int(irow/AliEMCALGeoParams::fgkEMCALRows)*2;
 317             cellEta = icol;
 318             cellPhi = irow-AliEMCALGeoParams::fgkEMCALRows*int(cellSM/2);
 319           }
 320
 321           if( (icol < 0 || icol > AliEMCALGeoParams::fgkEMCALCols*2-1 ||
 322                irow < 0 || irow > AliEMCALGeoParams::fgkEMCALRows*5 - 1) //5*nRows+1/3*nRows //Count as bad "cells" out of EMCAL acceptance
 323              || (cu->GetEMCALChannelStatus(cellSM,cellEta,cellPhi)==1))  //Count as bad "cells" marked as bad in the DataBase
 324           {
 325             if     ( Radius(colC, rowC, icol, irow) < sqrSize ) coneBadCellsCoeff    += 1.;
 326             else if( icol>colC-sqrSize  &&  icol<colC+sqrSize ) phiBandBadCellsCoeff += 1 ;
 327                   else if( irow>rowC-sqrSize  &&  irow<rowC+sqrSize ) etaBandBadCellsCoeff += 1 ;
 328           }
 329         }
 330       }//end of cells loop
 331     }
 332
 333     else if(fDebug > 0) printf("cluster with bad (eta,phi) in EMCal for energy density coeff calculation\n");
 334
 335     if (coneCells > 0.)
 336     {
 337       //   printf("Energy density coneBadCellsCoeff= %.2f coneCells%.2f\n", coneBadCellsCoeff,coneCells);
 338       coneBadCellsCoeff = (coneCells-coneBadCellsCoeff)/coneCells;
 339       //  printf("coneBadCellsCoeff= %.2f\n", coneBadCellsCoeff);
 340     }
 341     if (phiBandCells > 0.)
 342     {
 343       // printf("Energy density phiBandBadCellsCoeff = %.2f phiBandCells%.2f\n", phiBandBadCellsCoeff,phiBandCells);
 344       phiBandBadCellsCoeff = (phiBandCells-phiBandBadCellsCoeff)/phiBandCells;
 345       // printf("phiBandBadCellsCoeff = %.2f\n", phiBandBadCellsCoeff);
 346     }
 347     if (etaBandCells > 0.)
 348     {
 349       //printf("Energy density etaBandBadCellsCoeff = %.2f etaBandCells%.2f\n", etaBandBadCellsCoeff,etaBandCells);
 350       etaBandBadCellsCoeff = (etaBandCells-etaBandBadCellsCoeff)/etaBandCells;
 351       // printf("etaBandBadCellsCoeff = %.2f\n",etaBandBadCellsCoeff);
 352     }
 353
 354   }
 355
 356 }
 357
 358 //____________________________________________
 359 TString AliIsolationCut::GetICParametersList()
 360 {
 361   //Put data member values in string to keep in output container
 362
 363   TString parList ; //this will be list of parameters used for this analysis.
 364   const Int_t buffersize = 255;
 365   char onePar[buffersize] ;
 366
 367   snprintf(onePar,buffersize,"--- AliIsolationCut ---\n") ;
 368   parList+=onePar ;
 369   snprintf(onePar,buffersize,"fConeSize: (isolation cone size) %1.2f\n",fConeSize) ;
 370   parList+=onePar ;
 371   snprintf(onePar,buffersize,"fPtThreshold =%1.2f (isolation pt threshold) \n",fPtThreshold) ;
 372   parList+=onePar ;
 373   snprintf(onePar,buffersize,"fPtFraction=%1.2f (isolation pt threshold fraction ) \n",fPtFraction) ;
 374   parList+=onePar ;
 375   snprintf(onePar,buffersize,"fICMethod=%d (isolation cut case) \n",fICMethod) ;
 376   parList+=onePar ;
 377   snprintf(onePar,buffersize,"fPartInCone=%d \n",fPartInCone) ;
 378   parList+=onePar ;
 379  snprintf(onePar,buffersize,"fFracIsThresh=%i \n",fFracIsThresh) ;
 380   parList+=onePar ;
 381
 382   return parList;
 383 }
 384
 385 //____________________________________
 386 void AliIsolationCut::InitParameters()
 387 {
 388   //Initialize the parameters of the analysis.
 389
 390   fConeSize       = 0.4 ;
 391   fPtThreshold    = 0.5  ;
 392   fPtThresholdMax = 10000.  ;
 393   fSumPtThreshold    = 1.0 ;
 394   fSumPtThresholdMax = 10000. ;
 395   fPtFraction     = 0.1 ;
 396   fPartInCone     = kNeutralAndCharged;
 397   fICMethod       = kSumPtIC; // 0 pt threshol method, 1 cone pt sum method
 398   fFracIsThresh   = 1;
 399 }
 400
 401 //________________________________________________________________________________
 402 void  AliIsolationCut::MakeIsolationCut(TObjArray * plCTS,
 403                                         TObjArray * plNe,
 404                                         AliCaloTrackReader * reader,
 405                                         AliCaloPID * pid,
 406                                         Bool_t bFillAOD,
 407                                         AliAODPWG4ParticleCorrelation  *pCandidate,
 408                                         TString aodArrayRefName,
 409                                         Int_t   & n,
 410                                         Int_t   & nfrac,
 411                                         Float_t & coneptsum,
 412                                         Bool_t  & isolated) const
 413 {
 414   //Search in cone around a candidate particle if it is isolated
 415   Float_t ptC   = pCandidate->Pt() ;
 416   Float_t phiC  = pCandidate->Phi() ;
 417   if(phiC<0) phiC+=TMath::TwoPi();
 418   Float_t etaC  = pCandidate->Eta() ;
 419
 420   Float_t ptLead = -100. ;
 421   Float_t pt     = -100. ;
 422   Float_t eta    = -100. ;
 423   Float_t phi    = -100. ;
 424   Float_t rad    = -100. ;
 425
 426   Float_t coneptsumCluster = 0;
 427   Float_t coneptsumTrack   = 0;
 428
 429   Float_t  etaBandPtSumTrack   = 0;
 430   Float_t  phiBandPtSumTrack   = 0;
 431   Float_t  etaBandPtSumCluster = 0;
 432   Float_t  phiBandPtSumCluster = 0;
 433
 434   n         = 0 ;
 435   nfrac     = 0 ;
 436   isolated  = kFALSE;
 437
 438   if(fDebug>0)
 439   {
 440     printf("AliIsolationCut::MakeIsolationCut() - Cadidate pT %2.2f, eta %2.2f, phi %2.2f, cone %1.2f, thres %2.2f, Fill AOD? %d",
 441            pCandidate->Pt(), pCandidate->Eta(), pCandidate->Phi()*TMath::RadToDeg(), fConeSize,fPtThreshold,bFillAOD);
 442     if(plCTS) printf(", nTracks %d"  ,plCTS->GetEntriesFast());
 443     if(plNe)  printf(", nClusters %d",plNe ->GetEntriesFast());
 444
 445     printf("\n");
 446   }
 447
 448   //Initialize the array with refrences
 449   TObjArray * refclusters  = 0x0;
 450   TObjArray * reftracks    = 0x0;
 451   Int_t       ntrackrefs   = 0;
 452   Int_t       nclusterrefs = 0;
 453
 454   //Check charged particles in cone.
 455   if(plCTS &&
 456      (fPartInCone==kOnlyCharged || fPartInCone==kNeutralAndCharged))
 457   {
 458     TVector3 p3;
 459     for(Int_t ipr = 0;ipr < plCTS->GetEntries() ; ipr ++ )
 460     {
 461       AliVTrack* track = dynamic_cast<AliVTrack*>(plCTS->At(ipr)) ;
 462
 463       if(track)
 464       {
 465         //Do not count the candidate (pion, conversion photon) or the daughters of the candidate
 466         if(track->GetID() == pCandidate->GetTrackLabel(0) || track->GetID() == pCandidate->GetTrackLabel(1) ||
 467            track->GetID() == pCandidate->GetTrackLabel(2) || track->GetID() == pCandidate->GetTrackLabel(3)   ) continue ;
 468
 469         p3.SetXYZ(track->Px(),track->Py(),track->Pz());
 470         pt  = p3.Pt();
 471         eta = p3.Eta();
 472         phi = p3.Phi() ;
 473       }
 474       else
 475       {// Mixed event stored in AliAODPWG4Particles
 476         AliAODPWG4Particle * trackmix = dynamic_cast<AliAODPWG4Particle*>(plCTS->At(ipr)) ;
 477         if(!trackmix)
 478         {
 479           printf("AliIsolationCut::MakeIsolationCut() - Wrong track data type, continue\n");
 480           continue;
 481         }
 482
 483         pt  = trackmix->Pt();
 484         eta = trackmix->Eta();
 485         phi = trackmix->Phi() ;
 486       }
 487
 488       if( phi < 0 ) phi+=TMath::TwoPi();
 489
 490       rad = Radius(etaC, phiC, eta, phi);
 491
 492       // ** For the background out of cone **
 493
 494       if(rad > fConeSize)
 495       {
 496         if(eta > (etaC-fConeSize) && eta < (etaC+fConeSize)) phiBandPtSumTrack += pt;
 497         if(phi > (phiC-fConeSize) && phi < (phiC+fConeSize)) etaBandPtSumTrack += pt;
 498       }
 499
 500       // ** For the isolated particle **
 501
 502       // Only loop the particle at the same side of candidate
 503       if(TMath::Abs(phi-phiC) > TMath::PiOver2()) continue ;
 504
 505       // If at the same side has particle larger than candidate,
 506       // then candidate can not be the leading, skip such events
 507       if(pt > ptC)
 508       {
 509         n         = -1;
 510         nfrac     = -1;
 511         coneptsumTrack = -1;
 512         isolated  = kFALSE;
 513
 514         pCandidate->SetLeadingParticle(kFALSE);
 515
 516         if(bFillAOD && reftracks)
 517         {
 518           reftracks->Clear();
 519           delete reftracks;
 520         }
 521
 522         return ;
 523       }
 524
 525       // // Check if there is any particle inside cone with pt larger than  fPtThreshold
 526       // Check if the leading particule inside the cone has a ptLead larger than fPtThreshold
 527
 528       if( fDebug > 0 )
 529         printf("\t track %d, pT %2.2f, eta %1.2f, phi %2.2f, R candidate %2.2f", ipr,pt,eta,phi,rad);
 530
 531       if(rad < fConeSize)
 532       {
 533         if(fDebug > 0)  printf(" -  inside candidate cone");
 534
 535         if(bFillAOD)
 536         {
 537           ntrackrefs++;
 538           if(ntrackrefs == 1)
 539           {
 540             reftracks = new TObjArray(0);
 541             //reftracks->SetName(Form("Tracks%s",aodArrayRefName.Data()));
 542             TString tempo(aodArrayRefName)  ;
 543             tempo += "Tracks" ;
 544             reftracks->SetName(tempo);
 545             reftracks->SetOwner(kFALSE);
 546           }
 547           reftracks->Add(track);
 548         }
 549
 550         coneptsumTrack+=pt;
 551
 552         if( ptLead < pt ) ptLead = pt;
 553
 554 //        // *Before*, count particles in cone
 555 //        if(pt > fPtThreshold && pt < fPtThresholdMax)  n++;
 556 //
 557 //        //if fPtFraction*ptC<fPtThreshold then consider the fPtThreshold directly
 558 //        if(fFracIsThresh)
 559 //        {
 560 //          if( fPtFraction*ptC < fPtThreshold )
 561 //          {
 562 //            if( pt > fPtThreshold )    nfrac++ ;
 563 //          }
 564 //          else
 565 //          {
 566 //            if( pt > fPtFraction*ptC ) nfrac++;
 567 //          }
 568 //        }
 569 //        else
 570 //        {
 571 //          if( pt > fPtFraction*ptC ) nfrac++;
 572 //        }
 573
 574       } // Inside cone
 575
 576       if( fDebug > 0 )  printf("\n");
 577
 578     }// charged particle loop
 579
 580   }//Tracks
 581
 582
 583   //Check neutral particles in cone.
 584   if(plNe &&
 585      (fPartInCone==kOnlyNeutral || fPartInCone==kNeutralAndCharged))
 586   {
 587     TLorentzVector mom ;
 588
 589     for(Int_t ipr = 0;ipr < plNe->GetEntries() ; ipr ++ )
 590     {
 591       AliVCluster * calo = dynamic_cast<AliVCluster *>(plNe->At(ipr)) ;
 592
 593       if(calo)
 594       {
 595         //Get the index where the cluster comes, to retrieve the corresponding vertex
 596         Int_t evtIndex = 0 ;
 597         if (reader->GetMixedEvent())
 598           evtIndex=reader->GetMixedEvent()->EventIndexForCaloCluster(calo->GetID()) ;
 599
 600
 601         //Do not count the candidate (photon or pi0) or the daughters of the candidate
 602         if(calo->GetID() == pCandidate->GetCaloLabel(0) ||
 603            calo->GetID() == pCandidate->GetCaloLabel(1)   ) continue ;
 604
 605         //Skip matched clusters with tracks in case of neutral+charged analysis
 606         if( fPartInCone == kNeutralAndCharged &&
 607            pid->IsTrackMatched(calo,reader->GetCaloUtils(),reader->GetInputEvent()) ) continue ;
 608
 609         //Assume that come from vertex in straight line
 610         calo->GetMomentum(mom,reader->GetVertex(evtIndex)) ;
 611
 612         pt  = mom.Pt()  ;
 613         eta = mom.Eta() ;
 614         phi = mom.Phi() ;
 615       }
 616       else
 617       {// Mixed event stored in AliAODPWG4Particles
 618         AliAODPWG4Particle * calomix = dynamic_cast<AliAODPWG4Particle*>(plNe->At(ipr)) ;
 619         if(!calomix)
 620         {
 621           printf("AliIsolationCut::MakeIsolationCut() - Wrong calo data type, continue\n");
 622           continue;
 623         }
 624
 625         pt  = calomix->Pt();
 626         eta = calomix->Eta();
 627         phi = calomix->Phi() ;
 628       }
 629
 630       if( phi < 0 ) phi+=TMath::TwoPi();
 631
 632       rad = Radius(etaC, phiC, eta, phi);
 633
 634       // ** For the background out of cone **
 635
 636       if(rad > fConeSize)
 637       {
 638         if(eta > (etaC-fConeSize) && eta < (etaC+fConeSize)) phiBandPtSumCluster += pt;
 639         if(phi > (phiC-fConeSize) && phi < (phiC+fConeSize)) etaBandPtSumCluster += pt;
 640       }
 641
 642       // ** For the isolated particle **
 643
 644       // Only loop the particle at the same side of candidate
 645       if(TMath::Abs(phi-phiC)>TMath::PiOver2()) continue ;
 646
 647       // If at the same side has particle larger than candidate,
 648       // then candidate can not be the leading, skip such events
 649       if(pt > ptC)
 650       {
 651         n         = -1;
 652         nfrac     = -1;
 653         coneptsumCluster = -1;
 654         isolated  = kFALSE;
 655
 656         pCandidate->SetLeadingParticle(kFALSE);
 657
 658         if(bFillAOD)
 659         {
 660           if(reftracks)
 661           {
 662             reftracks  ->Clear();
 663             delete reftracks;
 664           }
 665
 666           if(refclusters)
 667           {
 668             refclusters->Clear();
 669             delete refclusters;
 670           }
 671         }
 672         return ;
 673       }
 674
 675       //Check if there is any particle inside cone with pt larger than  fPtThreshold
 676
 677       if(fDebug > 0 )
 678         printf("\t cluster %d, pT %2.2f, eta %1.2f, phi %2.2f, R candidate %2.2f", ipr,pt,eta,phi,rad);
 679
 680       if(rad < fConeSize)
 681       {
 682         if(fDebug > 0 )  printf(" - inside candidate cone");
 683
 684         if(bFillAOD)
 685         {
 686           nclusterrefs++;
 687           if(nclusterrefs==1)
 688           {
 689             refclusters = new TObjArray(0);
 690             //refclusters->SetName(Form("Clusters%s",aodArrayRefName.Data()));
 691             TString tempo(aodArrayRefName)  ;
 692             tempo += "Clusters" ;
 693             refclusters->SetName(tempo);
 694             refclusters->SetOwner(kFALSE);
 695           }
 696           refclusters->Add(calo);
 697         }
 698
 699         coneptsumCluster+=pt;
 700
 701         if( ptLead < pt ) ptLead = pt;
 702
 703 //        // *Before*, count particles in cone
 704 //        if(pt > fPtThreshold && pt < fPtThresholdMax)  n++;
 705 //
 706 //        //if fPtFraction*ptC<fPtThreshold then consider the fPtThreshold directly
 707 //        if(fFracIsThresh)
 708 //        {
 709 //          if( fPtFraction*ptC < fPtThreshold )
 710 //          {
 711 //            if( pt > fPtThreshold )    nfrac++ ;
 712 //          }
 713 //          else
 714 //          {
 715 //            if( pt > fPtFraction*ptC ) nfrac++;
 716 //          }
 717 //        }
 718 //        else
 719 //        {
 720 //          if( pt > fPtFraction*ptC ) nfrac++;
 721 //        }
 722
 723       }//in cone
 724
 725       if(fDebug > 0 )  printf("\n");
 726
 727     }// neutral particle loop
 728
 729   }//neutrals
 730
 731   //Add reference arrays to AOD when filling AODs only
 732   if(bFillAOD)
 733   {
 734     if(refclusters)     pCandidate->AddObjArray(refclusters);
 735     if(reftracks)         pCandidate->AddObjArray(reftracks);
 736   }
 737
 738   coneptsum = coneptsumCluster + coneptsumTrack;
 739
 740   // *Now*, just check the leading particle in the cone if the threshold is passed
 741   if(ptLead > fPtThreshold && ptLead < fPtThresholdMax)  n = 1;
 742
 743   //if fPtFraction*ptC<fPtThreshold then consider the fPtThreshold directly
 744   if(fFracIsThresh)
 745   {
 746     if( fPtFraction*ptC < fPtThreshold )
 747     {
 748       if( ptLead > fPtThreshold )    nfrac = 1 ;
 749     }
 750     else
 751     {
 752       if( ptLead > fPtFraction*ptC ) nfrac = 1;
 753     }
 754   }
 755   else
 756   {
 757     if( ptLead > fPtFraction*ptC ) nfrac = 1;
 758   }
 759
 760   //-------------------------------------------------------------------
 761   //Check isolation, depending on selected isolation criteria requested
 762
 763   if( fICMethod == kPtThresIC)
 764   {
 765     if( n == 0 ) isolated = kTRUE ;
 766   }
 767   else if( fICMethod == kSumPtIC )
 768   {
 769     if( coneptsum > fSumPtThreshold &&
 770         coneptsum < fSumPtThresholdMax )
 771       isolated  =  kFALSE ;
 772     else
 773       isolated  =  kTRUE  ;
 774   }
 775   else if( fICMethod == kPtFracIC )
 776   {
 777     if(nfrac == 0 ) isolated = kTRUE ;
 778   }
 779   else if( fICMethod == kSumPtFracIC )
 780   {
 781     //when the fPtFraction*ptC < fSumPtThreshold then consider the later case
 782     // printf("photon analysis IsDataMC() ?%i\n",IsDataMC());
 783     if( fFracIsThresh )
 784     {
 785       if( fPtFraction*ptC < fSumPtThreshold  && coneptsum < fSumPtThreshold ) isolated  =  kTRUE ;
 786       if( fPtFraction*ptC > fSumPtThreshold  && coneptsum < fPtFraction*ptC ) isolated  =  kTRUE ;
 787     }
 788     else
 789     {
 790       if( coneptsum < fPtFraction*ptC ) isolated  =  kTRUE ;
 791     }
 792   }
 793   else if( fICMethod == kSumDensityIC )
 794   {
 795     // Get good cell density (number of active cells over all cells in cone)
 796     // and correct energy in cone
 797
 798     Float_t cellDensity = GetCellDensity(pCandidate,reader);
 799
 800     if( coneptsum < fSumPtThreshold*cellDensity )
 801       isolated = kTRUE;
 802   }
 803   else if( fICMethod == kSumBkgSubIC )
 804   {
 805     Double_t coneptsumBkg = 0.;
 806     Float_t  etaBandPtSumTrackNorm   = 0;
 807     Float_t  phiBandPtSumTrackNorm   = 0;
 808     Float_t  etaBandPtSumClusterNorm = 0;
 809     Float_t  phiBandPtSumClusterNorm = 0;
 810
 811     Float_t  excessFracEtaTrack   = 1;
 812     Float_t  excessFracPhiTrack   = 1;
 813     Float_t  excessFracEtaCluster = 1;
 814     Float_t  excessFracPhiCluster = 1;
 815
 816     // Normalize background to cone area
 817     if     (fPartInCone != kOnlyCharged       )
 818       CalculateUEBandClusterNormalization(reader, etaC, phiC,
 819                                           phiBandPtSumCluster    , etaBandPtSumCluster,
 820                                           phiBandPtSumClusterNorm, etaBandPtSumClusterNorm,
 821                                           excessFracEtaCluster   , excessFracPhiCluster    );
 822     if     (fPartInCone != kOnlyNeutral       )
 823       CalculateUEBandTrackNormalization(reader, etaC, phiC,
 824                                           phiBandPtSumTrack    , etaBandPtSumTrack  ,
 825                                           phiBandPtSumTrackNorm, etaBandPtSumTrackNorm,
 826                                           excessFracEtaTrack   , excessFracPhiTrack    );
 827
 828     if     (fPartInCone == kOnlyCharged       ) coneptsumBkg = etaBandPtSumTrackNorm;
 829     else if(fPartInCone == kOnlyNeutral       ) coneptsumBkg = etaBandPtSumClusterNorm;
 830     else if(fPartInCone == kNeutralAndCharged ) coneptsumBkg = etaBandPtSumClusterNorm + etaBandPtSumTrackNorm;
 831
 832     //coneptsumCluster*=(coneBadCellsCoeff*excessFracEtaCluster*excessFracPhiCluster) ; // apply this correction earlier???
 833     // line commented out in last modif!!!
 834
 835     coneptsum = coneptsumCluster+coneptsumTrack;
 836
 837     coneptsum -= coneptsumBkg;
 838
 839     if( coneptsum > fSumPtThreshold && coneptsum < fSumPtThresholdMax )
 840       isolated  =  kFALSE ;
 841     else
 842       isolated  =  kTRUE  ;
 843
 844   }
 845
 846 }
 847
 848 //_____________________________________________________
 849 void AliIsolationCut::Print(const Option_t * opt) const
 850 {
 851
 852   //Print some relevant parameters set for the analysis
 853   if(! opt)
 854     return;
 855
 856   printf("**** Print %s %s **** \n", GetName(), GetTitle() ) ;
 857
 858   printf("IC method          =     %d\n",    fICMethod   ) ;
 859   printf("Cone Size          =     %1.2f\n", fConeSize   ) ;
 860   printf("pT threshold       =     %2.1f\n", fPtThreshold) ;
 861   printf("pT fraction        =     %3.1f\n", fPtFraction ) ;
 862   printf("particle type in cone =  %d\n",    fPartInCone ) ;
 863   printf("using fraction for high pt leading instead of frac ? %i\n",fFracIsThresh);
 864   printf("    \n") ;
 865
 866 }
 867
 868 //___________________________________________________________________________
 869 Float_t AliIsolationCut::Radius(Float_t etaC, Float_t phiC,
 870                                 Float_t eta , Float_t phi) const
 871 {
 872   // Calculate the distance to trigger from any particle
 873
 874   Float_t dEta = etaC-eta;
 875   Float_t dPhi = phiC-phi;
 876
 877   if(TMath::Abs(dPhi) >= TMath::Pi())
 878     dPhi = TMath::TwoPi()-TMath::Abs(dPhi);
 879
 880   return TMath::Sqrt( dEta*dEta + dPhi*dPhi );
 881
 882 }
 883
 884
 885