PWGGA/CaloTrackCorrelations/AliAnaParticleIsolation.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 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 for analysis of particle isolation
  18 // Input is selected particles put in AOD branch (AliAODPWG4ParticleCorrelation)
  19 //
  20 //  Class created from old AliPHOSGammaJet
  21 //  (see AliRoot versions previous Release 4-09)
  22 //
  23 // -- Author: Gustavo Conesa (LNF-INFN)
  24 //
  25 //////////////////////////////////////////////////////////////////////////////
  26
  27 // --- ROOT system ---
  28 #include <TClonesArray.h>
  29 #include <TList.h>
  30 #include <TObjString.h>
  31 #include <TH2F.h>
  32 #include <TClass.h>
  33 #include <TH2F.h>
  34 #include "TParticle.h"
  35 #include "TDatabasePDG.h"
  36
  37 // --- Analysis system ---
  38 #include "AliAnaParticleIsolation.h"
  39 #include "AliCaloTrackReader.h"
  40 #include "AliStack.h"
  41 #include "AliIsolationCut.h"
  42 #include "AliFiducialCut.h"
  43 #include "AliMCAnalysisUtils.h"
  44 #include "AliNeutralMesonSelection.h"
  45 #include "AliAODMCParticle.h"
  46 #include "AliAODPWG4ParticleCorrelation.h"
  47 #include "AliMCAnalysisUtils.h"
  48 #include "AliVTrack.h"
  49 #include "AliVCluster.h"
  50 #include "AliESDEvent.h"
  51 #include "AliAODEvent.h"
  52 // --- Detectors ---
  53 #include "AliEMCALGeometry.h"
  54 #include "AliPHOSGeoUtils.h"
  55
  56 ClassImp(AliAnaParticleIsolation)
  57
  58 //______________________________________________________________________________
  59 AliAnaParticleIsolation::AliAnaParticleIsolation() :
  60 AliAnaCaloTrackCorrBaseClass(),
  61 fIsoDetector(-1),                 fIsoDetectorString(""),
  62 fReMakeIC(0),                     fMakeSeveralIC(0),
  63 fFillTMHisto(0),                  fFillSSHisto(1),
  64 fFillUEBandSubtractHistograms(1), fFillCellHistograms(0),
  65 fFillTaggedDecayHistograms(0),
  66 fNDecayBits(0),                   fDecayBits(),
  67 fFillNLMHistograms(0),
  68 fLeadingOnly(0),                  fCheckLeadingWithNeutralClusters(0),
  69 fSelectPrimariesInCone(0),        fMakePrimaryPi0DecayStudy(0),
  70 fFillBackgroundBinHistograms(0),  fNBkgBin(0),
  71 fFillPtTrigBinHistograms(0),      fNPtTrigBin(0),
  72 fMinCellsAngleOverlap(0),
  73 // Several IC
  74 fNCones(0),                       fNPtThresFrac(0),
  75 fConeSizes(),                     fPtThresholds(),
  76 fPtFractions(),                   fSumPtThresholds(),
  77 fMomentum(),                      fMomIso(),
  78 fMomDaugh1(),                     fMomDaugh2(),
  79 fTrackVector(),
  80 // Histograms
  81 fhEIso(0),                        fhPtIso(0),
  82 fhPtCentralityIso(0),             fhPtEventPlaneIso(0),
  83 fhPtNLocMaxIso(0),
  84 fhPhiIso(0),                      fhEtaIso(0),                              fhEtaPhiIso(0),
  85 fhEtaPhiNoIso(0),
  86 fhENoIso(0),                      fhPtNoIso(0),                             fhPtNLocMaxNoIso(0),
  87 fhPtInCone(0),
  88 fhPtClusterInCone(0),             fhPtCellInCone(0),                        fhPtTrackInCone(0),
  89 fhPtTrackInConeOtherBC(0),        fhPtTrackInConeOtherBCPileUpSPD(0),
  90 fhPtTrackInConeBC0(0),            fhPtTrackInConeVtxBC0(0),
  91 fhPtTrackInConeBC0PileUpSPD(0),
  92 fhPtInConePileUp(),               fhPtInConeCent(0),
  93 fhPerpConeSumPt(0),               fhPtInPerpCone(0),
  94 fhEtaPhiInConeCluster(0),         fhEtaPhiCluster(0),
  95 fhEtaPhiInConeTrack(0),           fhEtaPhiTrack(0),
  96 fhEtaBandCluster(0),              fhPhiBandCluster(0),
  97 fhEtaBandTrack(0),                fhPhiBandTrack(0),
  98 fhEtaBandCell(0),                 fhPhiBandCell(0),
  99 fhConePtLead(0),                  fhConePtLeadCluster(0),                   fhConePtLeadTrack(0),
 100 fhConePtLeadClustervsTrack(0),    fhConePtLeadClusterTrackFrac(0),
 101 fhConeSumPt(0),                   fhConeSumPtCellTrack(0),
 102 fhConeSumPtCell(0),               fhConeSumPtCluster(0),                    fhConeSumPtTrack(0),
 103 fhConeSumPtEtaBandUECluster(0),             fhConeSumPtPhiBandUECluster(0),
 104 fhConeSumPtEtaBandUETrack(0),               fhConeSumPtPhiBandUETrack(0),
 105 fhConeSumPtEtaBandUECell(0),                fhConeSumPtPhiBandUECell(0),
 106 fhConeSumPtTrigEtaPhi(0),
 107 fhConeSumPtCellTrackTrigEtaPhi(0),
 108 fhConeSumPtEtaBandUEClusterTrigEtaPhi(0),   fhConeSumPtPhiBandUEClusterTrigEtaPhi(0),
 109 fhConeSumPtEtaBandUETrackTrigEtaPhi(0),     fhConeSumPtPhiBandUETrackTrigEtaPhi(0),
 110 fhConeSumPtEtaBandUECellTrigEtaPhi(0),      fhConeSumPtPhiBandUECellTrigEtaPhi(0),
 111 fhConeSumPtEtaUESub(0),                     fhConeSumPtPhiUESub(0),
 112 fhConeSumPtEtaUESubTrigEtaPhi(0),           fhConeSumPtPhiUESubTrigEtaPhi(0),
 113 fhConeSumPtEtaUESubTrackCell(0),            fhConeSumPtPhiUESubTrackCell(0),
 114 fhConeSumPtEtaUESubTrackCellTrigEtaPhi(0),  fhConeSumPtPhiUESubTrackCellTrigEtaPhi(0),
 115 fhConeSumPtEtaUESubCluster(0),              fhConeSumPtPhiUESubCluster(0),
 116 fhConeSumPtEtaUESubClusterTrigEtaPhi(0),    fhConeSumPtPhiUESubClusterTrigEtaPhi(0),
 117 fhConeSumPtEtaUESubCell(0),                 fhConeSumPtPhiUESubCell(0),
 118 fhConeSumPtEtaUESubCellTrigEtaPhi(0),       fhConeSumPtPhiUESubCellTrigEtaPhi(0),
 119 fhConeSumPtEtaUESubTrack(0),                fhConeSumPtPhiUESubTrack(0),
 120 fhConeSumPtEtaUESubTrackTrigEtaPhi(0),      fhConeSumPtPhiUESubTrackTrigEtaPhi(0),
 121 fhFractionTrackOutConeEta(0),               fhFractionTrackOutConeEtaTrigEtaPhi(0),
 122 fhFractionClusterOutConeEta(0),             fhFractionClusterOutConeEtaTrigEtaPhi(0),
 123 fhFractionClusterOutConePhi(0),             fhFractionClusterOutConePhiTrigEtaPhi(0),
 124 fhFractionCellOutConeEta(0),                fhFractionCellOutConeEtaTrigEtaPhi(0),
 125 fhFractionCellOutConePhi(0),                fhFractionCellOutConePhiTrigEtaPhi(0),
 126 fhConeSumPtClustervsTrack(0),               fhConeSumPtClusterTrackFrac(0),
 127 fhConeSumPtEtaUESubClustervsTrack(0),       fhConeSumPtPhiUESubClustervsTrack(0),
 128 fhConeSumPtCellvsTrack(0),
 129 fhConeSumPtEtaUESubCellvsTrack(0),          fhConeSumPtPhiUESubCellvsTrack(0),
 130 fhEtaBandClustervsTrack(0),                 fhPhiBandClustervsTrack(0),
 131 fhEtaBandNormClustervsTrack(0),             fhPhiBandNormClustervsTrack(0),
 132 fhEtaBandCellvsTrack(0),                    fhPhiBandCellvsTrack(0),
 133 fhEtaBandNormCellvsTrack(0),                fhPhiBandNormCellvsTrack(0),
 134 fhConeSumPtSubvsConeSumPtTotPhiTrack(0),    fhConeSumPtSubNormvsConeSumPtTotPhiTrack(0),
 135 fhConeSumPtSubvsConeSumPtTotEtaTrack(0),    fhConeSumPtSubNormvsConeSumPtTotEtaTrack(0),
 136 fhConeSumPtSubvsConeSumPtTotPhiCluster(0),  fhConeSumPtSubNormvsConeSumPtTotPhiCluster(0),
 137 fhConeSumPtSubvsConeSumPtTotEtaCluster(0),  fhConeSumPtSubNormvsConeSumPtTotEtaCluster(0),
 138 fhConeSumPtSubvsConeSumPtTotPhiCell(0),     fhConeSumPtSubNormvsConeSumPtTotPhiCell(0),
 139 fhConeSumPtSubvsConeSumPtTotEtaCell(0),     fhConeSumPtSubNormvsConeSumPtTotEtaCell(0),
 140 fhConeSumPtVSUETracksEtaBand(0),            fhConeSumPtVSUETracksPhiBand(0),
 141 fhConeSumPtVSUEClusterEtaBand(0),           fhConeSumPtVSUEClusterPhiBand(0),
 142 fhPtPrimMCPi0DecayPairOutOfCone(0),
 143 fhPtPrimMCPi0DecayPairOutOfAcceptance(0),
 144 fhPtPrimMCPi0DecayPairOutOfAcceptanceNoOverlap(0),
 145 fhPtPrimMCPi0DecayPairAcceptInConeLowPt(0),
 146 fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlap(0),
 147 fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlapCaloE(0),
 148 fhPtPrimMCPi0DecayPairNoOverlap(0),
 149 fhPtPrimMCPi0DecayIsoPairOutOfCone(0),
 150 fhPtPrimMCPi0DecayIsoPairOutOfAcceptance(0),
 151 fhPtPrimMCPi0DecayIsoPairOutOfAcceptanceNoOverlap(0),
 152 fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPt(0),
 153 fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlap(0),
 154 fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlapCaloE(0),
 155 fhPtPrimMCPi0DecayIsoPairNoOverlap(0),
 156 fhPtPrimMCPi0Overlap(0),                    fhPtPrimMCPi0IsoOverlap(0),
 157 fhPtLeadConeBin(0),                         fhSumPtConeBin(0),
 158 fhPtLeadConeBinMC(0),                       fhSumPtConeBinMC(0),
 159 fhPtLeadConeBinDecay(0),                    fhSumPtConeBinDecay(0),
 160 fhPtLeadConeBinLambda0(0),                  fhSumPtConeBinLambda0(0),
 161 fhPtLeadConeBinLambda0MC(0),                fhSumPtConeBinLambda0MC(0),
 162 fhPtTrigBinPtLeadCone(0),                   fhPtTrigBinSumPtCone(0),
 163 fhPtTrigBinPtLeadConeMC(0),                 fhPtTrigBinSumPtConeMC(0),
 164 fhPtTrigBinPtLeadConeDecay(0),              fhPtTrigBinSumPtConeDecay(0),
 165 fhPtTrigBinLambda0vsPtLeadCone(0),          fhPtTrigBinLambda0vsSumPtCone(0),
 166 fhPtTrigBinLambda0vsPtLeadConeMC(0),        fhPtTrigBinLambda0vsSumPtConeMC(0),
 167 // Number of local maxima in cluster
 168 fhNLocMax(),
 169 fhELambda0LocMax1(),              fhELambda1LocMax1(),
 170 fhELambda0LocMax2(),              fhELambda1LocMax2(),
 171 fhELambda0LocMaxN(),              fhELambda1LocMaxN(),
 172 // PileUp
 173 fhEIsoPileUp(),                   fhPtIsoPileUp(),
 174 fhENoIsoPileUp(),                 fhPtNoIsoPileUp(),
 175 fhTimeENoCut(0),                  fhTimeESPD(0),                  fhTimeESPDMulti(0),
 176 fhTimeNPileUpVertSPD(0),          fhTimeNPileUpVertTrack(0),
 177 fhTimeNPileUpVertContributors(0),
 178 fhTimePileUpMainVertexZDistance(0), fhTimePileUpMainVertexZDiamond(0)
 179 {
 180   //default ctor
 181
 182   //Initialize parameters
 183   InitParameters();
 184
 185   for(Int_t i = 0; i < 5 ; i++)
 186   {
 187     fConeSizes[i]      = 0 ;
 188
 189     for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
 190       fhSumPtLeadingPtMC[imc][i] = 0 ;
 191
 192     for(Int_t j = 0; j < 5 ; j++)
 193     {
 194       fhPtThresIsolated             [i][j] = 0 ;
 195       fhPtFracIsolated              [i][j] = 0 ;
 196       fhSumPtIsolated               [i][j] = 0 ;
 197
 198       fhEtaPhiPtThresIso            [i][j] = 0 ;
 199       fhEtaPhiPtThresDecayIso       [i][j] = 0 ;
 200       fhPtPtThresDecayIso           [i][j] = 0 ;
 201
 202       fhEtaPhiPtFracIso             [i][j] = 0 ;
 203       fhEtaPhiPtFracDecayIso        [i][j] = 0 ;
 204       fhPtPtFracDecayIso            [i][j] = 0 ;
 205       fhPtPtSumDecayIso             [i][j] = 0 ;
 206       fhPtSumDensityIso             [i][j] = 0 ;
 207       fhPtSumDensityDecayIso        [i][j] = 0 ;
 208       fhEtaPhiSumDensityIso         [i][j] = 0 ;
 209       fhEtaPhiSumDensityDecayIso    [i][j] = 0 ;
 210       fhPtFracPtSumIso              [i][j] = 0 ;
 211       fhPtFracPtSumDecayIso         [i][j] = 0 ;
 212       fhEtaPhiFracPtSumIso          [i][j] = 0 ;
 213       fhEtaPhiFracPtSumDecayIso     [i][j] = 0 ;
 214
 215       for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
 216       {
 217         fhPtThresIsolatedMC[imc][i][j] = 0 ;
 218         fhPtFracIsolatedMC [imc][i][j] = 0 ;
 219         fhSumPtIsolatedMC  [imc][i][j] = 0 ;
 220
 221       }
 222     }
 223   }
 224
 225   for(Int_t ibit =0; ibit < 4; ibit++)
 226   {
 227     for(Int_t iso =0; iso < 2; iso++)
 228     {
 229       fhPtDecay       [iso][ibit] = 0;
 230       fhEtaPhiDecay   [iso][ibit] = 0;
 231       fhPtLambda0Decay[iso][ibit] = 0;
 232       for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
 233         fhPtDecayMC[iso][ibit][imc]    = 0;
 234     }
 235   }
 236
 237   for(Int_t i = 0; i < 5 ; i++)
 238   {
 239     fPtFractions    [i] = 0 ;
 240     fPtThresholds   [i] = 0 ;
 241     fSumPtThresholds[i] = 0 ;
 242
 243     fhSumPtLeadingPt    [i] = 0 ;
 244     fhPtLeadingPt       [i] = 0 ;
 245     fhPerpSumPtLeadingPt[i] = 0 ;
 246     fhPerpPtLeadingPt   [i] = 0 ;
 247   }
 248
 249   for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
 250   {
 251     fhPtNoIsoMC  [imc]    = 0;
 252     fhPtIsoMC    [imc]    = 0;
 253     fhPhiIsoMC   [imc]    = 0;
 254     fhEtaIsoMC   [imc]    = 0;
 255     fhPtLambda0MC[imc][0] = 0;
 256     fhPtLambda0MC[imc][1] = 0;
 257   }
 258
 259   for(Int_t i = 0; i < 2 ; i++)
 260   {
 261     fhTrackMatchedDEta[i] = 0 ;             fhTrackMatchedDPhi[i] = 0 ;   fhTrackMatchedDEtaDPhi  [i] = 0 ;
 262     fhdEdx            [i] = 0 ;             fhEOverP          [i] = 0 ;   fhTrackMatchedMCParticle[i] = 0 ;
 263     fhELambda0        [i] = 0 ;             fhPtLambda0       [i] = 0 ;   //fhELambda1        [i] = 0 ;
 264     fhELambda0TRD     [i] = 0 ;             fhPtLambda0TRD    [i] = 0 ;   //fhELambda1TRD     [i] = 0 ;
 265
 266     // Number of local maxima in cluster
 267     fhNLocMax        [i] = 0 ;
 268     fhELambda0LocMax1[i] = 0 ;              fhELambda1LocMax1[i] = 0 ;
 269     fhELambda0LocMax2[i] = 0 ;              fhELambda1LocMax2[i] = 0 ;
 270     fhELambda0LocMaxN[i] = 0 ;              fhELambda1LocMaxN[i] = 0 ;
 271   }
 272
 273   // Acceptance
 274   for(Int_t i = 0; i < fgkNmcPrimTypes; i++)
 275   {
 276     fhPtPrimMCiso[i] = 0;
 277     fhEPrimMC    [i] = 0;
 278     fhPtPrimMC   [i] = 0;
 279     fhEtaPrimMC  [i] = 0;
 280     fhPhiPrimMC  [i] = 0;
 281   }
 282
 283   // Pile-Up
 284
 285   for(Int_t i = 0 ; i < 7 ; i++)
 286   {
 287     fhPtInConePileUp[i] = 0 ;
 288     fhEIsoPileUp    [i] = 0 ;
 289     fhPtIsoPileUp   [i] = 0 ;
 290     fhENoIsoPileUp  [i] = 0 ;
 291     fhPtNoIsoPileUp [i] = 0 ;
 292   }
 293 }
 294
 295 //_______________________________________________________________________________________________
 296 void AliAnaParticleIsolation::CalculateCaloUEBand(AliAODPWG4ParticleCorrelation * pCandidate,
 297                                                   Float_t & etaBandPtSum, Float_t & phiBandPtSum)
 298 {
 299   // Get the clusters pT or sum of pT in phi/eta bands or at 45 degrees from trigger
 300
 301   if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyCharged ) return ;
 302
 303   Float_t conesize   = GetIsolationCut()->GetConeSize();
 304
 305   //Select the Calorimeter
 306   TObjArray * pl = 0x0;
 307   if      (GetCalorimeter() == kPHOS )
 308     pl    = GetPHOSClusters();
 309   else if (GetCalorimeter() == kEMCAL)
 310     pl    = GetEMCALClusters();
 311
 312   if(!pl) return ;
 313
 314   //Get vertex for cluster momentum calculation
 315   Double_t vertex[] = {0,0,0} ; //vertex ;
 316   if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
 317     GetReader()->GetVertex(vertex);
 318
 319   Float_t ptTrig    = pCandidate->Pt() ;
 320   Float_t phiTrig   = pCandidate->Phi();
 321   Float_t etaTrig   = pCandidate->Eta();
 322
 323   for(Int_t icluster=0; icluster < pl->GetEntriesFast(); icluster++)
 324   {
 325     AliVCluster* cluster = (AliVCluster *) pl->At(icluster);
 326
 327     if ( !cluster )
 328     {
 329       AliWarning("Cluster not available?");
 330       continue;
 331     }
 332
 333     //Do not count the candidate (photon or pi0) or the daughters of the candidate
 334     if(cluster->GetID() == pCandidate->GetCaloLabel(0) ||
 335        cluster->GetID() == pCandidate->GetCaloLabel(1)   ) continue ;
 336
 337     //Remove matched clusters to tracks if Neutral and Track info is used
 338     if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged &&
 339        IsTrackMatched(cluster,GetReader()->GetInputEvent())) continue ;
 340
 341     cluster->GetMomentum(fMomentum,vertex) ;//Assume that come from vertex in straight line
 342
 343     //exclude particles in cone
 344     Float_t rad = GetIsolationCut()->Radius(etaTrig, phiTrig, fMomentum.Eta(), fMomentum.Phi());
 345
 346     // histo of eta and phi for all clusters
 347     fhEtaPhiCluster->Fill(fMomentum.Eta(), fMomentum.Phi());
 348     if(rad < conesize) {
 349         // histos for all clusters in cone
 350       fhEtaPhiInConeCluster->Fill(fMomentum.Eta(), fMomentum.Phi());
 351       continue ;
 352     }
 353     //fill histogram for UE in phi band in EMCal acceptance
 354     if(fMomentum.Eta() > (etaTrig-conesize) && fMomentum.Eta()  < (etaTrig+conesize))
 355     {
 356       phiBandPtSum+=fMomentum.Pt();
 357       fhPhiBandCluster->Fill(fMomentum.Eta(),fMomentum.Phi());
 358
 359     }
 360
 361     //fill histogram for UE in eta band in EMCal acceptance
 362     if(fMomentum.Phi() > (phiTrig-conesize) && fMomentum.Phi() < (phiTrig+conesize))
 363     {
 364       etaBandPtSum+=fMomentum.Pt();
 365       fhEtaBandCluster->Fill(fMomentum.Eta(),fMomentum.Phi());
 366     }
 367   }
 368
 369   fhConeSumPtEtaBandUECluster          ->Fill(ptTrig  ,       etaBandPtSum);
 370   fhConeSumPtPhiBandUECluster          ->Fill(ptTrig  ,       phiBandPtSum);
 371   fhConeSumPtEtaBandUEClusterTrigEtaPhi->Fill(etaTrig,phiTrig,etaBandPtSum);
 372   fhConeSumPtPhiBandUEClusterTrigEtaPhi->Fill(etaTrig,phiTrig,phiBandPtSum);
 373
 374 }
 375
 376 //________________________________________________________________________________________________
 377 void AliAnaParticleIsolation::CalculateCaloCellUEBand(AliAODPWG4ParticleCorrelation * pCandidate,
 378                                                       Float_t & etaBandPtSumCells, Float_t & phiBandPtSumCells)
 379 {
 380   // Get the cells amplitude or sum of amplitude in phi/eta bands or at 45 degrees from trigger
 381
 382   if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyCharged ) return ;
 383
 384   Float_t conesize = GetIsolationCut()->GetConeSize();
 385
 386   Float_t phiTrig = pCandidate->Phi();
 387   if(phiTrig<0) phiTrig += TMath::TwoPi();
 388   Float_t etaTrig = pCandidate->Eta();
 389
 390   if(pCandidate->GetDetectorTag()==kEMCAL)
 391   {
 392     AliEMCALGeometry* eGeom = AliEMCALGeometry::GetInstance();
 393     Int_t absId = -999;
 394
 395     if (eGeom->GetAbsCellIdFromEtaPhi(etaTrig,phiTrig,absId))
 396     {
 397       if(!eGeom->CheckAbsCellId(absId)) return ;
 398
 399       // Get absolute (col,row) of trigger particle
 400       Int_t nSupMod = eGeom->GetSuperModuleNumber(absId);
 401       Int_t nModule = -1;
 402       Int_t imEta=-1, imPhi=-1;
 403       Int_t ieta =-1, iphi =-1;
 404
 405       if (eGeom->GetCellIndex(absId,nSupMod,nModule,imPhi,imEta))
 406       {
 407         eGeom->GetCellPhiEtaIndexInSModule(nSupMod,nModule,imPhi,imEta,iphi,ieta);
 408
 409         Int_t colTrig = ieta;
 410         if (nSupMod % 2) colTrig = AliEMCALGeoParams::fgkEMCALCols + ieta ;
 411         Int_t rowTrig = iphi + AliEMCALGeoParams::fgkEMCALRows*int(nSupMod/2);
 412
 413         Int_t sqrSize = int(conesize/0.0143);
 414
 415         AliVCaloCells * cells = GetEMCALCells();
 416
 417         Int_t nTotalRows = AliEMCALGeoParams::fgkEMCALRows*16/3 ; // 24*(16/3) 5 full-size Sectors (2 SM) + 1 one-third Sector (2 SM)
 418         Int_t nTotalCols = 2*AliEMCALGeoParams::fgkEMCALCols;
 419         //  printf("nTotalRows %i, nTotalCols %i\n",nTotalRows,nTotalCols);
 420         // Loop on cells in eta band
 421
 422                   Int_t irowmin = rowTrig-sqrSize;
 423         if(irowmin<0) irowmin=0;
 424         Int_t irowmax = rowTrig+sqrSize;
 425         if(irowmax>AliEMCALGeoParams::fgkEMCALRows) irowmax=AliEMCALGeoParams::fgkEMCALRows;
 426
 427
 428         for(Int_t irow = irowmin; irow <irowmax; irow++)
 429         {
 430           for(Int_t icol = 0; icol < nTotalCols; icol++)
 431           {
 432             Int_t inSector = int(irow/AliEMCALGeoParams::fgkEMCALRows);
 433             if(inSector==5) continue;
 434             Int_t inSupMod = -1;
 435             Int_t icolLoc  = -1;
 436             if(icol < AliEMCALGeoParams::fgkEMCALCols)
 437             {
 438               inSupMod = 2*inSector + 1;
 439               icolLoc  = icol;
 440             }
 441             else if(icol > AliEMCALGeoParams::fgkEMCALCols - 1)
 442             {
 443               inSupMod = 2*inSector;
 444               icolLoc  = icol-AliEMCALGeoParams::fgkEMCALCols;
 445             }
 446
 447             Int_t irowLoc  = irow - AliEMCALGeoParams::fgkEMCALRows*inSector ;
 448
 449             // Exclude cells in cone
 450             if(TMath::Abs(icol-colTrig) < sqrSize || TMath::Abs(irow-rowTrig) < sqrSize){
 451               continue ;
 452             }
 453             Int_t iabsId = eGeom->GetAbsCellIdFromCellIndexes(inSupMod,irowLoc,icolLoc);
 454             if(!eGeom->CheckAbsCellId(iabsId)) continue;
 455             etaBandPtSumCells += cells->GetCellAmplitude(iabsId);
 456             fhEtaBandCell->Fill(colTrig,rowTrig);
 457
 458             //          printf("ETA inSupMod %i,irowLoc %i,icolLoc %i, iabsId %i, etaBandPtSumCells %f\n",nSupMod,irowLoc,icolLoc,iabsId,etaBandPtSumCells);
 459           }
 460         }
 461         Int_t icolmin = colTrig-sqrSize;
 462         if(icolmin<0) icolmin=0;
 463         Int_t icolmax = colTrig+sqrSize;
 464         if(icolmax>AliEMCALGeoParams::fgkEMCALCols) icolmax=AliEMCALGeoParams::fgkEMCALCols;
 465
 466         // Loop on cells in phi band
 467         for(Int_t icol = icolmin; icol < icolmax; icol++)
 468         {
 469           for(Int_t irow = 0; irow < nTotalRows; irow++)
 470           {
 471             Int_t inSector = int(irow/AliEMCALGeoParams::fgkEMCALRows);
 472             if(inSector==5) continue;
 473             Int_t inSupMod = -1;
 474             Int_t icolLoc  = -1;
 475             //    printf("icol %i, irow %i, inSector %i\n",icol,irow ,inSector);
 476             if(icol < AliEMCALGeoParams::fgkEMCALCols)
 477             {
 478               //        printf("icol < AliEMCALGeoParams::fgkEMCALCols %i\n",AliEMCALGeoParams::fgkEMCALCols );
 479               inSupMod = 2*inSector + 1;
 480               icolLoc  = icol;
 481             }
 482             else if(icol > AliEMCALGeoParams::fgkEMCALCols - 1)
 483             {
 484               //      printf("icol > AliEMCALGeoParams::fgkEMCALCols -1 %i\n",AliEMCALGeoParams::fgkEMCALCols -1 );
 485               inSupMod = 2*inSector;
 486               icolLoc  = icol-AliEMCALGeoParams::fgkEMCALCols;
 487             }
 488
 489             Int_t irowLoc  = irow - AliEMCALGeoParams::fgkEMCALRows*inSector ;   // Stesso problema di sopra //
 490
 491             // Exclude cells in cone
 492             if(TMath::Abs(icol-colTrig) < sqrSize) {
 493               //printf("TMath::Abs(icol-colTrig) %i < sqrSize %i\n",TMath::Abs(icol-colTrig) ,sqrSize);continue ;
 494             }
 495             if(TMath::Abs(irow-rowTrig) < sqrSize) {
 496               //printf("TMath::Abs(irow-rowTrig) %i < sqrSize %i\n",TMath::Abs(irow-rowTrig) ,sqrSize);continue ;
 497             }
 498
 499             Int_t iabsId = eGeom->GetAbsCellIdFromCellIndexes(inSupMod,irowLoc,icolLoc);
 500             if(!eGeom->CheckAbsCellId(iabsId))
 501             {
 502               AliWarning(Form("!eGeom->CheckAbsCellId(iabsId=%i) inSupMod %i irowLoc %i icolLoc %i",iabsId,inSupMod, irowLoc, icolLoc));
 503               continue;
 504             }
 505             phiBandPtSumCells += cells->GetCellAmplitude(iabsId);
 506             fhPhiBandCell->Fill(colTrig,rowTrig);
 507             //printf("inSupMod %i,irowLoc %i,icolLoc %i, iabsId %i, phiBandPtSumCells %f\n",nSupMod,irowLoc,icolLoc,iabsId,phiBandPtSumCells);
 508           }
 509         }
 510       }
 511     }
 512   }
 513
 514   Float_t ptTrig = pCandidate->Pt();
 515
 516   fhConeSumPtEtaBandUECell          ->Fill(ptTrig ,        etaBandPtSumCells);
 517   fhConeSumPtPhiBandUECell          ->Fill(ptTrig ,        phiBandPtSumCells);
 518   fhConeSumPtEtaBandUECellTrigEtaPhi->Fill(etaTrig,phiTrig,etaBandPtSumCells);
 519   fhConeSumPtPhiBandUECellTrigEtaPhi->Fill(etaTrig,phiTrig,phiBandPtSumCells);
 520
 521 }
 522
 523 //________________________________________________________________________________________________
 524 void AliAnaParticleIsolation::CalculateTrackUEBand(AliAODPWG4ParticleCorrelation * pCandidate,
 525                                                    Float_t & etaBandPtSum, Float_t & phiBandPtSum)
 526 {
 527   // Get the track pT or sum of pT in phi/eta bands or at 45 degrees from trigger
 528
 529   if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyNeutral ) return ;
 530
 531   Float_t conesize   = GetIsolationCut()->GetConeSize();
 532
 533   Double_t sumptPerp= 0. ;
 534   Float_t ptTrig    = pCandidate->Pt() ;
 535   Float_t phiTrig   = pCandidate->Phi();
 536   Float_t etaTrig   = pCandidate->Eta();
 537
 538   TObjArray * trackList   = GetCTSTracks() ;
 539   for(Int_t itrack=0; itrack < trackList->GetEntriesFast(); itrack++)
 540   {
 541     AliVTrack* track = (AliVTrack *) trackList->At(itrack);
 542
 543     if(!track)
 544     {
 545       AliWarning("Track not available?");
 546       continue;
 547     }
 548
 549     //Do not count the candidate (pion, conversion photon) or the daughters of the candidate
 550     if(track->GetID() == pCandidate->GetTrackLabel(0) || track->GetID() == pCandidate->GetTrackLabel(1) ||
 551        track->GetID() == pCandidate->GetTrackLabel(2) || track->GetID() == pCandidate->GetTrackLabel(3)   ) continue ;
 552
 553     // histo of eta:phi for all tracks
 554     fhEtaPhiTrack->Fill(track->Eta(),track->Phi());
 555
 556     //exclude particles in cone
 557     Float_t rad = GetIsolationCut()->Radius(etaTrig, phiTrig, track->Eta(), track->Phi());
 558     if(rad < conesize) {
 559         // histo of eta:phi for all tracks in cone
 560       fhEtaPhiInConeTrack->Fill(track->Eta(),track->Phi());
 561       continue ;
 562     }
 563
 564     //fill histogram for UE in phi band
 565     if(track->Eta() > (etaTrig-conesize) && track->Eta()  < (etaTrig+conesize))
 566     {
 567       phiBandPtSum+=track->Pt();
 568       fhPhiBandTrack->Fill(track->Eta(),track->Phi());
 569     }
 570
 571     //fill histogram for UE in eta band in EMCal acceptance
 572     if(track->Phi() > (phiTrig-conesize) && track->Phi() < (phiTrig+conesize))
 573     {
 574       etaBandPtSum+=track->Pt();
 575       fhEtaBandTrack->Fill(track->Eta(),track->Phi());
 576     }
 577
 578     //fill the histograms at +-45 degrees in phi from trigger particle, perpedicular to trigger axis in phi
 579     Double_t dPhi = phiTrig - track->Phi() + TMath::PiOver2();
 580     Double_t dEta = etaTrig - track->Eta();
 581     Double_t arg  = dPhi*dPhi + dEta*dEta;
 582     if(TMath::Sqrt(arg) < conesize)
 583     {
 584       fhPtInPerpCone->Fill(ptTrig,TMath::Sqrt(track->Px()*track->Px()+track->Py()*track->Py()));
 585       sumptPerp+=track->Pt();
 586     }
 587
 588     dPhi = phiTrig - track->Phi() - TMath::PiOver2();
 589     arg  = dPhi*dPhi + dEta*dEta;
 590     if(TMath::Sqrt(arg) < conesize)
 591     {
 592       fhPtInPerpCone->Fill(ptTrig,TMath::Sqrt(track->Px()*track->Px()+track->Py()*track->Py()));
 593       sumptPerp+=track->Pt();
 594     }
 595   }
 596
 597   fhPerpConeSumPt                    ->Fill(ptTrig ,        sumptPerp   );
 598   fhConeSumPtEtaBandUETrack          ->Fill(ptTrig ,        etaBandPtSum);
 599   fhConeSumPtPhiBandUETrack          ->Fill(ptTrig ,        phiBandPtSum);
 600   fhConeSumPtEtaBandUETrackTrigEtaPhi->Fill(etaTrig,phiTrig,etaBandPtSum);
 601   fhConeSumPtPhiBandUETrackTrigEtaPhi->Fill(etaTrig,phiTrig,phiBandPtSum);
 602
 603 }
 604
 605
 606
 607 //_____________________________________________________________________________________________________________________________________
 608 void AliAnaParticleIsolation::CalculateNormalizeUEBandPerUnitArea(AliAODPWG4ParticleCorrelation * pCandidate, Float_t coneptsumCluster,
 609                                                                   Float_t coneptsumCell,          Float_t coneptsumTrack,
 610                                                                   Float_t &etaBandptsumTrackNorm, Float_t &etaBandptsumClusterNorm)
 611 {
 612   //normalize phi/eta band per area unit
 613
 614   Float_t etaUEptsumTrack   = 0 ;
 615   Float_t phiUEptsumTrack   = 0 ;
 616   Float_t etaUEptsumCluster = 0 ;
 617   Float_t phiUEptsumCluster = 0 ;
 618   Float_t etaUEptsumCell    = 0 ;
 619   Float_t phiUEptsumCell    = 0 ;
 620
 621   Int_t   partTypeInCone    = GetIsolationCut()->GetParticleTypeInCone();
 622
 623   // Do the normalization
 624
 625   Float_t conesize  = GetIsolationCut()->GetConeSize();
 626   Float_t coneA     = conesize*conesize*TMath::Pi(); // A = pi R^2, isolation cone area
 627   Float_t ptTrig    = pCandidate->Pt() ;
 628   Float_t phiTrig   = pCandidate->Phi();
 629   Float_t etaTrig   = pCandidate->Eta();
 630
 631
 632   // ------ //
 633   // Tracks //
 634   // ------ //
 635   Float_t phiUEptsumTrackNorm  = 0 ;
 636   Float_t etaUEptsumTrackNorm  = 0 ;
 637   Float_t coneptsumTrackSubPhi = 0 ;
 638   Float_t coneptsumTrackSubEta = 0 ;
 639   Float_t coneptsumTrackSubPhiNorm = 0 ;
 640   Float_t coneptsumTrackSubEtaNorm = 0 ;
 641   etaBandptsumTrackNorm = 0 ;
 642
 643   if( partTypeInCone!=AliIsolationCut::kOnlyNeutral )
 644   {
 645     // Sum the pT in the phi or eta band for clusters or tracks
 646     CalculateTrackUEBand   (pCandidate,etaUEptsumTrack  ,phiUEptsumTrack  );// rajouter ici l'histo eta phi
 647
 648     //Fill histos
 649     fhConeSumPtVSUETracksEtaBand->Fill(coneptsumTrack,etaUEptsumTrack);
 650     fhConeSumPtVSUETracksPhiBand->Fill(coneptsumTrack,phiUEptsumTrack);
 651
 652
 653     Float_t correctConeSumTrack    = 1;
 654     Float_t correctConeSumTrackPhi = 1;
 655
 656     GetIsolationCut()->CalculateUEBandTrackNormalization(GetReader(),etaTrig, phiTrig,
 657                                                          phiUEptsumTrack,etaUEptsumTrack,
 658                                                          phiUEptsumTrackNorm,etaUEptsumTrackNorm,
 659                                                          correctConeSumTrack,correctConeSumTrackPhi);
 660
 661     coneptsumTrackSubPhi = coneptsumTrack - phiUEptsumTrackNorm;
 662     coneptsumTrackSubEta = coneptsumTrack - etaUEptsumTrackNorm;
 663
 664     etaBandptsumTrackNorm = etaUEptsumTrackNorm;
 665
 666     fhConeSumPtPhiUESubTrack           ->Fill(ptTrig ,          coneptsumTrackSubPhi);
 667     fhConeSumPtPhiUESubTrackTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumTrackSubPhi);
 668     fhConeSumPtEtaUESubTrack           ->Fill(ptTrig ,          coneptsumTrackSubEta);
 669     fhConeSumPtEtaUESubTrackTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumTrackSubEta);
 670
 671     fhFractionTrackOutConeEta          ->Fill(ptTrig ,         correctConeSumTrack-1);
 672     fhFractionTrackOutConeEtaTrigEtaPhi->Fill(etaTrig, phiTrig,correctConeSumTrack-1);
 673
 674     if(coneptsumTrack > 0)
 675     {
 676       coneptsumTrackSubPhiNorm = coneptsumTrackSubPhi/coneptsumTrack;
 677         coneptsumTrackSubEtaNorm = coneptsumTrackSubEta/coneptsumTrack;
 678     }
 679
 680     fhConeSumPtSubvsConeSumPtTotPhiTrack    ->Fill(coneptsumTrack,coneptsumTrackSubPhi);
 681     fhConeSumPtSubNormvsConeSumPtTotPhiTrack->Fill(coneptsumTrack,coneptsumTrackSubPhiNorm);
 682     fhConeSumPtSubvsConeSumPtTotEtaTrack    ->Fill(coneptsumTrack,coneptsumTrackSubEta);
 683     fhConeSumPtSubNormvsConeSumPtTotEtaTrack->Fill(coneptsumTrack,coneptsumTrackSubEtaNorm);
 684
 685   }
 686
 687   // ------------------------ //
 688   // EMCal Clusters and cells //
 689   // ------------------------ //
 690   Float_t phiUEptsumClusterNorm  = 0 ;
 691   Float_t etaUEptsumClusterNorm  = 0 ;
 692   Float_t coneptsumClusterSubPhi = 0 ;
 693   Float_t coneptsumClusterSubEta = 0 ;
 694   Float_t coneptsumClusterSubPhiNorm = 0 ;
 695   Float_t coneptsumClusterSubEtaNorm = 0 ;
 696   Float_t phiUEptsumCellNorm     = 0 ;
 697   Float_t etaUEptsumCellNorm     = 0 ;
 698   Float_t coneptsumCellSubPhi    = 0 ;
 699   Float_t coneptsumCellSubEta    = 0 ;
 700   Float_t coneptsumCellSubPhiNorm = 0 ;
 701   Float_t coneptsumCellSubEtaNorm = 0 ;
 702   etaBandptsumClusterNorm = 0;
 703
 704   if( partTypeInCone!=AliIsolationCut::kOnlyCharged )
 705   {
 706
 707     // -------------- //
 708     // EMCal clusters //
 709     // -------------- //
 710
 711     // Sum the pT in the phi or eta band for clusters or tracks
 712     CalculateCaloUEBand    (pCandidate,etaUEptsumCluster,phiUEptsumCluster);// rajouter ici l'histo eta phi
 713
 714     //Fill histos
 715     fhConeSumPtVSUEClusterEtaBand->Fill(coneptsumCluster,etaUEptsumCluster);
 716     fhConeSumPtVSUEClusterPhiBand->Fill(coneptsumCluster,phiUEptsumCluster);
 717
 718
 719     Float_t correctConeSumClusterEta = 1;
 720     Float_t correctConeSumClusterPhi = 1;
 721
 722     GetIsolationCut()->CalculateUEBandClusterNormalization(GetReader(),etaTrig, phiTrig,
 723                                                            phiUEptsumCluster,etaUEptsumCluster,
 724                                                            phiUEptsumClusterNorm,etaUEptsumClusterNorm,
 725                                                            correctConeSumClusterEta,correctConeSumClusterPhi);
 726
 727     // In case that cone is out of eta and phi side, we are over correcting, not too often with the current cuts ...
 728     // Comment if not used
 729     //  Float_t coneBadCellsCoeff   =1;
 730     //  Float_t etaBandBadCellsCoeff=1;
 731     //  Float_t phiBandBadCellsCoeff=1;
 732     //  GetIsolationCut()->GetCoeffNormBadCell(pCandidate,   GetReader(),coneBadCellsCoeff,etaBandBadCellsCoeff,phiBandBadCellsCoeff) ;
 733
 734     //coneptsumCluster=coneptsumCluster*coneBadCellsCoeff*correctConeSumClusterEta*correctConeSumClusterPhi;
 735
 736     coneptsumClusterSubPhi = coneptsumCluster - phiUEptsumClusterNorm;
 737     coneptsumClusterSubEta = coneptsumCluster - etaUEptsumClusterNorm;
 738
 739     etaBandptsumClusterNorm = etaUEptsumClusterNorm;
 740
 741     fhConeSumPtPhiUESubCluster           ->Fill(ptTrig ,          coneptsumClusterSubPhi);
 742     fhConeSumPtPhiUESubClusterTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumClusterSubPhi);
 743     fhConeSumPtEtaUESubCluster           ->Fill(ptTrig ,          coneptsumClusterSubEta);
 744     fhConeSumPtEtaUESubClusterTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumClusterSubEta);
 745
 746     fhFractionClusterOutConeEta          ->Fill(ptTrig ,          correctConeSumClusterEta-1);
 747     fhFractionClusterOutConeEtaTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumClusterEta-1);
 748     fhFractionClusterOutConePhi          ->Fill(ptTrig ,          correctConeSumClusterPhi-1);
 749     fhFractionClusterOutConePhiTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumClusterPhi-1);
 750
 751     if(coneptsumCluster!=0)
 752     {
 753             coneptsumClusterSubPhiNorm = coneptsumClusterSubPhi/coneptsumCluster;
 754         coneptsumClusterSubEtaNorm = coneptsumClusterSubEta/coneptsumCluster;
 755     }
 756
 757     fhConeSumPtSubvsConeSumPtTotPhiCluster    ->Fill(coneptsumCluster,coneptsumClusterSubPhi);
 758     fhConeSumPtSubNormvsConeSumPtTotPhiCluster->Fill(coneptsumCluster,coneptsumClusterSubPhiNorm);
 759     fhConeSumPtSubvsConeSumPtTotEtaCluster    ->Fill(coneptsumCluster,coneptsumClusterSubEta);
 760     fhConeSumPtSubNormvsConeSumPtTotEtaCluster->Fill(coneptsumCluster,coneptsumClusterSubEtaNorm);
 761
 762     // ----------- //
 763     // EMCal Cells //
 764     // ----------- //
 765
 766     if(fFillCellHistograms)
 767     {
 768       // Sum the pT in the phi or eta band for clusters or tracks
 769       CalculateCaloCellUEBand(pCandidate,etaUEptsumCell   ,phiUEptsumCell   );
 770
 771       // Move to AliIsolationCut the calculation not the histograms??
 772
 773       //Careful here if EMCal limits changed .. 2010 (4 SM) to 2011-12 (10 SM), for the moment consider 100 deg in phi
 774       Float_t emcEtaSize = 0.7*2; // TO FIX
 775       Float_t emcPhiSize = TMath::DegToRad()*100.; // TO FIX
 776
 777       if(((2*conesize*emcPhiSize)-coneA)!=0)phiUEptsumCellNorm = phiUEptsumCell*(coneA / ((2*conesize*emcPhiSize)-coneA));
 778       if(((2*conesize*emcEtaSize)-coneA)!=0)etaUEptsumCellNorm = etaUEptsumCell*(coneA / ((2*conesize*emcEtaSize)-coneA));
 779
 780       // Need to correct coneptsumCluster by the fraction of the cone out of the calorimeter cut acceptance!
 781
 782       Float_t correctConeSumCellEta = 1;
 783       if(TMath::Abs(etaTrig)+conesize > emcEtaSize/2.)
 784       {
 785         Float_t excess = TMath::Abs(etaTrig) + conesize - emcEtaSize/2.;
 786         correctConeSumCellEta = GetIsolationCut()->CalculateExcessAreaFraction(excess);
 787         //printf("Excess EMC-Eta %2.3f, coneA %2.2f,  excessA %2.2f, angle %2.2f,factor %2.2f\n",excess,coneA, excessA, angle*TMath::RadToDeg(), correctConeSumClusterEta);
 788         // Need to correct phi band surface if part of the cone falls out of track cut acceptance!
 789         if(((2*(conesize-excess)*emcPhiSize)-(coneA-correctConeSumCellEta))!=0)phiUEptsumCellNorm = phiUEptsumCell*(coneA / ((2*(conesize-excess)*emcPhiSize)-(coneA-correctConeSumCellEta)));
 790       }
 791
 792       Float_t correctConeSumCellPhi = 1;
 793       //printf("EMCPhiTrig %2.2f, conesize %2.2f, sum %2.2f, rest %2.2f \n",phiTrig*TMath::RadToDeg(),conesize*TMath::RadToDeg(),(phiTrig+conesize)*TMath::RadToDeg(),(phiTrig-conesize)*TMath::RadToDeg() );
 794       if((phiTrig+conesize > 180*TMath::DegToRad()) ||
 795          (phiTrig-conesize <  80*TMath::DegToRad()))
 796       {
 797         Float_t excess = 0;
 798         if( phiTrig+conesize > 180*TMath::DegToRad() ) excess = conesize + phiTrig - 180*TMath::DegToRad() ;
 799         else                                           excess = conesize - phiTrig +  80*TMath::DegToRad() ;
 800
 801         correctConeSumCellPhi = GetIsolationCut()->CalculateExcessAreaFraction(excess);
 802         //printf("Excess EMC-Phi %2.3f, coneA %2.2f,  excessA %2.2f, angle %2.2f,factor %2.2f\n",excess,coneA, excessA, angle*TMath::RadToDeg(), correctConeSumClusterPhi);
 803
 804         // Need to correct eta band surface if part of the cone falls out of track cut acceptance!
 805         if(((2*(conesize-excess)*emcEtaSize)-(coneA-correctConeSumCellPhi))!=0)etaUEptsumCellNorm = etaUEptsumCell*(coneA / ((2*(conesize-excess)*emcEtaSize)-(coneA-correctConeSumCellPhi)));
 806
 807       }
 808
 809       // In case that cone is out of eta and phi side, we are over correcting, not too often with the current cuts ...
 810       coneptsumCellSubPhi = coneptsumCell*correctConeSumCellEta*correctConeSumCellPhi - phiUEptsumCellNorm;
 811       coneptsumCellSubEta = coneptsumCell*correctConeSumCellEta*correctConeSumCellPhi - etaUEptsumCellNorm;
 812
 813       fhConeSumPtPhiUESubCell           ->Fill(ptTrig ,          coneptsumCellSubPhi);
 814       fhConeSumPtPhiUESubCellTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumCellSubPhi);
 815       fhConeSumPtEtaUESubCell           ->Fill(ptTrig ,          coneptsumCellSubEta);
 816       fhConeSumPtEtaUESubCellTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumCellSubEta);
 817
 818       fhFractionCellOutConeEta          ->Fill(ptTrig ,          correctConeSumCellEta-1);
 819       fhFractionCellOutConeEtaTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumCellEta-1);
 820       fhFractionCellOutConePhi          ->Fill(ptTrig ,          correctConeSumCellPhi-1);
 821       fhFractionCellOutConePhiTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumCellPhi-1);
 822       if(coneptsumCell!=0)
 823       {
 824         coneptsumCellSubPhiNorm = coneptsumCellSubPhi/coneptsumCell;
 825         coneptsumCellSubEtaNorm = coneptsumCellSubEta/coneptsumCell;
 826       }
 827
 828       fhConeSumPtSubvsConeSumPtTotPhiCell    ->Fill(coneptsumCell,coneptsumCellSubPhi);
 829       fhConeSumPtSubNormvsConeSumPtTotPhiCell->Fill(coneptsumCell,coneptsumCellSubPhiNorm);
 830       fhConeSumPtSubvsConeSumPtTotEtaCell    ->Fill(coneptsumCell,coneptsumCellSubEta);
 831       fhConeSumPtSubNormvsConeSumPtTotEtaCell->Fill(coneptsumCell,coneptsumCellSubEtaNorm);
 832     }
 833   }
 834
 835   if( partTypeInCone==AliIsolationCut::kNeutralAndCharged )
 836   {
 837     // --------------------------- //
 838     // Tracks and clusters in cone //
 839     // --------------------------- //
 840
 841     Double_t sumPhiUESub = coneptsumClusterSubPhi + coneptsumTrackSubPhi;
 842     Double_t sumEtaUESub = coneptsumClusterSubEta + coneptsumTrackSubEta;
 843
 844     fhConeSumPtPhiUESub          ->Fill(ptTrig ,          sumPhiUESub);
 845     fhConeSumPtPhiUESubTrigEtaPhi->Fill(etaTrig, phiTrig, sumPhiUESub);
 846     fhConeSumPtEtaUESub          ->Fill(ptTrig ,          sumEtaUESub);
 847     fhConeSumPtEtaUESubTrigEtaPhi->Fill(etaTrig, phiTrig, sumEtaUESub);
 848
 849     fhEtaBandClustervsTrack    ->Fill(etaUEptsumCluster    ,etaUEptsumTrack    );
 850     fhPhiBandClustervsTrack    ->Fill(phiUEptsumCluster    ,phiUEptsumTrack    );
 851     fhEtaBandNormClustervsTrack->Fill(etaUEptsumClusterNorm,etaUEptsumTrackNorm);
 852     fhPhiBandNormClustervsTrack->Fill(phiUEptsumClusterNorm,phiUEptsumTrackNorm);
 853
 854     fhConeSumPtEtaUESubClustervsTrack->Fill(coneptsumClusterSubEta,coneptsumTrackSubEta);
 855     fhConeSumPtPhiUESubClustervsTrack->Fill(coneptsumClusterSubPhi,coneptsumTrackSubPhi);
 856
 857     // ------------------------ //
 858     // Tracks and cells in cone //
 859     // ------------------------ //
 860
 861     if(fFillCellHistograms)
 862     {
 863       Double_t sumPhiUESubTrackCell = coneptsumCellSubPhi + coneptsumTrackSubPhi;
 864       Double_t sumEtaUESubTrackCell = coneptsumCellSubEta + coneptsumTrackSubEta;
 865
 866       fhConeSumPtPhiUESubTrackCell          ->Fill(ptTrig ,          sumPhiUESubTrackCell);
 867       fhConeSumPtPhiUESubTrackCellTrigEtaPhi->Fill(etaTrig, phiTrig, sumPhiUESubTrackCell);
 868       fhConeSumPtEtaUESubTrackCell          ->Fill(ptTrig ,          sumEtaUESubTrackCell);
 869       fhConeSumPtEtaUESubTrackCellTrigEtaPhi->Fill(etaTrig, phiTrig, sumEtaUESubTrackCell);
 870
 871       fhEtaBandCellvsTrack    ->Fill(etaUEptsumCell    ,etaUEptsumTrack    );
 872       fhPhiBandCellvsTrack    ->Fill(phiUEptsumCell    ,phiUEptsumTrack    );
 873       fhEtaBandNormCellvsTrack->Fill(etaUEptsumCellNorm,etaUEptsumTrackNorm);
 874       fhPhiBandNormCellvsTrack->Fill(phiUEptsumCellNorm,phiUEptsumTrackNorm);
 875
 876       fhConeSumPtEtaUESubCellvsTrack->Fill(coneptsumCellSubEta,coneptsumTrackSubEta);
 877       fhConeSumPtPhiUESubCellvsTrack->Fill(coneptsumCellSubPhi,coneptsumTrackSubPhi);
 878     }
 879
 880   }
 881 }
 882
 883
 884 //______________________________________________________________________________________________________________
 885 void AliAnaParticleIsolation::CalculateCaloSignalInCone(AliAODPWG4ParticleCorrelation * aodParticle,
 886                                                         Float_t & coneptsumCluster, Float_t & coneptLeadCluster)
 887 {
 888   // Get the cluster pT or sum of pT in isolation cone
 889   coneptLeadCluster = 0;
 890   coneptsumCluster  = 0;
 891
 892   if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyCharged ) return ;
 893
 894   //Recover reference arrays with clusters and tracks
 895   TObjArray * refclusters = aodParticle->GetObjArray(GetAODObjArrayName()+"Clusters");
 896   if(!refclusters) return ;
 897
 898   Float_t ptTrig = aodParticle->Pt();
 899
 900   //Get vertex for cluster momentum calculation
 901   Double_t vertex[] = {0,0,0} ; //vertex ;
 902   if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
 903     GetReader()->GetVertex(vertex);
 904
 905   Float_t ptcone = 0;
 906
 907   for(Int_t icalo=0; icalo < refclusters->GetEntriesFast(); icalo++)
 908   {
 909     AliVCluster* calo = (AliVCluster *) refclusters->At(icalo);
 910     calo->GetMomentum(fMomentum,vertex) ;//Assume that come from vertex in straight line
 911     ptcone = fMomentum.Pt();
 912
 913     fhPtInCone       ->Fill(ptTrig, ptcone);
 914     fhPtClusterInCone->Fill(ptTrig, ptcone);
 915
 916     if(IsPileUpAnalysisOn())
 917     {
 918       if(GetReader()->IsPileUpFromSPD())               fhPtInConePileUp[0]->Fill(ptTrig,ptcone);
 919       if(GetReader()->IsPileUpFromEMCal())             fhPtInConePileUp[1]->Fill(ptTrig,ptcone);
 920       if(GetReader()->IsPileUpFromSPDOrEMCal())        fhPtInConePileUp[2]->Fill(ptTrig,ptcone);
 921       if(GetReader()->IsPileUpFromSPDAndEMCal())       fhPtInConePileUp[3]->Fill(ptTrig,ptcone);
 922       if(GetReader()->IsPileUpFromSPDAndNotEMCal())    fhPtInConePileUp[4]->Fill(ptTrig,ptcone);
 923       if(GetReader()->IsPileUpFromEMCalAndNotSPD())    fhPtInConePileUp[5]->Fill(ptTrig,ptcone);
 924       if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtInConePileUp[6]->Fill(ptTrig,ptcone);
 925     }
 926
 927     if(IsHighMultiplicityAnalysisOn()) fhPtInConeCent->Fill(GetEventCentrality(),ptcone);
 928
 929     coneptsumCluster+=ptcone;
 930     if(ptcone > coneptLeadCluster) coneptLeadCluster = ptcone;
 931   }
 932
 933   fhConeSumPtCluster ->Fill(ptTrig, coneptsumCluster );
 934   fhConePtLeadCluster->Fill(ptTrig, coneptLeadCluster);
 935 }
 936
 937 //______________________________________________________________________________________________________
 938 void AliAnaParticleIsolation::CalculateCaloCellSignalInCone(AliAODPWG4ParticleCorrelation * aodParticle,
 939                                                             Float_t & coneptsumCell)
 940 {
 941   // Get the cell amplityde or sum of amplitudes in isolation cone
 942   // Mising: Remove signal cells in cone in case the trigger is a cluster!
 943
 944   if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyCharged ) return ;
 945
 946   Float_t conesize = GetIsolationCut()->GetConeSize();
 947
 948   Float_t  ptTrig  = aodParticle->Pt();
 949   Float_t  phiTrig = aodParticle->Phi();
 950   if(phiTrig<0) phiTrig += TMath::TwoPi();
 951   Float_t  etaTrig = aodParticle->Eta();
 952
 953   if(aodParticle->GetDetectorTag()==kEMCAL)
 954   {
 955     AliEMCALGeometry* eGeom = AliEMCALGeometry::GetInstance();
 956     Int_t absId = -999;
 957
 958     if (eGeom->GetAbsCellIdFromEtaPhi(etaTrig,phiTrig,absId))
 959     {
 960       if(!eGeom->CheckAbsCellId(absId)) return ;
 961
 962       // Get absolute (col,row) of trigger particle
 963       Int_t nSupMod = eGeom->GetSuperModuleNumber(absId);
 964       Int_t nModule = -1;
 965       Int_t imEta=-1, imPhi=-1;
 966       Int_t ieta =-1, iphi =-1;
 967
 968       if (eGeom->GetCellIndex(absId,nSupMod,nModule,imPhi,imEta))
 969       {
 970         Int_t iEta=-1, iPhi=-1;
 971         eGeom->GetCellPhiEtaIndexInSModule(nSupMod,nModule,imPhi,imEta,iphi,ieta);
 972
 973         Int_t colTrig = iEta;
 974         if (nSupMod % 2) colTrig = AliEMCALGeoParams::fgkEMCALCols + iEta ;
 975         Int_t rowTrig = iPhi + AliEMCALGeoParams::fgkEMCALRows*int(nSupMod/2);
 976
 977         Int_t sqrSize = int(conesize/0.0143);
 978
 979         AliVCaloCells * cells = GetEMCALCells();
 980
 981         // Loop on cells in cone
 982         for(Int_t irow = rowTrig-sqrSize; irow < rowTrig+sqrSize; irow++)
 983         {
 984           for(Int_t icol = colTrig-sqrSize; icol < colTrig+sqrSize; icol++)
 985           {
 986             Int_t inSector = int(irow/AliEMCALGeoParams::fgkEMCALRows);
 987             if(inSector==5) continue;
 988
 989             Int_t inSupMod = -1;
 990             Int_t icolLoc  = -1;
 991             if(icol < AliEMCALGeoParams::fgkEMCALCols)
 992             {
 993               inSupMod = 2*inSector + 1;
 994               icolLoc  = icol;
 995             }
 996             else if(icol > AliEMCALGeoParams::fgkEMCALCols - 1)
 997             {
 998               inSupMod = 2*inSector;
 999               icolLoc  = icol-AliEMCALGeoParams::fgkEMCALCols;
1000             }
1001
1002             Int_t irowLoc  = irow - AliEMCALGeoParams::fgkEMCALRows*inSector ;
1003
1004             Int_t iabsId = eGeom->GetAbsCellIdFromCellIndexes(inSupMod,irowLoc,icolLoc);
1005             if(!eGeom->CheckAbsCellId(iabsId)) continue;
1006
1007             fhPtCellInCone->Fill(ptTrig, cells->GetCellAmplitude(iabsId));
1008             coneptsumCell += cells->GetCellAmplitude(iabsId);
1009           }
1010         }
1011       }
1012     }
1013   }
1014
1015   fhConeSumPtCell->Fill(ptTrig,coneptsumCell);
1016
1017 }
1018
1019 //___________________________________________________________________________________________________________
1020 void AliAnaParticleIsolation::CalculateTrackSignalInCone(AliAODPWG4ParticleCorrelation * aodParticle,
1021                                                          Float_t & coneptsumTrack, Float_t & coneptLeadTrack)
1022 {
1023   // Get the track pT or sum of pT in isolation cone
1024
1025   if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyNeutral ) return ;
1026
1027   //Recover reference arrays with clusters and tracks
1028   TObjArray * reftracks   = aodParticle->GetObjArray(GetAODObjArrayName()+"Tracks");
1029   if(!reftracks) return ;
1030
1031   Float_t  ptTrig = aodParticle->Pt();
1032   Double_t bz     = GetReader()->GetInputEvent()->GetMagneticField();
1033
1034   for(Int_t itrack=0; itrack < reftracks->GetEntriesFast(); itrack++)
1035   {
1036     AliVTrack* track = (AliVTrack *) reftracks->At(itrack);
1037     Float_t pTtrack = track->Pt();
1038
1039     fhPtInCone     ->Fill(ptTrig,pTtrack);
1040     fhPtTrackInCone->Fill(ptTrig,pTtrack);
1041
1042     if(IsPileUpAnalysisOn())
1043     {
1044       ULong_t status = track->GetStatus();
1045       Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
1046       //Double32_t tof = track->GetTOFsignal()*1e-3;
1047       Int_t trackBC = track->GetTOFBunchCrossing(bz);
1048
1049       if     ( okTOF && trackBC!=0 ) fhPtTrackInConeOtherBC->Fill(ptTrig,pTtrack);
1050       else if( okTOF && trackBC==0 ) fhPtTrackInConeBC0    ->Fill(ptTrig,pTtrack);
1051
1052       Int_t vtxBC = GetReader()->GetVertexBC();
1053       if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtTrackInConeVtxBC0->Fill(ptTrig,pTtrack);
1054
1055       if(GetReader()->IsPileUpFromSPD())             { fhPtInConePileUp[0]->Fill(ptTrig,pTtrack);
1056         if(okTOF && trackBC!=0 )                         fhPtTrackInConeOtherBCPileUpSPD->Fill(ptTrig,pTtrack);
1057         if(okTOF && trackBC==0 )                         fhPtTrackInConeBC0PileUpSPD    ->Fill(ptTrig,pTtrack); }
1058       if(GetReader()->IsPileUpFromEMCal())             fhPtInConePileUp[1]->Fill(ptTrig,pTtrack);
1059       if(GetReader()->IsPileUpFromSPDOrEMCal())        fhPtInConePileUp[2]->Fill(ptTrig,pTtrack);
1060       if(GetReader()->IsPileUpFromSPDAndEMCal())       fhPtInConePileUp[3]->Fill(ptTrig,pTtrack);
1061       if(GetReader()->IsPileUpFromSPDAndNotEMCal())    fhPtInConePileUp[4]->Fill(ptTrig,pTtrack);
1062       if(GetReader()->IsPileUpFromEMCalAndNotSPD())    fhPtInConePileUp[5]->Fill(ptTrig,pTtrack);
1063       if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtInConePileUp[6]->Fill(ptTrig,pTtrack);
1064     }
1065
1066     if(IsHighMultiplicityAnalysisOn()) fhPtInConeCent->Fill(GetEventCentrality(),pTtrack);
1067
1068     coneptsumTrack+=pTtrack;
1069     if(pTtrack > coneptLeadTrack) coneptLeadTrack = pTtrack;
1070   }
1071
1072   fhConeSumPtTrack ->Fill(ptTrig, coneptsumTrack );
1073   fhConePtLeadTrack->Fill(ptTrig, coneptLeadTrack);
1074
1075 }
1076
1077 //_________________________________________________________________
1078 void AliAnaParticleIsolation::FillPileUpHistograms(Int_t clusterID)
1079 {
1080   // Fill some histograms to understand pile-up
1081
1082   if ( clusterID < 0 )
1083   {
1084     AliWarning(Form("ID of cluster = %d, not possible!", clusterID));
1085     return;
1086   }
1087
1088   Int_t iclus = -1;
1089   TObjArray* clusters = 0x0;
1090   if     (GetCalorimeter() == kEMCAL) clusters = GetEMCALClusters();
1091   else if(GetCalorimeter() == kPHOS ) clusters = GetPHOSClusters();
1092
1093   Float_t energy = 0;
1094   Float_t time   = -1000;
1095
1096   if(clusters)
1097   {
1098     AliVCluster *cluster = FindCluster(clusters,clusterID,iclus);
1099     energy = cluster->E();
1100     time   = cluster->GetTOF()*1e9;
1101   }
1102
1103   //printf("E %f, time %f\n",energy,time);
1104   AliVEvent * event = GetReader()->GetInputEvent();
1105
1106   fhTimeENoCut->Fill(energy,time);
1107   if(GetReader()->IsPileUpFromSPD())     fhTimeESPD     ->Fill(energy,time);
1108   if(event->IsPileupFromSPDInMultBins()) fhTimeESPDMulti->Fill(energy,time);
1109
1110   if(energy < 8) return; // Fill time figures for high energy clusters not too close to trigger threshold
1111
1112   AliESDEvent* esdEv = dynamic_cast<AliESDEvent*> (event);
1113   AliAODEvent* aodEv = dynamic_cast<AliAODEvent*> (event);
1114
1115   // N pile up vertices
1116   Int_t nVerticesSPD    = -1;
1117   Int_t nVerticesTracks = -1;
1118
1119   if      (esdEv)
1120   {
1121     nVerticesSPD    = esdEv->GetNumberOfPileupVerticesSPD();
1122     nVerticesTracks = esdEv->GetNumberOfPileupVerticesTracks();
1123
1124   }//ESD
1125   else if (aodEv)
1126   {
1127     nVerticesSPD    = aodEv->GetNumberOfPileupVerticesSPD();
1128     nVerticesTracks = aodEv->GetNumberOfPileupVerticesTracks();
1129   }//AOD
1130
1131   fhTimeNPileUpVertSPD  ->Fill(time,nVerticesSPD);
1132   fhTimeNPileUpVertTrack->Fill(time,nVerticesTracks);
1133
1134   //printf("Is SPD %d, Is SPD Multi %d, n spd %d, n track %d\n",
1135   //       GetReader()->IsPileUpFromSPD(),event->IsPileupFromSPDInMultBins(),nVerticesSPD,nVerticesTracks);
1136
1137   Int_t ncont = -1;
1138   Float_t z1 = -1, z2 = -1;
1139   Float_t diamZ = -1;
1140   for(Int_t iVert=0; iVert<nVerticesSPD;iVert++)
1141   {
1142     if      (esdEv)
1143     {
1144       const AliESDVertex* pv=esdEv->GetPileupVertexSPD(iVert);
1145       ncont=pv->GetNContributors();
1146       z1 = esdEv->GetPrimaryVertexSPD()->GetZ();
1147       z2 = pv->GetZ();
1148       diamZ = esdEv->GetDiamondZ();
1149     }//ESD
1150     else if (aodEv)
1151     {
1152       AliAODVertex *pv=aodEv->GetVertex(iVert);
1153       if(pv->GetType()!=AliAODVertex::kPileupSPD) continue;
1154       ncont=pv->GetNContributors();
1155       z1=aodEv->GetPrimaryVertexSPD()->GetZ();
1156       z2=pv->GetZ();
1157       diamZ = aodEv->GetDiamondZ();
1158     }// AOD
1159
1160     Double_t distZ  = TMath::Abs(z2-z1);
1161     diamZ  = TMath::Abs(z2-diamZ);
1162
1163     fhTimeNPileUpVertContributors  ->Fill(time,ncont);
1164     fhTimePileUpMainVertexZDistance->Fill(time,distZ);
1165     fhTimePileUpMainVertexZDiamond ->Fill(time,diamZ);
1166
1167   }// loop
1168 }
1169
1170 //_____________________________________________________________________________________________________________________
1171 void AliAnaParticleIsolation::FillTrackMatchingShowerShapeControlHistograms(AliAODPWG4ParticleCorrelation  *pCandidate,
1172                                                                             Float_t coneptsum, Float_t coneleadpt,
1173                                                                             Int_t mcIndex)
1174 {
1175   // Fill Track matching and Shower Shape control histograms
1176   if(!fFillTMHisto && !fFillSSHisto && !fFillBackgroundBinHistograms && !fFillTaggedDecayHistograms) return;
1177
1178   Int_t  clusterID = pCandidate->GetCaloLabel(0) ;
1179   Int_t  nMaxima   = pCandidate->GetNLM();
1180   Int_t  mcTag     = pCandidate->GetTag() ;
1181   Bool_t isolated  = pCandidate->IsIsolated();
1182
1183   if ( clusterID < 0 )
1184   {
1185     AliWarning(Form("ID of cluster = %d, not possible!", clusterID));
1186     return;
1187   }
1188
1189   Float_t m02    = pCandidate->GetM02() ;
1190   Float_t energy = pCandidate->E();
1191   Float_t pt     = pCandidate->Pt();
1192   Float_t eta    = pCandidate->Eta();
1193   Float_t phi    = pCandidate->Phi();
1194   if(phi<0) phi+= TMath::TwoPi();
1195
1196   // Candidates tagged as decay in another analysis (AliAnaPi0EbE)
1197   if(fFillTaggedDecayHistograms)
1198   {
1199     Int_t decayTag = pCandidate->DecayTag();
1200     if(decayTag < 0) decayTag = 0;
1201
1202     for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
1203     {
1204       if(!GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit])) continue;
1205
1206       if(fFillSSHisto) fhPtLambda0Decay[isolated][ibit]->Fill(pt,m02);
1207
1208       // In case it was not done on the trigger selection task
1209       // apply here a shower shape cut, not too strong, to select photons
1210       if( m02 < 0.3 ) continue;
1211
1212       fhPtDecay    [isolated][ibit]->Fill(pt);
1213       fhEtaPhiDecay[isolated][ibit]->Fill(eta,phi);
1214
1215       if(IsDataMC())
1216       {
1217         fhPtDecayMC[isolated][ibit][mcIndex]->Fill(pt);
1218
1219         if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
1220           fhPtDecayMC[isolated][ibit][kmcPhoton]->Fill(pt);
1221
1222         if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==kmcPi0Decay )
1223           fhPtDecayMC[isolated][ibit][kmcPi0DecayLostPair]->Fill(pt);
1224       }
1225     } // bit loop
1226   } // decay histograms
1227
1228
1229   // Get the max pt leading in cone or the sum of pt in cone
1230   // assign a bin to the candidate, depending on both quantities
1231   // see the shower shape in those bins.
1232   if(fFillBackgroundBinHistograms)
1233   {
1234     // Get the background bin for this cone and trigger
1235     Int_t ptsumBin  = -1;
1236     Int_t leadptBin = -1;
1237
1238     AliDebug(1,Form("pT cand: %2.2f, In cone pT: Sum %2.2f, Lead %2.2f, n bins %d",pt,coneptsum,coneleadpt,fNBkgBin));
1239
1240     for(Int_t ibin = 0; ibin < fNBkgBin; ibin++)
1241     {
1242       if( coneptsum  >= fBkgBinLimit[ibin] && coneptsum  < fBkgBinLimit[ibin+1]) ptsumBin  = ibin;
1243       if( coneleadpt >= fBkgBinLimit[ibin] && coneleadpt < fBkgBinLimit[ibin+1]) leadptBin = ibin;
1244     }
1245
1246     // Fill the histograms per bin of pt lead or pt sum
1247
1248     if ( leadptBin >= 0 )
1249     {
1250       AliDebug(1,Form("\t Lead bin %d [%2.2f,%2.2f]", leadptBin,fBkgBinLimit[leadptBin],fBkgBinLimit[leadptBin+1]));
1251       fhPtLeadConeBin[leadptBin]->Fill(pt);
1252       if(fFillSSHisto) fhPtLeadConeBinLambda0[leadptBin]->Fill(pt,m02);
1253
1254       if ( leadptBin == 0 )
1255         AliDebug(1,Form("No track/clusters in isolation cone: cand pt %2.2f GeV/c, track multiplicity %d, N clusters %d",
1256                         pt, GetTrackMultiplicity(),GetEMCALClusters()->GetEntriesFast()));
1257     }
1258
1259     if ( ptsumBin  >= 0 )
1260     {
1261       AliDebug(1,Form("\t Sum bin %d [%2.2f,%2.2f]" , ptsumBin ,fBkgBinLimit[ptsumBin] ,fBkgBinLimit[ptsumBin +1]));
1262       fhSumPtConeBin[ptsumBin]->Fill(pt);
1263       if(fFillSSHisto) fhSumPtConeBinLambda0[ptsumBin]->Fill(pt,m02);
1264     }
1265
1266     // Check if it was a decay
1267     if(fFillTaggedDecayHistograms && m02 < 0.3)
1268     {
1269       Int_t decayTag = pCandidate->DecayTag();
1270       if(decayTag < 0) decayTag = 0;
1271       for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
1272       {
1273         if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
1274         {
1275           Int_t leadptBinDecay = leadptBin+ibit*fNBkgBin;
1276           Int_t  ptsumBinDecay =  ptsumBin+ibit*fNBkgBin;
1277           if( leadptBin >=0 ) fhPtLeadConeBinDecay[leadptBinDecay]->Fill(pt);
1278           if( ptsumBin  >=0 ) fhSumPtConeBinDecay [ ptsumBinDecay]->Fill(pt);
1279         }
1280       }
1281     }
1282
1283     if(IsDataMC())
1284     {
1285       Int_t leadptBinMC = leadptBin+mcIndex*fNBkgBin;
1286       Int_t  ptsumBinMC =  ptsumBin+mcIndex*fNBkgBin;
1287
1288       if( leadptBin >=0 )
1289       {
1290         fhPtLeadConeBinMC[leadptBinMC]->Fill(pt);
1291         if(fFillSSHisto) fhPtLeadConeBinLambda0MC[leadptBinMC]->Fill(pt,m02);
1292       }
1293
1294       if( ptsumBin  >=0 )
1295       {
1296          fhSumPtConeBinMC [ ptsumBinMC]->Fill(pt);
1297         if(fFillSSHisto)  fhSumPtConeBinLambda0MC [ ptsumBinMC]->Fill(pt,m02);
1298       }
1299
1300
1301       if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
1302       {
1303         leadptBinMC = leadptBin+kmcPhoton*fNBkgBin;
1304         ptsumBinMC  =  ptsumBin+kmcPhoton*fNBkgBin;
1305         if( leadptBin >=0 )
1306         {
1307           fhPtLeadConeBinMC[leadptBinMC]->Fill(pt);
1308           if(fFillSSHisto) fhPtLeadConeBinLambda0MC[leadptBinMC]->Fill(pt,m02);
1309         }
1310
1311         if( ptsumBin  >=0 )
1312         {
1313           fhSumPtConeBinMC [ ptsumBinMC]->Fill(pt);
1314           if(fFillSSHisto)  fhSumPtConeBinLambda0MC [ ptsumBinMC]->Fill(pt,m02);
1315         }
1316       }
1317     }
1318   }
1319
1320   if(fFillPtTrigBinHistograms)
1321   {
1322     // Get the background bin for this cone and trigger
1323     Int_t ptTrigBin  = -1;
1324
1325     for(Int_t ibin = 0; ibin < fNPtTrigBin; ibin++)
1326     {
1327       if( pt  >= fPtTrigBinLimit[ibin] && coneptsum  < fPtTrigBinLimit[ibin+1]) ptTrigBin  = ibin;
1328     }
1329
1330     // Fill the histograms per pT candidate bin of pt lead or pt sum
1331
1332     if ( ptTrigBin >= 0 )
1333     {
1334       AliDebug(1,Form("Trigger pT %f, bin %d [%2.2f,%2.2f]",pt,ptTrigBin,fPtTrigBinLimit[ptTrigBin],fPtTrigBinLimit[ptTrigBin+1]));
1335
1336       fhPtTrigBinPtLeadCone[ptTrigBin]->Fill(coneleadpt);
1337       fhPtTrigBinSumPtCone [ptTrigBin]->Fill(coneptsum );
1338       if(fFillSSHisto)
1339       {
1340         fhPtTrigBinLambda0vsPtLeadCone[ptTrigBin]->Fill(coneleadpt,m02);
1341         fhPtTrigBinLambda0vsSumPtCone [ptTrigBin]->Fill(coneptsum ,m02);
1342       }
1343     }
1344
1345     // Check if it was a decay
1346     if( fFillTaggedDecayHistograms && m02 < 0.3 )
1347     {
1348       Int_t decayTag = pCandidate->DecayTag();
1349       if(decayTag < 0) decayTag = 0;
1350       for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
1351       {
1352         if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
1353         {
1354           Int_t binDecay = ptTrigBin+ibit*fNPtTrigBin;
1355           if( binDecay > 0 )
1356           {
1357             fhPtTrigBinPtLeadConeDecay[binDecay]->Fill(coneleadpt);
1358             fhPtTrigBinSumPtConeDecay [binDecay]->Fill(coneptsum );
1359           }
1360         }
1361       }
1362     }
1363
1364     if( IsDataMC() )
1365     {
1366       Int_t ptTrigBinMC = ptTrigBin+mcIndex*fNPtTrigBin;
1367
1368       if( ptTrigBin >=0 )
1369       {
1370         fhPtTrigBinPtLeadConeMC[ptTrigBinMC]->Fill(coneleadpt);
1371         fhPtTrigBinSumPtConeMC [ptTrigBinMC]->Fill(coneptsum );
1372         if(fFillSSHisto)
1373         {
1374           fhPtTrigBinLambda0vsPtLeadConeMC[ptTrigBinMC]->Fill(coneleadpt,m02);
1375           fhPtTrigBinLambda0vsSumPtConeMC [ptTrigBinMC]->Fill(coneptsum ,m02);
1376         }
1377       }
1378
1379       if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
1380       {
1381         ptTrigBinMC = ptTrigBin+kmcPhoton*fNPtTrigBin;
1382         if( ptTrigBin >=0 )
1383         {
1384           fhPtTrigBinPtLeadConeMC[ptTrigBinMC]->Fill(coneleadpt);
1385           fhPtTrigBinSumPtConeMC [ptTrigBinMC]->Fill(coneptsum );
1386           if(fFillSSHisto)
1387           {
1388             fhPtTrigBinLambda0vsPtLeadConeMC[ptTrigBinMC]->Fill(coneleadpt,m02);
1389             fhPtTrigBinLambda0vsSumPtConeMC [ptTrigBinMC]->Fill(coneptsum ,m02);
1390           }
1391         }
1392       } // photon MC
1393     } // MC
1394   } // pT trigger bins
1395
1396   // Shower shape dependent histograms
1397   if(fFillSSHisto)
1398   {
1399     fhELambda0 [isolated]->Fill(energy, m02);
1400     fhPtLambda0[isolated]->Fill(pt,     m02);
1401     //fhELambda1 [isolated]->Fill(energy, m20);
1402
1403     if(IsDataMC())
1404     {
1405       if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
1406         fhPtLambda0MC[kmcPhoton][isolated]->Fill(pt,m02);
1407
1408       if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==kmcPi0Decay )
1409         fhPtLambda0MC[kmcPi0DecayLostPair][isolated]->Fill(pt,m02);
1410
1411       fhPtLambda0MC[mcIndex][isolated]->Fill(pt,m02);
1412     }
1413
1414     if(GetCalorimeter() == kEMCAL &&  GetFirstSMCoveredByTRD() >= 0 &&
1415        GetModuleNumber(pCandidate) >= GetFirstSMCoveredByTRD()  )
1416     {
1417       fhELambda0TRD [isolated]->Fill(energy, m02 );
1418       fhPtLambda0TRD[isolated]->Fill(pt    , m02 );
1419       //fhELambda1TRD [isolated]->Fill(energy, m20 );
1420     }
1421
1422     if(fFillNLMHistograms)
1423     {
1424       fhNLocMax[isolated]->Fill(energy,nMaxima);
1425       if     (nMaxima==1) { fhELambda0LocMax1[isolated]->Fill(energy,m02); fhELambda1LocMax1[isolated]->Fill(energy,m02); }
1426       else if(nMaxima==2) { fhELambda0LocMax2[isolated]->Fill(energy,m02); fhELambda1LocMax2[isolated]->Fill(energy,m02); }
1427       else                { fhELambda0LocMaxN[isolated]->Fill(energy,m02); fhELambda1LocMaxN[isolated]->Fill(energy,m02); }
1428     }
1429   } // SS histo fill
1430
1431   // Track matching dependent histograms
1432   if(fFillTMHisto)
1433   {
1434     Int_t iclus = -1;
1435     TObjArray* clusters = 0x0;
1436     if     (GetCalorimeter() == kEMCAL) clusters = GetEMCALClusters();
1437     else if(GetCalorimeter() == kPHOS ) clusters = GetPHOSClusters();
1438
1439     if(!clusters) return;
1440
1441     AliVCluster *cluster = FindCluster(clusters,clusterID,iclus);
1442
1443     Float_t dZ  = cluster->GetTrackDz();
1444     Float_t dR  = cluster->GetTrackDx();
1445
1446     if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
1447     {
1448       dR = 2000., dZ = 2000.;
1449       GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
1450     }
1451
1452     //printf("ParticleIsolation: dPhi %f, dEta %f\n",dR,dZ);
1453     if(fhTrackMatchedDEta[isolated] && TMath::Abs(dR) < 999)
1454     {
1455       fhTrackMatchedDEta[isolated]->Fill(energy,dZ);
1456       fhTrackMatchedDPhi[isolated]->Fill(energy,dR);
1457       if(energy > 0.5) fhTrackMatchedDEtaDPhi[isolated]->Fill(dZ,dR);
1458     }
1459
1460     // Check dEdx and E/p of matched clusters
1461
1462     if(TMath::Abs(dZ) < 0.05 && TMath::Abs(dR) < 0.05)
1463     {
1464
1465       AliVTrack *track = GetCaloUtils()->GetMatchedTrack(cluster, GetReader()->GetInputEvent());
1466
1467       if(track)
1468       {
1469         Float_t dEdx = track->GetTPCsignal();
1470         fhdEdx[isolated]->Fill(cluster->E(), dEdx);
1471
1472         Float_t eOverp = cluster->E()/track->P();
1473         fhEOverP[isolated]->Fill(cluster->E(),  eOverp);
1474       }
1475       //else
1476       //  printf("AliAnaParticleIsolation::FillTrackMatchingShowerShapeHistograms() - Residual OK but (dR, dZ)= (%2.4f,%2.4f) no track associated WHAT? \n", dR,dZ);
1477
1478
1479       if(IsDataMC())
1480       {
1481         if ( !GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion)  )
1482         {
1483           if       ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0)      ||
1484                      GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta)       ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 2.5 );
1485           else if  ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton)    ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 0.5 );
1486           else if  ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron)  ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 1.5 );
1487           else                                                                                   fhTrackMatchedMCParticle[isolated]->Fill(energy, 3.5 );
1488
1489         }
1490         else
1491         {
1492           if       ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0)      ||
1493                      GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta)       ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 6.5 );
1494           else if  ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton)    ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 4.5 );
1495           else if  ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron)  ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 5.5 );
1496           else                                                                                   fhTrackMatchedMCParticle[isolated]->Fill(energy, 7.5 );
1497         }
1498       }  // MC
1499
1500     } // match window
1501
1502   }// TM histos fill
1503
1504 }
1505
1506 //______________________________________________________
1507 TObjString *  AliAnaParticleIsolation::GetAnalysisCuts()
1508 {
1509   //Save parameters used for analysis
1510   TString parList ; //this will be list of parameters used for this analysis.
1511   const Int_t buffersize = 255;
1512   char onePar[buffersize] ;
1513
1514   snprintf(onePar, buffersize,"--- AliAnaParticleIsolation ---:") ;
1515   parList+=onePar ;
1516   snprintf(onePar, buffersize,"Calorimeter: %s;",GetCalorimeterString().Data()) ;
1517   parList+=onePar ;
1518   snprintf(onePar, buffersize,"Isolation Cand Detector: %s;",fIsoDetectorString.Data()) ;
1519   parList+=onePar ;
1520   snprintf(onePar, buffersize,"fReMakeIC =%d (Flag for reisolation during histogram filling);",fReMakeIC) ;
1521   parList+=onePar ;
1522   snprintf(onePar, buffersize,"fMakeSeveralIC=%d (Flag for isolation with several cuts at the same time );",fMakeSeveralIC) ;
1523   parList+=onePar ;
1524   snprintf(onePar, buffersize,"fFillTMHisto=%d (Flag for track matching histograms);",fFillTMHisto) ;
1525   parList+=onePar ;
1526   snprintf(onePar, buffersize,"fFillSSHisto=%d (Flag for shower shape histograms);",fFillSSHisto) ;
1527   parList+=onePar ;
1528
1529   if(fMakeSeveralIC)
1530   {
1531     snprintf(onePar, buffersize,"fNCones =%d (Number of cone sizes);",fNCones) ;
1532     parList+=onePar ;
1533     snprintf(onePar, buffersize,"fNPtThresFrac=%d (Flag for isolation with several cuts at the same time);",fNPtThresFrac) ;
1534     parList+=onePar ;
1535
1536     for(Int_t icone = 0; icone < fNCones ; icone++)
1537     {
1538       snprintf(onePar, buffersize,"fConeSizes[%d]=%1.2f (isolation cone size);",icone, fConeSizes[icone]) ;
1539       parList+=onePar ;
1540     }
1541     for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
1542     {
1543       snprintf(onePar, buffersize,"fPtThresholds[%d]=%1.2f (isolation pt threshold);",ipt, fPtThresholds[ipt]) ;
1544       parList+=onePar ;
1545     }
1546     for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
1547     {
1548       snprintf(onePar, buffersize,"fPtFractions[%d]=%1.2f (isolation pt fraction threshold);",ipt, fPtFractions[ipt]) ;
1549       parList+=onePar ;
1550     }
1551     for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
1552     {
1553       snprintf(onePar, buffersize,"fSumPtThresholds[%d]=%1.2f (isolation sum pt threshold);",ipt, fSumPtThresholds[ipt]) ;
1554       parList+=onePar ;
1555     }
1556   }
1557
1558   //Get parameters set in base class.
1559   parList += GetBaseParametersList() ;
1560
1561   //Get parameters set in IC class.
1562   if(!fMakeSeveralIC)parList += GetIsolationCut()->GetICParametersList() ;
1563
1564   return new TObjString(parList) ;
1565
1566 }
1567
1568 //________________________________________________________
1569 TList *  AliAnaParticleIsolation::GetCreateOutputObjects()
1570 {
1571   // Create histograms to be saved in output file and
1572   // store them in outputContainer
1573   TList * outputContainer = new TList() ;
1574   outputContainer->SetName("IsolatedParticleHistos") ;
1575
1576   Int_t   nptbins  = GetHistogramRanges()->GetHistoPtBins();
1577   Int_t   nphibins = GetHistogramRanges()->GetHistoPhiBins();
1578   Int_t   netabins = GetHistogramRanges()->GetHistoEtaBins();
1579   Float_t ptmax    = GetHistogramRanges()->GetHistoPtMax();
1580   Float_t phimax   = GetHistogramRanges()->GetHistoPhiMax();
1581   Float_t etamax   = GetHistogramRanges()->GetHistoEtaMax();
1582   Float_t ptmin    = GetHistogramRanges()->GetHistoPtMin();
1583   Float_t phimin   = GetHistogramRanges()->GetHistoPhiMin();
1584   Float_t etamin   = GetHistogramRanges()->GetHistoEtaMin();
1585   Int_t   ssbins   = GetHistogramRanges()->GetHistoShowerShapeBins();
1586   Float_t ssmax    = GetHistogramRanges()->GetHistoShowerShapeMax();
1587   Float_t ssmin    = GetHistogramRanges()->GetHistoShowerShapeMin();
1588   Int_t   ntimebins= GetHistogramRanges()->GetHistoTimeBins();
1589   Float_t timemax  = GetHistogramRanges()->GetHistoTimeMax();
1590   Float_t timemin  = GetHistogramRanges()->GetHistoTimeMin();
1591
1592   Int_t   nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins();
1593   Float_t resetamax   = GetHistogramRanges()->GetHistoTrackResidualEtaMax();
1594   Float_t resetamin   = GetHistogramRanges()->GetHistoTrackResidualEtaMin();
1595   Int_t   nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins();
1596   Float_t resphimax   = GetHistogramRanges()->GetHistoTrackResidualPhiMax();
1597   Float_t resphimin   = GetHistogramRanges()->GetHistoTrackResidualPhiMin();
1598
1599   Int_t   ndedxbins   = GetHistogramRanges()->GetHistodEdxBins();
1600   Float_t dedxmax     = GetHistogramRanges()->GetHistodEdxMax();
1601   Float_t dedxmin     = GetHistogramRanges()->GetHistodEdxMin();
1602   Int_t   nPoverEbins = GetHistogramRanges()->GetHistoPOverEBins();
1603   Float_t pOverEmax   = GetHistogramRanges()->GetHistoPOverEMax();
1604   Float_t pOverEmin   = GetHistogramRanges()->GetHistoPOverEMin();
1605
1606   Int_t   nptsumbins    = GetHistogramRanges()->GetHistoNPtSumBins();
1607   Float_t ptsummax      = GetHistogramRanges()->GetHistoPtSumMax();
1608   Float_t ptsummin      = GetHistogramRanges()->GetHistoPtSumMin();
1609   Int_t   nptinconebins = GetHistogramRanges()->GetHistoNPtInConeBins();
1610   Float_t ptinconemax   = GetHistogramRanges()->GetHistoPtInConeMax();
1611   Float_t ptinconemin   = GetHistogramRanges()->GetHistoPtInConeMin();
1612
1613   //Float_t ptthre    = GetIsolationCut()->GetPtThreshold();
1614   //Float_t ptsumthre = GetIsolationCut()->GetSumPtThreshold();
1615   //Float_t ptfrac    = GetIsolationCut()->GetPtFraction();
1616   Float_t r         = GetIsolationCut()->GetConeSize();
1617   Int_t   method    = GetIsolationCut()->GetICMethod() ;
1618   Int_t   particle  = GetIsolationCut()->GetParticleTypeInCone() ;
1619
1620   TString sThreshold = "";
1621   if      ( method == AliIsolationCut::kSumPtIC )
1622   {
1623     sThreshold = Form(", %2.2f < #Sigma #it{p}_{T}^{in cone} < %2.2f GeV/#it{c}",
1624                       GetIsolationCut()->GetSumPtThreshold(), GetIsolationCut()->GetSumPtThresholdMax());
1625     if(GetIsolationCut()->GetSumPtThresholdMax() > 200)
1626       sThreshold = Form(", #Sigma #it{p}_{T}^{in cone} = %2.2f GeV/#it{c}",
1627                         GetIsolationCut()->GetSumPtThreshold());
1628   }
1629   else if ( method == AliIsolationCut::kPtThresIC)
1630   {
1631     sThreshold = Form(", %2.2f < #it{p}_{T}^{th} < %2.2f GeV/#it{c}",
1632                       GetIsolationCut()->GetPtThreshold(),GetIsolationCut()->GetPtThresholdMax());
1633     if(GetIsolationCut()->GetSumPtThreshold() > 200)
1634       sThreshold = Form(", #it{p}_{T}^{th} = %2.2f GeV/#it{c}",
1635                         GetIsolationCut()->GetPtThreshold());
1636   }
1637   else if ( method == AliIsolationCut::kPtFracIC)
1638     sThreshold = Form(", #Sigma #it{p}_{T}^{in cone}/#it{p}_{T}^{trig} = %2.2f" ,
1639                       GetIsolationCut()->GetPtFraction());
1640
1641   TString sParticle = ", x^{0,#pm}";
1642   if      ( particle == AliIsolationCut::kOnlyNeutral )  sParticle = ", x^{0}";
1643   else if ( particle == AliIsolationCut::kOnlyCharged )  sParticle = ", x^{#pm}";
1644
1645   TString parTitle = Form("#it{R} = %2.2f%s%s",GetIsolationCut()->GetConeSize(), sThreshold.Data(),sParticle.Data());
1646
1647   TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ;
1648
1649   // MC histograms title and name
1650   TString mcPartType[] = { "#gamma", "#gamma_{prompt}", "#gamma_{fragmentation}",
1651     "#pi^{0} (merged #gamma)","#gamma_{#pi decay}","#gamma_{#pi decay} lost companion",
1652     "#gamma_{#eta decay}","#gamma_{other decay}",
1653     "e^{#pm}","hadrons?"} ;
1654
1655   TString mcPartName[] = { "Photon","PhotonPrompt","PhotonFrag",
1656     "Pi0","Pi0Decay","Pi0DecayLostPair","EtaDecay","OtherDecay",
1657     "Electron","Hadron"} ;
1658
1659   // Primary MC histograms title and name
1660   TString pptype[] = { "#gamma", "#gamma_{#pi decay}","#gamma_{other decay}",
1661     "#gamma_{prompt}","#gamma_{fragmentation}","#gamma_{ISR}","#pi^{0}"} ;
1662
1663   TString ppname[] = { "Photon","PhotonPi0Decay","PhotonOtherDecay",
1664     "PhotonPrompt","PhotonFrag","PhotonISR","Pi0"} ;
1665
1666   // Not Isolated histograms, reference histograms
1667
1668   fhENoIso  = new TH1F("hENoIso",
1669                        Form("Number of not isolated leading particles vs #it{p}_{T}, %s",parTitle.Data()),
1670                        nptbins,ptmin,ptmax);
1671   fhENoIso->SetYTitle("#it{counts}");
1672   fhENoIso->SetXTitle("E (GeV/#it{c})");
1673   outputContainer->Add(fhENoIso) ;
1674
1675   fhPtNoIso  = new TH1F("hPtNoIso",
1676                         Form("Number of not isolated leading particles vs #it{p}_{T}, %s",parTitle.Data()),
1677                         nptbins,ptmin,ptmax);
1678   fhPtNoIso->SetYTitle("#it{counts}");
1679   fhPtNoIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1680   outputContainer->Add(fhPtNoIso) ;
1681
1682   fhEtaPhiNoIso  = new TH2F("hEtaPhiNoIso",
1683                             Form("Number of not isolated leading particles #eta vs #phi, %s",parTitle.Data()),
1684                             netabins,etamin,etamax,nphibins,phimin,phimax);
1685   fhEtaPhiNoIso->SetXTitle("#eta");
1686   fhEtaPhiNoIso->SetYTitle("#phi");
1687   outputContainer->Add(fhEtaPhiNoIso) ;
1688
1689   if(IsDataMC())
1690   {
1691     // For histograms in arrays, index in the array, corresponding to any particle origin
1692
1693     for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
1694     {
1695       fhPtNoIsoMC[imc]  = new TH1F(Form("hPtNoIsoMC%s",mcPartName[imc].Data()),
1696                                    Form("#it{p}_{T} of NOT isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
1697                                    nptbins,ptmin,ptmax);
1698       fhPtNoIsoMC[imc]->SetYTitle("#it{counts}");
1699       fhPtNoIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1700       outputContainer->Add(fhPtNoIsoMC[imc]) ;
1701
1702       fhPtIsoMC[imc]  = new TH1F(Form("hPtMC%s",mcPartName[imc].Data()),
1703                                  Form("#it{p}_{T} of isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
1704                                  nptbins,ptmin,ptmax);
1705       fhPtIsoMC[imc]->SetYTitle("#it{counts}");
1706       fhPtIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1707       outputContainer->Add(fhPtIsoMC[imc]) ;
1708
1709       fhPhiIsoMC[imc]  = new TH2F(Form("hPhiMC%s",mcPartName[imc].Data()),
1710                                   Form("#phi vs #it{p}_{T} of isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
1711                                   nptbins,ptmin,ptmax,nphibins,phimin,phimax);
1712       fhPhiIsoMC[imc]->SetYTitle("#phi");
1713       fhPhiIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1714       outputContainer->Add(fhPhiIsoMC[imc]) ;
1715
1716       fhEtaIsoMC[imc]  = new TH2F(Form("hEtaMC%s",mcPartName[imc].Data()),
1717                                   Form("#phi vs #it{p}_{T} of isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
1718                                   nptbins,ptmin,ptmax,netabins,etamin,etamax);
1719       fhEtaIsoMC[imc]->SetYTitle("#eta");
1720       fhEtaIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1721       outputContainer->Add(fhEtaIsoMC[imc]) ;
1722     }
1723   }
1724
1725   // Histograms for tagged candidates as decay
1726   if(fFillTaggedDecayHistograms)
1727   {
1728     TString isoName [] = {"NoIso","Iso"};
1729     TString isoTitle[] = {"Not isolated"  ,"isolated"};
1730
1731     for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
1732     {
1733       for(Int_t iso = 0; iso < 2; iso++)
1734       {
1735         if(fMakeSeveralIC && iso) continue;
1736         fhPtDecay[iso][ibit]  =
1737         new TH1F(Form("hPtDecay%s_bit%d",isoName[iso].Data(),fDecayBits[ibit]),
1738                  Form("Number of %s leading pi0 decay particles vs #it{p}_{T}, bit %d, %s",isoTitle[iso].Data(),fDecayBits[ibit],parTitle.Data()),
1739                  nptbins,ptmin,ptmax);
1740         fhPtDecay[iso][ibit]->SetYTitle("#it{counts}");
1741         fhPtDecay[iso][ibit]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1742         outputContainer->Add(fhPtDecay[iso][ibit]) ;
1743
1744         fhEtaPhiDecay[iso][ibit]  =
1745         new TH2F(Form("hEtaPhiDecay%s_bit%d",isoName[iso].Data(),fDecayBits[ibit]),
1746                  Form("Number of %s leading Pi0 decay particles #eta vs #phi, bit %d, %s",isoTitle[iso].Data(),fDecayBits[ibit],parTitle.Data()),
1747                  netabins,etamin,etamax,nphibins,phimin,phimax);
1748         fhEtaPhiDecay[iso][ibit]->SetXTitle("#eta");
1749         fhEtaPhiDecay[iso][ibit]->SetYTitle("#phi");
1750         outputContainer->Add(fhEtaPhiDecay[iso][ibit]) ;
1751
1752         if(fFillSSHisto)
1753         {
1754           fhPtLambda0Decay[iso][ibit]  = new TH2F
1755           (Form("hPtLambda0Decay%s_bit%d",isoName[iso].Data(),fDecayBits[ibit]),
1756            Form("%s cluster : #it{p}_{T} vs #lambda_{0}, decay bit %d, %s",isoTitle[iso].Data(), fDecayBits[ibit], parTitle.Data()),
1757            nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1758           fhPtLambda0Decay[iso][ibit]->SetYTitle("#lambda_{0}^{2}");
1759           fhPtLambda0Decay[iso][ibit]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1760           outputContainer->Add(fhPtLambda0Decay[iso][ibit]) ;
1761         }
1762
1763         if(IsDataMC())
1764         {
1765           for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
1766           {
1767             fhPtDecayMC[iso][ibit][imc]  =
1768             new TH1F(Form("hPtDecay%s_bit%d_MC%s",isoName[iso].Data(),fDecayBits[ibit],mcPartName[imc].Data()),
1769                      Form("#it{p}_{T} of %s, decay bit %d,  %s, %s",isoTitle[iso].Data(),fDecayBits[ibit],mcPartType[imc].Data(),parTitle.Data()),
1770                      nptbins,ptmin,ptmax);
1771             fhPtDecayMC[iso][ibit][imc]->SetYTitle("#it{counts}");
1772             fhPtDecayMC[iso][ibit][imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1773             outputContainer->Add(fhPtDecayMC[iso][ibit][imc]) ;
1774           }// MC particle loop
1775         }// MC
1776       } // bit loop
1777     } //iso loop
1778   }// decay
1779
1780   if(!fMakeSeveralIC)
1781   {
1782     TString isoName [] = {"NoIso","Iso"};
1783     TString isoTitle[] = {"Not isolated"  ,"isolated"};
1784
1785     fhEIso   = new TH1F("hE",
1786                         Form("Number of isolated particles vs E, %s",parTitle.Data()),
1787                         nptbins,ptmin,ptmax);
1788     fhEIso->SetYTitle("d#it{N} / d#it{E}");
1789     fhEIso->SetXTitle("#it{E} (GeV/#it{c})");
1790     outputContainer->Add(fhEIso) ;
1791
1792     fhPtIso  = new TH1F("hPt",
1793                         Form("Number of isolated particles vs #it{p}_{T}, %s",parTitle.Data()),
1794                         nptbins,ptmin,ptmax);
1795     fhPtIso->SetYTitle("d#it{N} / #it{p}_{T}");
1796     fhPtIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1797     outputContainer->Add(fhPtIso) ;
1798
1799     fhPhiIso  = new TH2F("hPhi",
1800                          Form("Number of isolated particles vs #phi, %s",parTitle.Data()),
1801                          nptbins,ptmin,ptmax,nphibins,phimin,phimax);
1802     fhPhiIso->SetYTitle("#phi");
1803     fhPhiIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1804     outputContainer->Add(fhPhiIso) ;
1805
1806     fhEtaIso  = new TH2F("hEta",
1807                          Form("Number of isolated particles vs #eta, %s",parTitle.Data()),
1808                          nptbins,ptmin,ptmax,netabins,etamin,etamax);
1809     fhEtaIso->SetYTitle("#eta");
1810     fhEtaIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1811     outputContainer->Add(fhEtaIso) ;
1812
1813     fhEtaPhiIso  = new TH2F("hEtaPhiIso",
1814                             Form("Number of isolated particles #eta vs #phi, %s",parTitle.Data()),
1815                             netabins,etamin,etamax,nphibins,phimin,phimax);
1816     fhEtaPhiIso->SetXTitle("#eta");
1817     fhEtaPhiIso->SetYTitle("#phi");
1818     outputContainer->Add(fhEtaPhiIso) ;
1819
1820     if(IsHighMultiplicityAnalysisOn())
1821     {
1822       fhPtCentralityIso  = new TH2F("hPtCentrality",
1823                                     Form("centrality vs #it{p}_{T} for isolated particles, %s",parTitle.Data()),
1824                                     nptbins,ptmin,ptmax, 100,0,100);
1825       fhPtCentralityIso->SetYTitle("centrality");
1826       fhPtCentralityIso->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1827       outputContainer->Add(fhPtCentralityIso) ;
1828
1829       fhPtEventPlaneIso  = new TH2F("hPtEventPlane",
1830                                     Form("event plane angle vs #it{p}_{T} for isolated particles, %s",parTitle.Data()),
1831                                     nptbins,ptmin,ptmax, 100,0,TMath::Pi());
1832       fhPtEventPlaneIso->SetYTitle("Event plane angle (rad)");
1833       fhPtEventPlaneIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1834       outputContainer->Add(fhPtEventPlaneIso) ;
1835     }
1836
1837     if(fFillNLMHistograms)
1838     {
1839       fhPtNLocMaxIso  = new TH2F("hPtNLocMax",
1840                                  Form("Number of isolated particles vs #it{p}_{T}, %s",parTitle.Data()),
1841                                  nptbins,ptmin,ptmax,10,0,10);
1842       fhPtNLocMaxIso->SetYTitle("#it{NLM}");
1843       fhPtNLocMaxIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1844
1845       fhPtNLocMaxNoIso  = new TH2F("hPtNLocMaxNoIso",
1846                                    Form("Number of not isolated particles vs #it{p}_{T}, %s",parTitle.Data()),
1847                                    nptbins,ptmin,ptmax,10,0,10);
1848       fhPtNLocMaxNoIso->SetYTitle("#it{NLM}");
1849       fhPtNLocMaxNoIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1850       outputContainer->Add(fhPtNLocMaxNoIso) ;
1851     }
1852
1853     fhConePtLead  = new TH2F("hConePtLead",
1854                             Form("Track or Cluster  leading #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
1855                             nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
1856     fhConePtLead->SetYTitle("#it{p}_{T, leading} (GeV/#it{c})");
1857     fhConePtLead->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
1858     outputContainer->Add(fhConePtLead) ;
1859
1860     fhConeSumPt  = new TH2F("hConePtSum",
1861                             Form("Track and Cluster #Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
1862                             nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
1863     fhConeSumPt->SetYTitle("#Sigma #it{p}_{T}");
1864     fhConeSumPt->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
1865     outputContainer->Add(fhConeSumPt) ;
1866
1867     fhConeSumPtTrigEtaPhi  = new TH2F("hConePtSumTrigEtaPhi",
1868                                       Form("Trigger #eta vs #phi, #Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
1869                                       netabins,etamin,etamax,nphibins,phimin,phimax);
1870     fhConeSumPtTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
1871     fhConeSumPtTrigEtaPhi->SetXTitle("#eta_{trigger}");
1872     fhConeSumPtTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
1873     outputContainer->Add(fhConeSumPtTrigEtaPhi) ;
1874
1875     fhPtInCone  = new TH2F("hPtInCone",
1876                            Form("#it{p}_{T} of clusters and tracks in isolation cone for #it{R} =  %2.2f",r),
1877                            nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
1878     fhPtInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
1879     fhPtInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1880     outputContainer->Add(fhPtInCone) ;
1881
1882     if(fFillBackgroundBinHistograms)
1883     {
1884       fhPtLeadConeBin              = new TH1F*[fNBkgBin];
1885       fhSumPtConeBin               = new TH1F*[fNBkgBin];
1886       if(fFillSSHisto)
1887       {
1888         fhPtLeadConeBinLambda0     = new TH2F*[fNBkgBin];
1889         fhSumPtConeBinLambda0      = new TH2F*[fNBkgBin];
1890       }
1891
1892       if(fFillTaggedDecayHistograms)
1893       {
1894         fhPtLeadConeBinDecay       = new TH1F*[fNBkgBin*fNDecayBits];
1895         fhSumPtConeBinDecay        = new TH1F*[fNBkgBin*fNDecayBits];
1896       }
1897
1898       if(IsDataMC())
1899       {
1900         fhPtLeadConeBinMC          = new TH1F*[fNBkgBin*fgkNmcTypes];
1901         fhSumPtConeBinMC           = new TH1F*[fNBkgBin*fgkNmcTypes];
1902
1903         if(fFillSSHisto)
1904         {
1905           fhPtLeadConeBinLambda0MC = new TH2F*[fNBkgBin*fgkNmcTypes];
1906           fhSumPtConeBinLambda0MC  = new TH2F*[fNBkgBin*fgkNmcTypes];
1907         }
1908       }
1909
1910       for(Int_t ibin = 0; ibin < fNBkgBin; ibin++)
1911       {
1912         fhPtLeadConeBin[ibin]  = new TH1F
1913         (Form("hPtLeadCone_Bin%d",ibin),
1914          Form("cone %2.2f<#it{p}_{T}^{leading}<%2.2f GeV/#it{c}, %s",
1915               fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax);
1916         fhPtLeadConeBin[ibin]->SetYTitle("d #it{N} / d #it{p}_{T}");
1917         fhPtLeadConeBin[ibin]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1918         outputContainer->Add(fhPtLeadConeBin[ibin]) ;
1919
1920         fhSumPtConeBin[ibin]  = new TH1F
1921         (Form("hSumPtCone_Bin%d",ibin),
1922          Form("in cone %2.2f <#Sigma #it{p}_{T}< %2.2f GeV/#it{c}, %s",
1923               fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax);
1924         fhSumPtConeBin[ibin]->SetYTitle("d #it{N} / d #it{p}_{T}");
1925         fhSumPtConeBin[ibin]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1926         outputContainer->Add(fhSumPtConeBin[ibin]) ;
1927
1928         if(fFillTaggedDecayHistograms)
1929         {
1930           for(Int_t idecay = 0; idecay < fNDecayBits; idecay++)
1931           {
1932             Int_t bindecay = ibin+idecay*fNBkgBin;
1933
1934             fhPtLeadConeBinDecay[bindecay]  = new TH1F
1935             (Form("hPtLeadCone_Bin%d_DecayBit%d",ibin,fDecayBits[idecay]),
1936              Form("Decay bit %d, cone %2.2f<#it{p}_{T}^{leading}<%2.2f GeV/#it{c}, %s",
1937                   fDecayBits[idecay],fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax);
1938             fhPtLeadConeBinDecay[bindecay]->SetYTitle("d #it{N} / d #it{p}_{T}");
1939             fhPtLeadConeBinDecay[bindecay]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1940             outputContainer->Add(fhPtLeadConeBinDecay[bindecay]) ;
1941
1942             fhSumPtConeBinDecay[bindecay]  = new TH1F
1943             (Form("hSumPtCone_Bin%d_DecayBit%d",ibin,fDecayBits[idecay]),
1944              Form("Decay bit %d, in cone %2.2f <#Sigma #it{p}_{T}< %2.2f GeV/#it{c},  %s",
1945                   fDecayBits[idecay],fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax);
1946             fhSumPtConeBinDecay[bindecay]->SetYTitle("d #it{N} / d #it{p}_{T}");
1947             fhSumPtConeBinDecay[bindecay]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1948             outputContainer->Add(fhSumPtConeBinDecay[bindecay]) ;
1949           }
1950         }
1951
1952         if(IsDataMC())
1953         {
1954           for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
1955           {
1956             Int_t binmc = ibin+imc*fNBkgBin;
1957             fhPtLeadConeBinMC[binmc]  = new TH1F
1958             (Form("hPtLeadCone_Bin%d_MC%s",ibin, mcPartName[imc].Data()),
1959              Form("in cone %2.2f<#it{p}_{T}^{leading}<%2.2f GeV/#it{c}, MC %s, %s",
1960                   fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax);
1961             fhPtLeadConeBinMC[binmc]->SetYTitle("d #it{N} / d #it{p}_{T}");
1962             fhPtLeadConeBinMC[binmc]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1963             outputContainer->Add(fhPtLeadConeBinMC[binmc]) ;
1964
1965             fhSumPtConeBinMC[binmc]  = new TH1F
1966             (Form("hSumPtCone_Bin%d_MC%s",ibin,mcPartName[imc].Data()),
1967              Form("in cone %2.2f <#Sigma #it{p}_{T}< %2.2f GeV/#it{c}, MC %s, %s",
1968                   fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax);
1969             fhSumPtConeBinMC[binmc]->SetYTitle("d #it{N} / d #it{p}_{T}");
1970             fhSumPtConeBinMC[binmc]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1971             outputContainer->Add(fhSumPtConeBinMC[binmc]) ;
1972           } // MC particle loop
1973         }
1974
1975         if(fFillSSHisto)
1976         {
1977           fhPtLeadConeBinLambda0[ibin]  = new TH2F
1978           (Form("hPtLeadConeLambda0_Bin%d",ibin),
1979            Form("#lambda_{0}, in cone %2.2f<#it{p}_{T}^{leading}<%2.2f GeV/#it{c}, %s",
1980                 fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1981           fhPtLeadConeBinLambda0[ibin]->SetYTitle("#lambda_{0}^{2}");
1982           fhPtLeadConeBinLambda0[ibin]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1983           outputContainer->Add(fhPtLeadConeBinLambda0[ibin]) ;
1984
1985           fhSumPtConeBinLambda0[ibin]  = new TH2F
1986           (Form("hSumPtConeLambda0_Bin%d",ibin),
1987            Form("#lambda_{0}, in cone %2.2f <#Sigma #it{p}_{T}< %2.2f GeV/#it{c}, %s",
1988                 fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1989           fhSumPtConeBinLambda0[ibin]->SetYTitle("#lambda_{0}^{2}");
1990           fhSumPtConeBinLambda0[ibin]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1991           outputContainer->Add(fhSumPtConeBinLambda0[ibin]) ;
1992
1993           if(IsDataMC())
1994           {
1995             for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
1996             {
1997               Int_t binmc = ibin+imc*fNBkgBin;
1998               fhPtLeadConeBinLambda0MC[binmc]  = new TH2F
1999               (Form("hPtLeadConeLambda0_Bin%d_MC%s",ibin, mcPartName[imc].Data()),
2000                Form("#lambda_{0}, in cone %2.2f<#it{p}_{T}^{leading}<%2.2f GeV/#it{c}, MC %s, %s",
2001                     fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2002               fhPtLeadConeBinLambda0MC[binmc]->SetYTitle("#lambda_{0}^{2}");
2003               fhPtLeadConeBinLambda0MC[binmc]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2004               outputContainer->Add(fhPtLeadConeBinLambda0MC[binmc]) ;
2005
2006               fhSumPtConeBinLambda0MC[binmc]  = new TH2F
2007               (Form("hSumPtConeLambda0_Bin%d_MC%s",ibin,mcPartName[imc].Data()),
2008                Form("#lambda_{0}, in cone %2.2f <#Sigma #it{p}_{T}< %2.2f GeV/#it{c}, MC %s, %s",
2009                     fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2010               fhSumPtConeBinLambda0MC[binmc]->SetYTitle("#lambda_{0}^{2}");
2011               fhSumPtConeBinLambda0MC[binmc]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2012               outputContainer->Add(fhSumPtConeBinLambda0MC[binmc]) ;
2013             } // MC particle loop
2014           }
2015         } // shower shape on
2016       } // pt in cone bin loop
2017     } // bkg cone pt bin histograms
2018
2019     if(fFillPtTrigBinHistograms)
2020     {
2021       fhPtTrigBinPtLeadCone = new TH1F*[fNPtTrigBin];
2022       fhPtTrigBinSumPtCone  = new TH1F*[fNPtTrigBin];
2023
2024       fhPtTrigBinPtLeadConeDecay = new TH1F*[fNPtTrigBin];
2025       fhPtTrigBinSumPtConeDecay  = new TH1F*[fNPtTrigBin];
2026
2027       if(IsDataMC())
2028       {
2029         fhPtTrigBinPtLeadConeMC = new TH1F*[fNPtTrigBin*fgkNmcTypes];
2030         fhPtTrigBinSumPtConeMC  = new TH1F*[fNPtTrigBin*fgkNmcTypes];
2031       }
2032
2033       if(fFillSSHisto)
2034       {
2035         fhPtTrigBinLambda0vsPtLeadCone = new TH2F*[fNPtTrigBin];
2036         fhPtTrigBinLambda0vsSumPtCone  = new TH2F*[fNPtTrigBin];
2037
2038         if(IsDataMC())
2039         {
2040           fhPtTrigBinLambda0vsPtLeadConeMC = new TH2F*[fNPtTrigBin*fgkNmcTypes];
2041           fhPtTrigBinLambda0vsSumPtConeMC  = new TH2F*[fNPtTrigBin*fgkNmcTypes];
2042         }
2043       }
2044
2045       for(Int_t ibin = 0; ibin < fNPtTrigBin; ibin++)
2046       {
2047         fhPtTrigBinPtLeadCone[ibin]  = new TH1F
2048         (Form("hPtTrigBin_PtLeadCone_Bin%d",ibin),
2049          Form("#it{p}_{T}^{lead. in cone}, %2.2f<#it{p}_{T}^{cand}<%2.2f GeV/#it{c}, %s",
2050               fPtTrigBinLimit[ibin],fPtTrigBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax);
2051         fhPtTrigBinPtLeadCone[ibin]->SetYTitle("d #it{N} / d #it{p}_{T}");
2052         fhPtTrigBinPtLeadCone[ibin]->SetXTitle("#it{p}_{T}^{in cone} (GeV/#it{c})");
2053         outputContainer->Add(fhPtTrigBinPtLeadCone[ibin]) ;
2054
2055         fhPtTrigBinSumPtCone[ibin]  = new TH1F
2056         (Form("hPtTrigBin_SumPtCone_Bin%d",ibin),
2057          Form("#Sigma #it{p}_{T}^{in cone} %2.2f <#it{p}_{T}^{cand}< %2.2f GeV/#it{c}, %s",
2058               fPtTrigBinLimit[ibin],fPtTrigBinLimit[ibin+1], parTitle.Data()),nptsumbins,ptsummin,ptsummax);
2059         fhPtTrigBinSumPtCone[ibin]->SetYTitle("d #it{N} / d #it{p}_{T}");
2060         fhPtTrigBinSumPtCone[ibin]->SetXTitle("#Sigma #it{p}_{T}^{in cone} (GeV/#it{c})");
2061         outputContainer->Add(fhPtTrigBinSumPtCone[ibin]) ;
2062
2063         if(fFillTaggedDecayHistograms)
2064         {
2065           for(Int_t idecay = 0; idecay < fNDecayBits; idecay++)
2066           {
2067             Int_t binDecay = ibin+idecay*fNPtTrigBin;
2068
2069             fhPtTrigBinPtLeadConeDecay[binDecay]  = new TH1F
2070             (Form("hPtTrigBin_PtLeadCone_Bin%d_DecayBit%d",ibin,fDecayBits[idecay]),
2071              Form("Decay bit %d, #it{p}_{T}^{lead. in cone}, %2.2f<#it{p}_{T}^{cand}<%2.2f GeV/#it{c}, %s",
2072                   fDecayBits[idecay],fPtTrigBinLimit[ibin],fPtTrigBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax);
2073             fhPtTrigBinPtLeadConeDecay[binDecay]->SetYTitle("d #it{N} / d #it{p}_{T}");
2074             fhPtTrigBinPtLeadConeDecay[binDecay]->SetXTitle("#it{p}_{T}^{lead in cone} (GeV/#it{c})");
2075             outputContainer->Add(fhPtTrigBinPtLeadConeDecay[binDecay]) ;
2076
2077             fhPtTrigBinSumPtConeDecay[binDecay]  = new TH1F
2078             (Form("hPtTrigBin_SumPtCone_Bin%d_DecayBit%d",ibin,fDecayBits[idecay]),
2079              Form("Decay bit %d, #Sigma #it{p}_{T}^{in cone} %2.2f <#it{p}_{T}^{cand}< %2.2f GeV/#it{c}, %s",
2080                   fDecayBits[idecay],fPtTrigBinLimit[ibin],fPtTrigBinLimit[ibin+1], parTitle.Data()),nptsumbins,ptsummin,ptsummax);
2081             fhPtTrigBinSumPtConeDecay[binDecay]->SetYTitle("d #it{N} / d #it{p}_{T}");
2082             fhPtTrigBinSumPtConeDecay[binDecay]->SetXTitle("#Sigma #it{p}_{T}^{in cone} (GeV/#it{c})");
2083             outputContainer->Add(fhPtTrigBinSumPtConeDecay[binDecay]) ;
2084           }
2085         }
2086
2087         if(IsDataMC())
2088         {
2089           for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
2090           {
2091             Int_t binmc = ibin+imc*fNPtTrigBin;
2092             fhPtTrigBinPtLeadConeMC[binmc]  = new TH1F
2093             (Form("hPtTrigBin_PtLeadCone_Bin%d_MC%s",ibin, mcPartName[imc].Data()),
2094              Form("#it{p}_{T}^{lead. in cone}, %2.2f<#it{p}_{T}^{cand}<%2.2f GeV/#it{c}, MC %s, %s",
2095                   fPtTrigBinLimit[ibin],fPtTrigBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax);
2096             fhPtTrigBinPtLeadConeMC[binmc]->SetYTitle("d #it{N} / d #it{p}_{T}");
2097             fhPtTrigBinPtLeadConeMC[binmc]->SetXTitle("#it{p}_{T}^{lead in cone} (GeV/#it{c})");
2098             outputContainer->Add(fhPtTrigBinPtLeadConeMC[binmc]) ;
2099
2100             fhPtTrigBinSumPtConeMC[binmc]  = new TH1F
2101             (Form("hPtTrigBin_SumPtCone_Bin%d_MC%s",ibin,mcPartName[imc].Data()),
2102              Form("#Sigma #it{p}_{T}^{in cone}, %2.2f <#it{p}_{T}^{cand}< %2.2f GeV/#it{c}, MC %s, %s",
2103                   fPtTrigBinLimit[ibin],fPtTrigBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptsumbins,ptsummin,ptsummax);
2104             fhPtTrigBinSumPtConeMC[binmc]->SetYTitle("d #it{N} / d #it{p}_{T}");
2105             fhPtTrigBinSumPtConeMC[binmc]->SetXTitle("#Sigma #it{p}_{T}^{in cone} (GeV/#it{c})");
2106             outputContainer->Add(fhPtTrigBinSumPtConeMC[binmc]) ;
2107           } // MC particle loop
2108         } // MC
2109
2110         if(fFillSSHisto)
2111         {
2112           fhPtTrigBinLambda0vsPtLeadCone[ibin]  = new TH2F
2113           (Form("hPtTrigBin_PtLeadConeVSLambda0_Bin%d",ibin),
2114            Form("#lambda_{0} vs #it{p}_{T}^{lead. in cone}, %2.2f<#it{p}_{T}^{cand}<%2.2f GeV/#it{c}, %s",
2115                 fPtTrigBinLimit[ibin],fPtTrigBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2116           fhPtTrigBinLambda0vsPtLeadCone[ibin]->SetYTitle("#lambda_{0}^{2}");
2117           fhPtTrigBinLambda0vsPtLeadCone[ibin]->SetXTitle("#it{p}_{T}^{lead in cone} (GeV/#it{c})");
2118           outputContainer->Add(fhPtTrigBinLambda0vsPtLeadCone[ibin]) ;
2119
2120           fhPtTrigBinLambda0vsSumPtCone[ibin]  = new TH2F
2121           (Form("hPtTrigBin_SumPtConeVSLambda0_Bin%d",ibin),
2122            Form("#lambda_{0} vs #Sigma #it{p}_{T}^{in cone} %2.2f <#it{p}_{T}^{cand}< %2.2f GeV/#it{c}, %s",
2123                 fPtTrigBinLimit[ibin],fPtTrigBinLimit[ibin+1], parTitle.Data()),nptsumbins,ptsummin,ptsummax,ssbins,ssmin,ssmax);
2124           fhPtTrigBinLambda0vsSumPtCone[ibin]->SetYTitle("#lambda_{0}^{2}");
2125           fhPtTrigBinLambda0vsSumPtCone[ibin]->SetXTitle("#Sigma #it{p}_{T}^{in cone} (GeV/#it{c})");
2126           outputContainer->Add(fhPtTrigBinLambda0vsSumPtCone[ibin]) ;
2127
2128           if(IsDataMC())
2129           {
2130             for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
2131             {
2132               Int_t binmc = ibin+imc*fNPtTrigBin;
2133               fhPtTrigBinLambda0vsPtLeadConeMC[binmc]  = new TH2F
2134               (Form("hPtTrigBin_PtLeadConeVSLambda0_Bin%d_MC%s",ibin, mcPartName[imc].Data()),
2135                Form("#lambda_{0} vs #it{p}_{T}^{lead. in cone}, %2.2f<#it{p}_{T}^{cand}<%2.2f GeV/#it{c}, MC %s, %s",
2136                     fPtTrigBinLimit[ibin],fPtTrigBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2137               fhPtTrigBinLambda0vsPtLeadConeMC[binmc]->SetYTitle("#lambda_{0}^{2}");
2138               fhPtTrigBinLambda0vsPtLeadConeMC[binmc]->SetXTitle("#it{p}_{T}^{lead in cone} (GeV/#it{c})");
2139               outputContainer->Add(fhPtTrigBinLambda0vsPtLeadConeMC[binmc]) ;
2140
2141               fhPtTrigBinLambda0vsSumPtConeMC[binmc]  = new TH2F
2142               (Form("hPtTrigBin_SumPtConeVSLambda0_Bin%d_MC%s",ibin,mcPartName[imc].Data()),
2143                Form("#lambda_{0} vs #Sigma #it{p}_{T}^{in cone}, %2.2f <#it{p}_{T}^{cand}< %2.2f GeV/#it{c}, MC %s, %s",
2144                     fPtTrigBinLimit[ibin],fPtTrigBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptsumbins,ptsummin,ptsummax,ssbins,ssmin,ssmax);
2145               fhPtTrigBinLambda0vsSumPtConeMC[binmc]->SetYTitle("#lambda_{0}^{2}");
2146               fhPtTrigBinLambda0vsSumPtConeMC[binmc]->SetXTitle("#Sigma #it{p}_{T}^{in cone} (GeV/#it{c})");
2147               outputContainer->Add(fhPtTrigBinLambda0vsSumPtConeMC[binmc]) ;
2148             } // MC particle loop
2149           } // MC
2150         } // SS histo
2151       } // pt trig bin loop
2152     } // pt trig bin histograms
2153
2154     if(IsHighMultiplicityAnalysisOn())
2155     {
2156       fhPtInConeCent  = new TH2F("hPtInConeCent",
2157                                  Form("#it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
2158                                  100,0,100,nptinconebins,ptinconemin,ptinconemax);
2159       fhPtInConeCent->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
2160       fhPtInConeCent->SetXTitle("centrality");
2161       outputContainer->Add(fhPtInConeCent) ;
2162     }
2163
2164     // Cluster only histograms
2165     if(GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::kOnlyCharged)
2166     {
2167       fhConeSumPtCluster  = new TH2F("hConePtSumCluster",
2168                                      Form("Cluster #Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
2169                                      nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2170       fhConeSumPtCluster->SetYTitle("#Sigma #it{p}_{T}");
2171       fhConeSumPtCluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2172       outputContainer->Add(fhConeSumPtCluster) ;
2173
2174       fhConePtLeadCluster  = new TH2F("hConeLeadPtCluster",
2175                                     Form("Cluster leading in isolation cone for #it{R} =  %2.2f",r),
2176                                     nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2177       fhConePtLeadCluster->SetYTitle("#it{p}_{T, leading} (GeV/#it{c})");
2178       fhConePtLeadCluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2179       outputContainer->Add(fhConePtLeadCluster) ;
2180
2181
2182       if(fFillCellHistograms)
2183       {
2184         fhConeSumPtCell  = new TH2F("hConePtSumCell",
2185                                     Form("Cell #Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
2186                                     nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2187         fhConeSumPtCell->SetYTitle("#Sigma #it{p}_{T}");
2188         fhConeSumPtCell->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2189         outputContainer->Add(fhConeSumPtCell) ;
2190       }
2191
2192       if(fFillUEBandSubtractHistograms)
2193       {
2194         fhConeSumPtEtaBandUECluster  = new TH2F("hConePtSumEtaBandUECluster",
2195                                                 "#Sigma cluster #it{p}_{T} in UE Eta Band",
2196                                                 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2197         fhConeSumPtEtaBandUECluster->SetYTitle("#Sigma #it{p}_{T}");
2198         fhConeSumPtEtaBandUECluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2199         outputContainer->Add(fhConeSumPtEtaBandUECluster) ;
2200
2201         fhConeSumPtPhiBandUECluster  = new TH2F("hConePtSumPhiBandUECluster",
2202                                                 "#Sigma cluster #it{p}_{T} UE Phi Band",
2203                                                 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2204         fhConeSumPtPhiBandUECluster->SetYTitle("#Sigma #it{p}_{T}");
2205         fhConeSumPtPhiBandUECluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2206         outputContainer->Add(fhConeSumPtPhiBandUECluster) ;
2207
2208         fhConeSumPtEtaBandUEClusterTrigEtaPhi  = new TH2F("hConePtSumEtaBandUEClusterTrigEtaPhi",
2209                                                           "Trigger #eta vs #phi, #Sigma cluster #it{p}_{T} in UE Eta Band",
2210                                                           netabins,etamin,etamax,nphibins,phimin,phimax);
2211         fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2212         fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
2213         fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2214         outputContainer->Add(fhConeSumPtEtaBandUEClusterTrigEtaPhi) ;
2215
2216         fhConeSumPtPhiBandUEClusterTrigEtaPhi  = new TH2F("hConePtSumPhiBandUEClusterTrigEtaPhi",
2217                                                           "Trigger #eta vs #phi, #Sigma cluster #it{p}_{T} UE Phi Band",
2218                                                           netabins,etamin,etamax,nphibins,phimin,phimax);
2219         fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2220         fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
2221         fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2222         outputContainer->Add(fhConeSumPtPhiBandUEClusterTrigEtaPhi) ;
2223         if(fFillCellHistograms)
2224         {
2225
2226           fhConeSumPtEtaBandUECell  = new TH2F("hConePtSumEtaBandUECell",
2227                                                "#Sigma cell #it{p}_{T} in UE Eta Band",
2228                                                nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2229           fhConeSumPtEtaBandUECell->SetYTitle("#Sigma #it{p}_{T}");
2230           fhConeSumPtEtaBandUECell->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2231           outputContainer->Add(fhConeSumPtEtaBandUECell) ;
2232
2233           fhConeSumPtPhiBandUECell  = new TH2F("hConePtSumPhiBandUECell",
2234                                                "#Sigma cell #it{p}_{T} UE Phi Band",
2235                                                nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2236           fhConeSumPtPhiBandUECell->SetYTitle("#Sigma #it{p}_{T}");
2237           fhConeSumPtPhiBandUECell->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2238           outputContainer->Add(fhConeSumPtPhiBandUECell) ;
2239
2240           fhConeSumPtEtaBandUECellTrigEtaPhi  = new TH2F("hConePtSumEtaBandUECellTrigEtaPhi",
2241                                                          "Trigger #eta vs #phi, #Sigma cell #it{p}_{T} in UE Eta Band",
2242                                                          netabins,etamin,etamax,nphibins,phimin,phimax);
2243           fhConeSumPtEtaBandUECellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2244           fhConeSumPtEtaBandUECellTrigEtaPhi->SetXTitle("#eta_{trigger}");
2245           fhConeSumPtEtaBandUECellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2246           outputContainer->Add(fhConeSumPtEtaBandUECellTrigEtaPhi) ;
2247
2248           fhConeSumPtPhiBandUECellTrigEtaPhi  = new TH2F("hConePtSumPhiBandUECellTrigEtaPhi",
2249                                                          "Trigger #eta vs #phi, #Sigma cell #it{p}_{T} UE Phi Band",
2250                                                          netabins,etamin,etamax,nphibins,phimin,phimax);
2251           fhConeSumPtPhiBandUECellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2252           fhConeSumPtPhiBandUECellTrigEtaPhi->SetXTitle("#eta_{trigger}");
2253           fhConeSumPtPhiBandUECellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2254           outputContainer->Add(fhConeSumPtPhiBandUECellTrigEtaPhi) ;
2255         }
2256
2257         fhEtaBandCluster  = new TH2F("hEtaBandCluster",
2258                                      Form("#eta vs #phi of clusters in #eta band isolation cone for #it{R} =  %2.2f",r),
2259                                      netabins,-1,1,nphibins,0,TMath::TwoPi());
2260         fhEtaBandCluster->SetXTitle("#eta");
2261         fhEtaBandCluster->SetYTitle("#phi");
2262         outputContainer->Add(fhEtaBandCluster) ;
2263
2264         fhPhiBandCluster  = new TH2F("hPhiBandCluster",
2265                                      Form("#eta vs #phi of clusters in #phi band isolation cone for #it{R} =  %2.2f",r),
2266                                      netabins,-1,1,nphibins,0,TMath::TwoPi());
2267         fhPhiBandCluster->SetXTitle("#eta");
2268         fhPhiBandCluster->SetYTitle("#phi");
2269         outputContainer->Add(fhPhiBandCluster) ;
2270
2271         fhEtaPhiInConeCluster= new TH2F("hEtaPhiInConeCluster",
2272                                         Form("#eta vs #phi of clusters in cone for #it{R} =  %2.2f",r),
2273                                         netabins,-1,1,nphibins,0,TMath::TwoPi());
2274         fhEtaPhiInConeCluster->SetXTitle("#eta");
2275         fhEtaPhiInConeCluster->SetYTitle("#phi");
2276         outputContainer->Add(fhEtaPhiInConeCluster) ;
2277
2278         fhEtaPhiCluster= new TH2F("hEtaPhiCluster",
2279                                   Form("#eta vs #phi of all clusters"),
2280                                   netabins,-1,1,nphibins,0,TMath::TwoPi());
2281         fhEtaPhiCluster->SetXTitle("#eta");
2282         fhEtaPhiCluster->SetYTitle("#phi");
2283         outputContainer->Add(fhEtaPhiCluster) ;
2284
2285       }
2286
2287       fhPtClusterInCone  = new TH2F("hPtClusterInCone",
2288                                     Form("#it{p}_{T} of clusters in isolation cone for #it{R} =  %2.2f",r),
2289                                     nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
2290       fhPtClusterInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
2291       fhPtClusterInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2292       outputContainer->Add(fhPtClusterInCone) ;
2293
2294       if(fFillCellHistograms)
2295       {
2296         fhPtCellInCone  = new TH2F("hPtCellInCone",
2297                                    Form("#it{p}_{T} of cells in isolation cone for #it{R} =  %2.2f",r),
2298                                    nptbins,ptmin,ptmax,1000,0,50);
2299         fhPtCellInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
2300         fhPtCellInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2301         outputContainer->Add(fhPtCellInCone) ;
2302
2303         fhEtaBandCell  = new TH2F("hEtaBandCell",
2304                                   Form("#col vs #row of cells in #eta band isolation cone for #it{R} =  %2.2f",r),
2305                                   96,0,95,128,0,127);
2306         fhEtaBandCell->SetXTitle("#col");
2307         fhEtaBandCell->SetYTitle("#row");
2308         outputContainer->Add(fhEtaBandCell) ;
2309
2310         fhPhiBandCell  = new TH2F("hPhiBandCell",
2311                                   Form("#col vs #row of cells in #phi band isolation cone for #it{R} =  %2.2f",r),
2312                                   96,0,95,128,0,127);
2313         fhPhiBandCell->SetXTitle("#col");
2314         fhPhiBandCell->SetYTitle("#row");
2315         outputContainer->Add(fhPhiBandCell) ;
2316       }
2317
2318       if(fFillUEBandSubtractHistograms)
2319       {
2320         fhConeSumPtEtaUESubCluster  = new TH2F("hConeSumPtEtaUESubCluster",
2321                                                Form("Clusters #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} =  %2.2f",r),
2322                                                nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2323         fhConeSumPtEtaUESubCluster->SetYTitle("#Sigma #it{p}_{T}");
2324         fhConeSumPtEtaUESubCluster->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2325         outputContainer->Add(fhConeSumPtEtaUESubCluster) ;
2326
2327         fhConeSumPtPhiUESubCluster  = new TH2F("hConeSumPtPhiUESubCluster",
2328                                                Form("Clusters #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} =  %2.2f",r),
2329                                                nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2330         fhConeSumPtPhiUESubCluster->SetYTitle("#Sigma #it{p}_{T}");
2331         fhConeSumPtPhiUESubCluster->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2332         outputContainer->Add(fhConeSumPtPhiUESubCluster) ;
2333
2334         fhConeSumPtEtaUESubClusterTrigEtaPhi  = new TH2F("hConeSumPtEtaUESubClusterTrigEtaPhi",
2335                                                          Form("Trigger #eta vs #phi, Clusters #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} =  %2.2f",r),
2336                                                          netabins,etamin,etamax,nphibins,phimin,phimax);
2337         fhConeSumPtEtaUESubClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2338         fhConeSumPtEtaUESubClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
2339         fhConeSumPtEtaUESubClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2340         outputContainer->Add(fhConeSumPtEtaUESubClusterTrigEtaPhi) ;
2341
2342         fhConeSumPtPhiUESubClusterTrigEtaPhi  = new TH2F("hConeSumPtPhiUESubClusterTrigEtaPhi",
2343                                                          Form("Trigger #eta vs #phi, Clusters #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} =  %2.2f",r),
2344                                                          netabins,etamin,etamax,nphibins,phimin,phimax);
2345         fhConeSumPtPhiUESubClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2346         fhConeSumPtPhiUESubClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
2347         fhConeSumPtPhiUESubClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2348         outputContainer->Add(fhConeSumPtPhiUESubClusterTrigEtaPhi) ;
2349
2350         if(fFillCellHistograms)
2351         {
2352           fhConeSumPtEtaUESubCell  = new TH2F("hConeSumPtEtaUESubCell",
2353                                               Form("Cells #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} =  %2.2f",r),
2354                                               nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2355           fhConeSumPtEtaUESubCell->SetYTitle("#Sigma #it{p}_{T}");
2356           fhConeSumPtEtaUESubCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2357           outputContainer->Add(fhConeSumPtEtaUESubCell) ;
2358
2359           fhConeSumPtPhiUESubCell  = new TH2F("hConeSumPtPhiUESubCell",
2360                                               Form("Cells #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} =  %2.2f",r),
2361                                               nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2362           fhConeSumPtPhiUESubCell->SetYTitle("#Sigma #it{p}_{T}");
2363           fhConeSumPtPhiUESubCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2364           outputContainer->Add(fhConeSumPtPhiUESubCell) ;
2365
2366           fhConeSumPtEtaUESubCellTrigEtaPhi  = new TH2F("hConeSumPtEtaUESubCellTrigEtaPhi",
2367                                                         Form("Trigger #eta vs #phi, Cells #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} =  %2.2f",r),
2368                                                         netabins,etamin,etamax,nphibins,phimin,phimax);
2369           fhConeSumPtEtaUESubCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2370           fhConeSumPtEtaUESubCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
2371           fhConeSumPtEtaUESubCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2372           outputContainer->Add(fhConeSumPtEtaUESubCellTrigEtaPhi) ;
2373
2374           fhConeSumPtPhiUESubCellTrigEtaPhi  = new TH2F("hConeSumPtPhiUESubCellTrigEtaPhi",
2375                                                         Form("Trigger #eta vs #phi, Cells #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} =  %2.2f",r),
2376                                                         netabins,etamin,etamax,nphibins,phimin,phimax);
2377           fhConeSumPtPhiUESubCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2378           fhConeSumPtPhiUESubCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
2379           fhConeSumPtPhiUESubCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2380           outputContainer->Add(fhConeSumPtPhiUESubCellTrigEtaPhi) ;
2381         }
2382
2383         fhFractionClusterOutConeEta  = new TH2F("hFractionClusterOutConeEta",
2384                                                 Form("Fraction of the isolation cone #it{R} =  %2.2f, out of clusters #eta acceptance",r),
2385                                                 nptbins,ptmin,ptmax,100,0,1);
2386         fhFractionClusterOutConeEta->SetYTitle("#it{fraction}");
2387         fhFractionClusterOutConeEta->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
2388         outputContainer->Add(fhFractionClusterOutConeEta) ;
2389
2390         fhFractionClusterOutConeEtaTrigEtaPhi  = new TH2F("hFractionClusterOutConeEtaTrigEtaPhi",
2391                                                           Form("Fraction of the isolation cone #it{R} =  %2.2f, out of clusters #eta acceptance, in trigger #eta-#phi ",r),
2392                                                           netabins,etamin,etamax,nphibins,phimin,phimax);
2393         fhFractionClusterOutConeEtaTrigEtaPhi->SetZTitle("#it{fraction}");
2394         fhFractionClusterOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
2395         fhFractionClusterOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2396         outputContainer->Add(fhFractionClusterOutConeEtaTrigEtaPhi) ;
2397
2398         fhFractionClusterOutConePhi  = new TH2F("hFractionClusterOutConePhi",
2399                                                 Form("Fraction of the isolation cone #it{R} =  %2.2f, out of clusters #phi acceptance",r),
2400                                                 nptbins,ptmin,ptmax,100,0,1);
2401         fhFractionClusterOutConePhi->SetYTitle("#it{fraction}");
2402         fhFractionClusterOutConePhi->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
2403         outputContainer->Add(fhFractionClusterOutConePhi) ;
2404
2405         fhFractionClusterOutConePhiTrigEtaPhi  = new TH2F("hFractionClusterOutConePhiTrigEtaPhi",
2406                                                           Form("Fraction of the isolation cone #it{R} =  %2.2f, out of clusters #phi acceptance, in trigger #eta-#phi ",r),
2407                                                           netabins,etamin,etamax,nphibins,phimin,phimax);
2408         fhFractionClusterOutConePhiTrigEtaPhi->SetZTitle("#it{fraction}");
2409         fhFractionClusterOutConePhiTrigEtaPhi->SetXTitle("#eta_{trigger}");
2410         fhFractionClusterOutConePhiTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2411         outputContainer->Add(fhFractionClusterOutConePhiTrigEtaPhi) ;
2412
2413         fhConeSumPtSubvsConeSumPtTotPhiCluster = new TH2F("hConeSumPtSubvsConeSumPtTotPhiCluster",
2414                                                           Form("#Sigma #it{p}_{T} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2415                                                           nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2416         fhConeSumPtSubvsConeSumPtTotPhiCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2417         fhConeSumPtSubvsConeSumPtTotPhiCluster->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2418         outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiCluster);
2419
2420         fhConeSumPtSubNormvsConeSumPtTotPhiCluster = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiCluster",
2421                                                               Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2422                                                               nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2423         fhConeSumPtSubNormvsConeSumPtTotPhiCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2424         fhConeSumPtSubNormvsConeSumPtTotPhiCluster->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2425         outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiCluster);
2426
2427         fhConeSumPtSubvsConeSumPtTotEtaCluster = new TH2F("hConeSumPtSubvsConeSumPtTotEtaCluster",
2428                                                           Form("#Sigma #it{p}_{T} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2429                                                           nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2430         fhConeSumPtSubvsConeSumPtTotEtaCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2431         fhConeSumPtSubvsConeSumPtTotEtaCluster->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2432         outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaCluster);
2433
2434         fhConeSumPtSubNormvsConeSumPtTotEtaCluster = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaCluster",
2435                                                               Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2436                                                               nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2437         fhConeSumPtSubNormvsConeSumPtTotEtaCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2438         fhConeSumPtSubNormvsConeSumPtTotEtaCluster->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2439         outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaCluster);
2440
2441         fhConeSumPtVSUEClusterEtaBand  = new TH2F("hConeSumPtVSUEClusterEtaBand",
2442                                                   Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in eta band for cluster (before normalization), R=%2.2f",r),
2443                                                   nptsumbins,ptsummin,ptsummax,2*nptsumbins,ptsummin,2*ptsummax);
2444         fhConeSumPtVSUEClusterEtaBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
2445         fhConeSumPtVSUEClusterEtaBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
2446         outputContainer->Add(fhConeSumPtVSUEClusterEtaBand);
2447
2448         fhConeSumPtVSUEClusterPhiBand  = new TH2F("hConeSumPtVSUEClusterPhiBand",
2449                                                   Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in phi band for cluster (before normalization), R=%2.2f",r),
2450                                                   nptsumbins,ptsummin,ptsummax,8*nptsumbins,ptsummin,8*ptsummax);
2451         fhConeSumPtVSUEClusterPhiBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
2452         fhConeSumPtVSUEClusterPhiBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
2453         outputContainer->Add(fhConeSumPtVSUEClusterPhiBand);
2454
2455         if(fFillCellHistograms)
2456         {
2457           fhFractionCellOutConeEta  = new TH2F("hFractionCellOutConeEta",
2458                                                Form("Fraction of the isolation cone #it{R} =  %2.2f, out of cells #eta acceptance",r),
2459                                                nptbins,ptmin,ptmax,100,0,1);
2460           fhFractionCellOutConeEta->SetYTitle("#it{fraction}");
2461           fhFractionCellOutConeEta->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
2462           outputContainer->Add(fhFractionCellOutConeEta) ;
2463
2464           fhFractionCellOutConeEtaTrigEtaPhi  = new TH2F("hFractionCellOutConeEtaTrigEtaPhi",
2465                                                          Form("Fraction of the isolation cone #it{R} =  %2.2f, out of cells #eta acceptance, in trigger #eta-#phi ",r),
2466                                                          netabins,etamin,etamax,nphibins,phimin,phimax);
2467           fhFractionCellOutConeEtaTrigEtaPhi->SetZTitle("#it{fraction}");
2468           fhFractionCellOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
2469           fhFractionCellOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2470           outputContainer->Add(fhFractionCellOutConeEtaTrigEtaPhi) ;
2471
2472           fhFractionCellOutConePhi  = new TH2F("hFractionCellOutConePhi",
2473                                                Form("Fraction of the isolation cone #it{R} =  %2.2f, out of cells #phi acceptance",r),
2474                                                nptbins,ptmin,ptmax,100,0,1);
2475           fhFractionCellOutConePhi->SetYTitle("#it{fraction}");
2476           fhFractionCellOutConePhi->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
2477           outputContainer->Add(fhFractionCellOutConePhi) ;
2478
2479           fhFractionCellOutConePhiTrigEtaPhi  = new TH2F("hFractionCellOutConePhiTrigEtaPhi",
2480                                                          Form("Fraction of the isolation cone #it{R} =  %2.2f, out of cells #phi acceptance, in trigger #eta-#phi ",r),
2481                                                          netabins,etamin,etamax,nphibins,phimin,phimax);
2482           fhFractionCellOutConePhiTrigEtaPhi->SetZTitle("#it{fraction}");
2483           fhFractionCellOutConePhiTrigEtaPhi->SetXTitle("#eta_{trigger}");
2484           fhFractionCellOutConePhiTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2485           outputContainer->Add(fhFractionCellOutConePhiTrigEtaPhi) ;
2486
2487
2488           fhConeSumPtSubvsConeSumPtTotPhiCell = new TH2F("hConeSumPtSubvsConeSumPtTotPhiCell",
2489                                                          Form("#Sigma #it{p}_{T} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2490                                                          nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2491           fhConeSumPtSubvsConeSumPtTotPhiCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2492           fhConeSumPtSubvsConeSumPtTotPhiCell->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2493           outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiCell);
2494
2495           fhConeSumPtSubNormvsConeSumPtTotPhiCell = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiCell",
2496                                                              Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2497                                                              nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2498           fhConeSumPtSubNormvsConeSumPtTotPhiCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2499           fhConeSumPtSubNormvsConeSumPtTotPhiCell->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2500           outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiCell);
2501
2502           fhConeSumPtSubvsConeSumPtTotEtaCell = new TH2F("hConeSumPtSubvsConeSumPtTotEtaCell",
2503                                                          Form("#Sigma #it{p}_{T} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2504                                                          nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2505           fhConeSumPtSubvsConeSumPtTotEtaCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2506           fhConeSumPtSubvsConeSumPtTotEtaCell->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2507           outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaCell);
2508
2509           fhConeSumPtSubNormvsConeSumPtTotEtaCell = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaCell",
2510                                                              Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2511                                                              nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2512           fhConeSumPtSubNormvsConeSumPtTotEtaCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2513           fhConeSumPtSubNormvsConeSumPtTotEtaCell->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2514           outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaCell);
2515         }
2516       }
2517     }
2518
2519     // Track only histograms
2520     if(GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::kOnlyNeutral)
2521     {
2522       fhConeSumPtTrack  = new TH2F("hConePtSumTrack",
2523                                    Form("Track #Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
2524                                    nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2525       fhConeSumPtTrack->SetYTitle("#Sigma #it{p}_{T}");
2526       fhConeSumPtTrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2527       outputContainer->Add(fhConeSumPtTrack) ;
2528
2529       fhConePtLeadTrack  = new TH2F("hConeLeadPtTrack",
2530                                    Form("Track leading in isolation cone for #it{R} =  %2.2f",r),
2531                                    nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2532       fhConePtLeadTrack->SetYTitle("#it{p}_{T, leading} (GeV/#it{c})");
2533       fhConePtLeadTrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2534       outputContainer->Add(fhConePtLeadTrack) ;
2535
2536       fhPtTrackInCone  = new TH2F("hPtTrackInCone",
2537                                   Form("#it{p}_{T} of tracks in isolation cone for #it{R} =  %2.2f",r),
2538                                   nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
2539       fhPtTrackInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
2540       fhPtTrackInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2541       outputContainer->Add(fhPtTrackInCone) ;
2542
2543
2544       if(fFillUEBandSubtractHistograms)
2545       {
2546         fhConeSumPtEtaBandUETrack  = new TH2F("hConePtSumEtaBandUETrack",
2547                                               "#Sigma track #it{p}_{T} in UE Eta Band",
2548                                               nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2549         fhConeSumPtEtaBandUETrack->SetYTitle("#Sigma #it{p}_{T}");
2550         fhConeSumPtEtaBandUETrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2551         outputContainer->Add(fhConeSumPtEtaBandUETrack) ;
2552
2553         fhConeSumPtPhiBandUETrack  = new TH2F("hConePtSumPhiBandUETrack",
2554                                               "#Sigma track #it{p}_{T} in UE Phi Band",
2555                                               nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax*8);
2556         fhConeSumPtPhiBandUETrack->SetYTitle("#Sigma #it{p}_{T}");
2557         fhConeSumPtPhiBandUETrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2558         outputContainer->Add(fhConeSumPtPhiBandUETrack) ;
2559
2560
2561         fhConeSumPtEtaBandUETrackTrigEtaPhi  = new TH2F("hConePtSumEtaBandUETrackTrigEtaPhi",
2562                                                         "Trigger #eta vs #phi, #Sigma track #it{p}_{T} in UE Eta Band",
2563                                                         netabins,etamin,etamax,nphibins,phimin,phimax);
2564         fhConeSumPtEtaBandUETrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2565         fhConeSumPtEtaBandUETrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
2566         fhConeSumPtEtaBandUETrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2567         outputContainer->Add(fhConeSumPtEtaBandUETrackTrigEtaPhi) ;
2568
2569         fhConeSumPtPhiBandUETrackTrigEtaPhi  = new TH2F("hConePtSumPhiBandUETrackTrigEtaPhi",
2570                                                         "Trigger #eta vs #phi, #Sigma track #it{p}_{T} in UE Phi Band",
2571                                                         netabins,etamin,etamax,nphibins,phimin,phimax);
2572         fhConeSumPtPhiBandUETrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2573         fhConeSumPtPhiBandUETrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
2574         fhConeSumPtPhiBandUETrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2575         outputContainer->Add(fhConeSumPtPhiBandUETrackTrigEtaPhi) ;
2576
2577         fhEtaBandTrack  = new TH2F("hEtaBandTrack",
2578                                    Form("#eta vs #phi of tracks in #eta band isolation cone for #it{R} =  %2.2f",r),
2579                                    netabins,-1,1,nphibins,0,TMath::TwoPi());
2580         fhEtaBandTrack->SetXTitle("#eta");
2581         fhEtaBandTrack->SetYTitle("#phi");
2582         outputContainer->Add(fhEtaBandTrack) ;
2583
2584         fhPhiBandTrack  = new TH2F("hPhiBandTrack",
2585                                    Form("#eta vs #phi of tracks in #phi band isolation cone for #it{R} =  %2.2f",r),
2586                                    netabins,-1,1,nphibins,0,TMath::TwoPi());
2587         fhPhiBandTrack->SetXTitle("#eta");
2588         fhPhiBandTrack->SetYTitle("#phi");
2589         outputContainer->Add(fhPhiBandTrack) ;
2590
2591         fhConeSumPtEtaUESubTrack  = new TH2F("hConeSumPtEtaUESubTrack",
2592                                              Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} =  %2.2f",r),
2593                                              nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2594         fhConeSumPtEtaUESubTrack->SetYTitle("#Sigma #it{p}_{T}");
2595         fhConeSumPtEtaUESubTrack->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2596         outputContainer->Add(fhConeSumPtEtaUESubTrack) ;
2597
2598         fhConeSumPtPhiUESubTrack  = new TH2F("hConeSumPtPhiUESubTrack",
2599                                              Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} =  %2.2f",r),
2600                                              nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2601         fhConeSumPtPhiUESubTrack->SetYTitle("#Sigma #it{p}_{T}");
2602         fhConeSumPtPhiUESubTrack->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2603         outputContainer->Add(fhConeSumPtPhiUESubTrack) ;
2604
2605         fhConeSumPtEtaUESubTrackTrigEtaPhi  = new TH2F("hConeSumPtEtaUESubTrackTrigEtaPhi",
2606                                                        Form("Trigger #eta vs #phi, Tracks #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} =  %2.2f",r),
2607                                                        netabins,etamin,etamax,nphibins,phimin,phimax);
2608         fhConeSumPtEtaUESubTrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2609         fhConeSumPtEtaUESubTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
2610         fhConeSumPtEtaUESubTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2611         outputContainer->Add(fhConeSumPtEtaUESubTrackTrigEtaPhi) ;
2612
2613         fhConeSumPtPhiUESubTrackTrigEtaPhi  = new TH2F("hConeSumPtPhiUESubTrackTrigEtaPhi",
2614                                                        Form("Trigger #eta vs #phi, Tracks #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} =  %2.2f",r),
2615                                                        netabins,etamin,etamax,nphibins,phimin,phimax);
2616         fhConeSumPtPhiUESubTrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2617         fhConeSumPtPhiUESubTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
2618         fhConeSumPtPhiUESubTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2619         outputContainer->Add(fhConeSumPtPhiUESubTrackTrigEtaPhi) ;
2620
2621         fhFractionTrackOutConeEta  = new TH2F("hFractionTrackOutConeEta",
2622                                               Form("Fraction of the isolation cone #it{R} =  %2.2f, out of tracks #eta acceptance",r),
2623                                               nptbins,ptmin,ptmax,100,0,1);
2624         fhFractionTrackOutConeEta->SetYTitle("#it{fraction}");
2625         fhFractionTrackOutConeEta->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
2626         outputContainer->Add(fhFractionTrackOutConeEta) ;
2627
2628         fhFractionTrackOutConeEtaTrigEtaPhi  = new TH2F("hFractionTrackOutConeEtaTrigEtaPhi",
2629                                                         Form("Fraction of the isolation cone #it{R} =  %2.2f, out of tracks #eta acceptance, in trigger #eta-#phi ",r),
2630                                                         netabins,etamin,etamax,nphibins,phimin,phimax);
2631         fhFractionTrackOutConeEtaTrigEtaPhi->SetZTitle("#it{fraction}");
2632         fhFractionTrackOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
2633         fhFractionTrackOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2634         outputContainer->Add(fhFractionTrackOutConeEtaTrigEtaPhi) ;
2635
2636         fhConeSumPtSubvsConeSumPtTotPhiTrack = new TH2F("hConeSumPtSubvsConeSumPtTotPhiTrack",
2637                                                         Form("#Sigma #it{p}_{T} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2638                                                         nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2639         fhConeSumPtSubvsConeSumPtTotPhiTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2640         fhConeSumPtSubvsConeSumPtTotPhiTrack->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2641         outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiTrack);
2642
2643         fhConeSumPtSubNormvsConeSumPtTotPhiTrack = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiTrack",
2644                                                             Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2645                                                             nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2646         fhConeSumPtSubNormvsConeSumPtTotPhiTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2647         fhConeSumPtSubNormvsConeSumPtTotPhiTrack->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2648         outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiTrack);
2649
2650         fhConeSumPtSubvsConeSumPtTotEtaTrack = new TH2F("hConeSumPtSubvsConeSumPtTotEtaTrack",
2651                                                         Form("#Sigma #it{p}_{T} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2652                                                         nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2653         fhConeSumPtSubvsConeSumPtTotEtaTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2654         fhConeSumPtSubvsConeSumPtTotEtaTrack->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2655         outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaTrack);
2656
2657         fhConeSumPtSubNormvsConeSumPtTotEtaTrack = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaTrack",
2658                                                             Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
2659                                                             nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2660         fhConeSumPtSubNormvsConeSumPtTotEtaTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2661         fhConeSumPtSubNormvsConeSumPtTotEtaTrack->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2662         outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaTrack);
2663
2664
2665         // UE in perpendicular cone
2666         fhPerpConeSumPt  = new TH2F("hPerpConePtSum",
2667                                     Form("#Sigma #it{p}_{T} in isolation cone at #pm 45 degree phi from trigger particle, #it{R} =  %2.2f",r),
2668                                     nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2669         fhPerpConeSumPt->SetYTitle("#Sigma #it{p}_{T}");
2670         fhPerpConeSumPt->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2671         outputContainer->Add(fhPerpConeSumPt) ;
2672
2673         fhPtInPerpCone  = new TH2F("hPtInPerpCone",
2674                                    Form("#it{p}_{T} in isolation cone at #pm 45 degree phi from trigger particle, #it{R} =  %2.2f",r),
2675                                    nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
2676         fhPtInPerpCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
2677         fhPtInPerpCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2678         outputContainer->Add(fhPtInPerpCone) ;
2679
2680         fhEtaPhiTrack= new TH2F("hEtaPhiTrack",
2681                                 Form("#eta vs #phi of all Tracks"),
2682                                 netabins,-1,1,nphibins,0,TMath::TwoPi());
2683         fhEtaPhiTrack->SetXTitle("#eta");
2684         fhEtaPhiTrack->SetYTitle("#phi");
2685         outputContainer->Add(fhEtaPhiTrack) ;
2686
2687         fhEtaPhiInConeTrack= new TH2F("hEtaPhiInConeTrack",
2688                                       Form("#eta vs #phi of Tracks in cone for #it{R} =  %2.2f",r),
2689                                       netabins,-1,1,nphibins,0,TMath::TwoPi());
2690         fhEtaPhiInConeTrack->SetXTitle("#eta");
2691         fhEtaPhiInConeTrack->SetYTitle("#phi");
2692         outputContainer->Add(fhEtaPhiInConeTrack) ;
2693
2694         fhConeSumPtVSUETracksEtaBand  = new TH2F("hConeSumPtVSUETracksEtaBand",
2695                                                  Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in eta band for tracks (before normalization), R=%2.2f",r),
2696                                                  nptsumbins,ptsummin,ptsummax,2*nptsumbins,ptsummin,2*ptsummax);
2697         fhConeSumPtVSUETracksEtaBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
2698         fhConeSumPtVSUETracksEtaBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
2699         outputContainer->Add(fhConeSumPtVSUETracksEtaBand);
2700
2701         fhConeSumPtVSUETracksPhiBand  = new TH2F("hConeSumPtVSUETracksPhiBand",
2702                                                  Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in phi band for tracks (before normalization), R=%2.2f",r),
2703                                                  nptsumbins,ptsummin,ptsummax,8*nptsumbins,ptsummin,8*ptsummax);
2704         fhConeSumPtVSUETracksPhiBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
2705         fhConeSumPtVSUETracksPhiBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
2706         outputContainer->Add(fhConeSumPtVSUETracksPhiBand);
2707       }
2708     }
2709
2710     if(GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged )
2711     {
2712       fhConeSumPtClustervsTrack   = new TH2F("hConePtSumClustervsTrack",
2713                                              Form("Track vs Cluster #Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
2714                                              nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2715       fhConeSumPtClustervsTrack->SetXTitle("#Sigma #it{p}_{T}^{cluster} (GeV/#it{c})");
2716       fhConeSumPtClustervsTrack->SetYTitle("#Sigma #it{p}_{T}^{track} (GeV/#it{c})");
2717       outputContainer->Add(fhConeSumPtClustervsTrack) ;
2718
2719       fhConeSumPtClusterTrackFrac   = new TH2F("hConePtSumClusterTrackFraction",
2720                                              Form("#Sigma #it{p}_{T}^{cluster}/#Sigma #it{p}_{T}^{track} in isolation cone for #it{R} =  %2.2f",r),
2721                                              nptbins,ptmin,ptmax,200,0,5);
2722       fhConeSumPtClusterTrackFrac->SetYTitle("#Sigma #it{p}^{cluster}_{T} /#Sigma #it{p}_{T}^{track}");
2723       fhConeSumPtClusterTrackFrac->SetXTitle("#it{p}^{trigger}_{T} (GeV/#it{c})");
2724       outputContainer->Add(fhConeSumPtClusterTrackFrac) ;
2725
2726
2727       fhConePtLeadClustervsTrack   = new TH2F("hConePtLeadClustervsTrack",
2728                                              Form("Track vs Cluster lead #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
2729                                              nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2730       fhConePtLeadClustervsTrack->SetXTitle("#it{p}^{leading cluster}_{T} (GeV/#it{c})");
2731       fhConePtLeadClustervsTrack->SetYTitle("#it{p}^{leading track}_{T} (GeV/#it{c})");
2732       outputContainer->Add(fhConePtLeadClustervsTrack) ;
2733
2734       fhConePtLeadClusterTrackFrac   = new TH2F("hConePtLeadClusterTrackFraction",
2735                                                Form(" #it{p}^{leading cluster}_{T}/#it{p}^{leading track}_{T} in isolation cone for #it{R} =  %2.2f",r),
2736                                                nptbins,ptmin,ptmax,200,0,5);
2737       fhConePtLeadClusterTrackFrac->SetYTitle("#it{p}^{leading cluster}_{T}/ #it{p}^{leading track}_{T}");
2738       fhConePtLeadClusterTrackFrac->SetXTitle("#it{p}^{trigger}_{T} (GeV/#it{c})");
2739       outputContainer->Add(fhConePtLeadClusterTrackFrac) ;
2740
2741
2742       if(fFillCellHistograms)
2743       {
2744         fhConeSumPtCellvsTrack   = new TH2F("hConePtSumCellvsTrack",
2745                                             Form("Track vs cell #Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
2746                                             nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2747         fhConeSumPtCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2748         fhConeSumPtCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2749         outputContainer->Add(fhConeSumPtCellvsTrack) ;
2750
2751         fhConeSumPtCellTrack = new TH2F("hConePtSumCellTrack",
2752                                         Form("Track and Cell #Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
2753                                         nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2754         fhConeSumPtCellTrack->SetYTitle("#Sigma #it{p}_{T}");
2755         fhConeSumPtCellTrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2756         outputContainer->Add(fhConeSumPtCellTrack) ;
2757
2758         fhConeSumPtCellTrackTrigEtaPhi  = new TH2F("hConePtSumCellTrackTrigEtaPhi",
2759                                                    Form("Trigger #eta vs #phi, #Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",r),
2760                                                    netabins,etamin,etamax,nphibins,phimin,phimax);
2761         fhConeSumPtCellTrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2762         fhConeSumPtCellTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
2763         fhConeSumPtCellTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2764         outputContainer->Add(fhConeSumPtCellTrackTrigEtaPhi) ;
2765
2766       }
2767
2768       if(fFillUEBandSubtractHistograms)
2769       {
2770         fhConeSumPtEtaUESub  = new TH2F("hConeSumPtEtaUESub",
2771                                         Form("#Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} =  %2.2f",r),
2772                                         nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2773         fhConeSumPtEtaUESub->SetYTitle("#Sigma #it{p}_{T}");
2774         fhConeSumPtEtaUESub->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2775         outputContainer->Add(fhConeSumPtEtaUESub) ;
2776
2777         fhConeSumPtPhiUESub  = new TH2F("hConeSumPtPhiUESub",
2778                                         Form("#Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} =  %2.2f",r),
2779                                         nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2780         fhConeSumPtPhiUESub->SetYTitle("#Sigma #it{p}_{T}");
2781         fhConeSumPtPhiUESub->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2782         outputContainer->Add(fhConeSumPtPhiUESub) ;
2783
2784         fhConeSumPtEtaUESubTrigEtaPhi  = new TH2F("hConeSumPtEtaUESubTrigEtaPhi",
2785                                                   Form("Trigger #eta vs #phi, #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} =  %2.2f",r),
2786                                                   netabins,etamin,etamax,nphibins,phimin,phimax);
2787         fhConeSumPtEtaUESubTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2788         fhConeSumPtEtaUESubTrigEtaPhi->SetXTitle("#eta_{trigger}");
2789         fhConeSumPtEtaUESubTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2790         outputContainer->Add(fhConeSumPtEtaUESubTrigEtaPhi) ;
2791
2792         fhConeSumPtPhiUESubTrigEtaPhi  = new TH2F("hConeSumPtPhiUESubTrigEtaPhi",
2793                                                   Form("Trigger #eta vs #phi, #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} =  %2.2f",r),
2794                                                   netabins,etamin,etamax,nphibins,phimin,phimax);
2795         fhConeSumPtPhiUESubTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2796         fhConeSumPtPhiUESubTrigEtaPhi->SetXTitle("#eta_{trigger}");
2797         fhConeSumPtPhiUESubTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2798         outputContainer->Add(fhConeSumPtPhiUESubTrigEtaPhi) ;
2799
2800         fhConeSumPtEtaUESubClustervsTrack   = new TH2F("hConePtSumEtaUESubClustervsTrack",
2801                                                        Form("Track vs Cluster #Sigma #it{p}_{T} UE sub eta band in isolation cone for #it{R} =  %2.2f",r),
2802                                                        2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2803         fhConeSumPtEtaUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2804         fhConeSumPtEtaUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2805         outputContainer->Add(fhConeSumPtEtaUESubClustervsTrack) ;
2806
2807         fhConeSumPtPhiUESubClustervsTrack   = new TH2F("hConePhiUESubPtSumClustervsTrack",
2808                                                        Form("Track vs Cluster #Sigma #it{p}_{T} UE sub phi band in isolation cone for #it{R} =  %2.2f",r),
2809                                                        2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2810         fhConeSumPtPhiUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2811         fhConeSumPtPhiUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2812         outputContainer->Add(fhConeSumPtPhiUESubClustervsTrack) ;
2813
2814         fhEtaBandClustervsTrack   = new TH2F("hEtaBandClustervsTrack",
2815                                              Form("Track vs Cluster #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} =  %2.2f",r),
2816                                              nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2817         fhEtaBandClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2818         fhEtaBandClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2819         outputContainer->Add(fhEtaBandClustervsTrack) ;
2820
2821         fhPhiBandClustervsTrack   = new TH2F("hPhiBandClustervsTrack",
2822                                              Form("Track vs Cluster #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} =  %2.2f",r),
2823                                              nptsumbins,ptsummin,ptsummax*4,nptsumbins,ptsummin,ptsummax*8);
2824         fhPhiBandClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2825         fhPhiBandClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2826         outputContainer->Add(fhPhiBandClustervsTrack) ;
2827
2828         fhEtaBandNormClustervsTrack   = new TH2F("hEtaBandNormClustervsTrack",
2829                                                  Form("Track vs Cluster #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} =  %2.2f",r),
2830                                                  nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2831         fhEtaBandNormClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2832         fhEtaBandNormClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2833         outputContainer->Add(fhEtaBandNormClustervsTrack) ;
2834
2835         fhPhiBandNormClustervsTrack   = new TH2F("hPhiBandNormClustervsTrack",
2836                                                  Form("Track vs Cluster #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} =  %2.2f",r),
2837                                                  nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2838         fhPhiBandNormClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2839         fhPhiBandNormClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2840         outputContainer->Add(fhPhiBandNormClustervsTrack) ;
2841
2842         fhConeSumPtEtaUESubClustervsTrack   = new TH2F("hConePtSumEtaUESubClustervsTrack",
2843                                                        Form("Track vs Cluster #Sigma #it{p}_{T} UE sub eta band in isolation cone for #it{R} =  %2.2f",r),
2844                                                        2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2845         fhConeSumPtEtaUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2846         fhConeSumPtEtaUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2847         outputContainer->Add(fhConeSumPtEtaUESubClustervsTrack) ;
2848
2849         fhConeSumPtPhiUESubClustervsTrack   = new TH2F("hConePhiUESubPtSumClustervsTrack",
2850                                                        Form("Track vs Cluster #Sigma #it{p}_{T} UE sub phi band in isolation cone for #it{R} =  %2.2f",r),
2851                                                        2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2852         fhConeSumPtPhiUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2853         fhConeSumPtPhiUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2854         outputContainer->Add(fhConeSumPtPhiUESubClustervsTrack) ;
2855
2856         if(fFillCellHistograms)
2857         {
2858
2859           fhConeSumPtEtaUESubCellvsTrack   = new TH2F("hConePtSumEtaUESubCellvsTrack",
2860                                                       Form("Track vs Cell #Sigma #it{p}_{T} UE sub eta band in isolation cone for #it{R} =  %2.2f",r),
2861                                                       2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2862           fhConeSumPtEtaUESubCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2863           fhConeSumPtEtaUESubCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2864           outputContainer->Add(fhConeSumPtEtaUESubCellvsTrack) ;
2865
2866           fhConeSumPtPhiUESubCellvsTrack   = new TH2F("hConePhiUESubPtSumCellvsTrack",
2867                                                       Form("Track vs Cell #Sigma #it{p}_{T} UE sub phi band in isolation cone for #it{R} =  %2.2f",r),
2868                                                       2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2869           fhConeSumPtPhiUESubCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2870           fhConeSumPtPhiUESubCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2871           outputContainer->Add(fhConeSumPtPhiUESubCellvsTrack) ;
2872
2873           fhEtaBandCellvsTrack   = new TH2F("hEtaBandCellvsTrack",
2874                                             Form("Track vs Cell #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} =  %2.2f",r),
2875                                             nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2876           fhEtaBandCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2877           fhEtaBandCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2878           outputContainer->Add(fhEtaBandCellvsTrack) ;
2879
2880           fhPhiBandCellvsTrack   = new TH2F("hPhiBandCellvsTrack",
2881                                             Form("Track vs Cell #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} =  %2.2f",r),
2882                                             nptsumbins,ptsummin,ptsummax*4,nptsumbins,ptsummin,ptsummax*8);
2883           fhPhiBandCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2884           fhPhiBandCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2885           outputContainer->Add(fhPhiBandCellvsTrack) ;
2886
2887           fhEtaBandNormCellvsTrack   = new TH2F("hEtaBandNormCellvsTrack",
2888                                                 Form("Track vs Cell #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} =  %2.2f",r),
2889                                                 nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2890           fhEtaBandNormCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2891           fhEtaBandNormCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2892           outputContainer->Add(fhEtaBandNormCellvsTrack) ;
2893
2894           fhPhiBandNormCellvsTrack   = new TH2F("hPhiBandNormCellvsTrack",
2895                                                 Form("Track vs Cell #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} =  %2.2f",r),
2896                                                 nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2897           fhPhiBandNormCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2898           fhPhiBandNormCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2899           outputContainer->Add(fhPhiBandNormCellvsTrack) ;
2900
2901           fhConeSumPtEtaUESubTrackCell  = new TH2F("hConeSumPtEtaUESubTrackCell",
2902                                                    Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} =  %2.2f",r),
2903                                                    nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2904           fhConeSumPtEtaUESubTrackCell->SetYTitle("#Sigma #it{p}_{T}");
2905           fhConeSumPtEtaUESubTrackCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2906           outputContainer->Add(fhConeSumPtEtaUESubTrackCell) ;
2907
2908           fhConeSumPtPhiUESubTrackCell  = new TH2F("hConeSumPtPhiUESubTrackCell",
2909                                                    Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} =  %2.2f",r),
2910                                                    nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2911           fhConeSumPtPhiUESubTrackCell->SetYTitle("#Sigma #it{p}_{T}");
2912           fhConeSumPtPhiUESubTrackCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2913           outputContainer->Add(fhConeSumPtPhiUESubTrackCell) ;
2914
2915           fhConeSumPtEtaUESubTrackCellTrigEtaPhi  = new TH2F("hConeSumPtEtaUESubTrackCellTrigEtaPhi",
2916                                                              Form("Trigger #eta vs #phi, Tracks #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} =  %2.2f",r),
2917                                                              netabins,etamin,etamax,nphibins,phimin,phimax);
2918           fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2919           fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
2920           fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2921           outputContainer->Add(fhConeSumPtEtaUESubTrackCellTrigEtaPhi) ;
2922
2923           fhConeSumPtPhiUESubTrackCellTrigEtaPhi  = new TH2F("hConeSumPtPhiUESubTrackCellTrigEtaPhi",
2924                                                              Form("Trigger #eta vs #phi, Tracks #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} =  %2.2f",r),
2925                                                              netabins,etamin,etamax,nphibins,phimin,phimax);
2926           fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2927           fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
2928           fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2929           outputContainer->Add(fhConeSumPtPhiUESubTrackCellTrigEtaPhi) ;
2930         }
2931       }
2932     }
2933
2934     for(Int_t iso = 0; iso < 2; iso++)
2935     {
2936       if(fFillTMHisto)
2937       {
2938         fhTrackMatchedDEta[iso]  = new TH2F
2939         (Form("hTrackMatchedDEta%s",isoName[iso].Data()),
2940          Form("%s - d#eta of cluster-track vs cluster energy, %s",isoTitle[iso].Data(),parTitle.Data()),
2941          nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
2942         fhTrackMatchedDEta[iso]->SetYTitle("d#eta");
2943         fhTrackMatchedDEta[iso]->SetXTitle("E_{cluster} (GeV)");
2944
2945         fhTrackMatchedDPhi[iso]  = new TH2F
2946         (Form("hTrackMatchedDPhi%s",isoName[iso].Data()),
2947          Form("%s - d#phi of cluster-track vs cluster energy, %s",isoTitle[iso].Data(),parTitle.Data()),
2948          nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
2949         fhTrackMatchedDPhi[iso]->SetYTitle("d#phi (rad)");
2950         fhTrackMatchedDPhi[iso]->SetXTitle("E_{cluster} (GeV)");
2951
2952         fhTrackMatchedDEtaDPhi[iso]  = new TH2F
2953         (Form("hTrackMatchedDEtaDPhi%s",isoName[iso].Data()),
2954          Form("%s - d#eta vs d#phi of cluster-track, %s",isoTitle[iso].Data(),parTitle.Data()),
2955          nresetabins,resetamin,resetamax,nresphibins,resphimin,resphimax);
2956         fhTrackMatchedDEtaDPhi[iso]->SetYTitle("d#phi (rad)");
2957         fhTrackMatchedDEtaDPhi[iso]->SetXTitle("d#eta");
2958
2959         outputContainer->Add(fhTrackMatchedDEta[iso]) ;
2960         outputContainer->Add(fhTrackMatchedDPhi[iso]) ;
2961         outputContainer->Add(fhTrackMatchedDEtaDPhi[iso]) ;
2962
2963         fhdEdx[iso]  = new TH2F
2964         (Form("hdEdx%s",isoName[iso].Data()),
2965          Form("%s - Matched track <d#it{E}/d#it{x}> vs cluster #it{E}, %s",isoTitle[iso].Data(),parTitle.Data()),
2966          nptbins,ptmin,ptmax,ndedxbins, dedxmin, dedxmax);
2967         fhdEdx[iso]->SetXTitle("#it{E} (GeV)");
2968         fhdEdx[iso]->SetYTitle("<d#it{E}/d#it{x}>");
2969         outputContainer->Add(fhdEdx[iso]);
2970
2971         fhEOverP[iso]  = new TH2F
2972         (Form("hEOverP%s",isoName[iso].Data()),
2973          Form("%s - Matched track #it{E}/#it{p} vs cluster, %s",isoTitle[iso].Data(),parTitle.Data()),
2974          nptbins,ptmin,ptmax,nPoverEbins,pOverEmin,pOverEmax);
2975         fhEOverP[iso]->SetXTitle("#it{E} (GeV)");
2976         fhEOverP[iso]->SetYTitle("#it{E}/#it{p}");
2977         outputContainer->Add(fhEOverP[iso]);
2978
2979         if(IsDataMC())
2980         {
2981           fhTrackMatchedMCParticle[iso]  = new TH2F
2982           (Form("hTrackMatchedMCParticle%s",isoName[iso].Data()),
2983            Form("%s - Origin of particle vs cluster #it{E}, %s",isoTitle[iso].Data(),parTitle.Data()),
2984            nptbins,ptmin,ptmax,8,0,8);
2985           fhTrackMatchedMCParticle[iso]->SetXTitle("#it{E} (GeV)");
2986           //fhTrackMatchedMCParticle[iso]->SetYTitle("Particle type");
2987
2988           fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(1 ,"Photon");
2989           fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(2 ,"Electron");
2990           fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(3 ,"Meson Merged");
2991           fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(4 ,"Rest");
2992           fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(5 ,"Conv. Photon");
2993           fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(6 ,"Conv. Electron");
2994           fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(7 ,"Conv. Merged");
2995           fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(8 ,"Conv. Rest");
2996
2997           outputContainer->Add(fhTrackMatchedMCParticle[iso]);
2998         }
2999       }
3000
3001       if(fFillSSHisto)
3002       {
3003         fhELambda0[iso]  = new TH2F
3004         (Form("hELambda0%s",isoName[iso].Data()),
3005          Form("%s cluster : #it{E} vs #lambda_{0}, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3006         fhELambda0[iso]->SetYTitle("#lambda_{0}^{2}");
3007         fhELambda0[iso]->SetXTitle("#it{E} (GeV)");
3008         outputContainer->Add(fhELambda0[iso]) ;
3009
3010 //        fhELambda1[iso]  = new TH2F
3011 //        (Form("hELambda1%s",isoName[iso].Data()),
3012 //         Form("%s cluster: #it{E} vs #lambda_{1}, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3013 //        fhELambda1[iso]->SetYTitle("#lambda_{1}^{2}");
3014 //        fhELambda1[iso]->SetXTitle("#it{E} (GeV)");
3015 //        outputContainer->Add(fhELambda1[iso]) ;
3016
3017         fhPtLambda0[iso]  = new TH2F
3018         (Form("hPtLambda0%s",isoName[iso].Data()),
3019          Form("%s cluster : #it{p}_{T} vs #lambda_{0}, %s",isoTitle[iso].Data(), parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3020         fhPtLambda0[iso]->SetYTitle("#lambda_{0}^{2}");
3021         fhPtLambda0[iso]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3022         outputContainer->Add(fhPtLambda0[iso]) ;
3023
3024         if(IsDataMC())
3025         {
3026           for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
3027           {
3028             fhPtLambda0MC[imc][iso]  = new TH2F(Form("hPtLambda0%s_MC%s",isoName[iso].Data(),mcPartName[imc].Data()),
3029                                                 Form("%s cluster : #it{p}_{T} vs #lambda_{0}: %s %s",isoTitle[iso].Data(),mcPartType[imc].Data(),parTitle.Data()),
3030                                                 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3031             fhPtLambda0MC[imc][iso]->SetYTitle("#lambda_{0}^{2}");
3032             fhPtLambda0MC[imc][iso]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
3033             outputContainer->Add( fhPtLambda0MC[imc][iso]) ;
3034           }
3035         }
3036
3037         if(fIsoDetector==kEMCAL &&  GetFirstSMCoveredByTRD() >= 0)
3038         {
3039           fhPtLambda0TRD[iso]  = new TH2F
3040           (Form("hPtLambda0TRD%s",isoName[iso].Data()),
3041            Form("%s cluster: #it{p}_{T} vs #lambda_{0}, SM behind TRD, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3042           fhPtLambda0TRD[iso]->SetYTitle("#lambda_{0}^{2}");
3043           fhPtLambda0TRD[iso]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3044           outputContainer->Add(fhPtLambda0TRD[iso]) ;
3045
3046           fhELambda0TRD[iso]  = new TH2F
3047           (Form("hELambda0TRD%s",isoName[iso].Data()),
3048            Form("%s cluster: #it{E} vs #lambda_{0}, SM behind TRD, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3049           fhELambda0TRD[iso]->SetYTitle("#lambda_{0}^{2}");
3050           fhELambda0TRD[iso]->SetXTitle("#it{E} (GeV)");
3051           outputContainer->Add(fhELambda0TRD[iso]) ;
3052
3053 //          fhELambda1TRD[iso]  = new TH2F
3054 //          (Form("hELambda1TRD%s",isoName[iso].Data()),
3055 //           Form("%s cluster: #it{E} vs #lambda_{1}, SM behind TRD, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3056 //          fhELambda1TRD[iso]->SetYTitle("#lambda_{1}^{2}");
3057 //          fhELambda1TRD[iso]->SetXTitle("#it{E} (GeV)");
3058 //          outputContainer->Add(fhELambda1TRD[iso]) ;
3059         }
3060
3061         if(fFillNLMHistograms)
3062         {
3063           fhNLocMax[iso] = new TH2F
3064           (Form("hNLocMax%s",isoName[iso].Data()),
3065            Form("%s - Number of local maxima in cluster, %s",isoTitle[iso].Data(),parTitle.Data()),
3066            nptbins,ptmin,ptmax,10,0,10);
3067           fhNLocMax[iso]->SetYTitle("#it{NLM}");
3068           fhNLocMax[iso]->SetXTitle("#it{E} (GeV)");
3069           outputContainer->Add(fhNLocMax[iso]) ;
3070
3071           fhELambda0LocMax1[iso]  = new TH2F
3072           (Form("hELambda0LocMax1%s",isoName[iso].Data()),
3073            Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{0}, #it{NLM}=1, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3074           fhELambda0LocMax1[iso]->SetYTitle("#lambda_{0}^{2}");
3075           fhELambda0LocMax1[iso]->SetXTitle("#it{E} (GeV)");
3076           outputContainer->Add(fhELambda0LocMax1[iso]) ;
3077
3078           fhELambda1LocMax1[iso]  = new TH2F
3079           (Form("hELambda1LocMax1%s",isoName[iso].Data()),
3080            Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{1}, #it{NLM}=1, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3081           fhELambda1LocMax1[iso]->SetYTitle("#lambda_{1}^{2}");
3082           fhELambda1LocMax1[iso]->SetXTitle("#it{E} (GeV)");
3083           outputContainer->Add(fhELambda1LocMax1[iso]) ;
3084
3085           fhELambda0LocMax2[iso]  = new TH2F
3086           (Form("hELambda0LocMax2%s",isoName[iso].Data()),
3087            Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{0}, #it{NLM}=2, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3088           fhELambda0LocMax2[iso]->SetYTitle("#lambda_{0}^{2}");
3089           fhELambda0LocMax2[iso]->SetXTitle("#it{E} (GeV)");
3090           outputContainer->Add(fhELambda0LocMax2[iso]) ;
3091
3092           fhELambda1LocMax2[iso]  = new TH2F
3093           (Form("hELambda1LocMax2%s",isoName[iso].Data()),
3094            Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{1}, #it{NLM}=2, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3095           fhELambda1LocMax2[iso]->SetYTitle("#lambda_{1}^{2}");
3096           fhELambda1LocMax2[iso]->SetXTitle("#it{E} (GeV)");
3097           outputContainer->Add(fhELambda1LocMax2[iso]) ;
3098
3099           fhELambda0LocMaxN[iso]  = new TH2F
3100           ( Form("hELambda0LocMaxN%s",isoName[iso].Data()),
3101            Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{0}, #it{NLM}>2, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3102           fhELambda0LocMaxN[iso]->SetYTitle("#lambda_{0}^{2}");
3103           fhELambda0LocMaxN[iso]->SetXTitle("#it{E} (GeV)");
3104           outputContainer->Add(fhELambda0LocMaxN[iso]) ;
3105
3106           fhELambda1LocMaxN[iso]  = new TH2F
3107           (Form("hELambda1LocMaxN%s",isoName[iso].Data()),
3108            Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{1}, #it{NLM}>2, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3109           fhELambda1LocMaxN[iso]->SetYTitle("#lambda_{1}^{2}");
3110           fhELambda1LocMaxN[iso]->SetXTitle("#it{E} (GeV)");
3111           outputContainer->Add(fhELambda1LocMaxN[iso]) ;
3112         } // NLM
3113       } // SS histo
3114     } // control histograms for isolated and non isolated objects
3115
3116
3117     if(IsPileUpAnalysisOn())
3118     {
3119       fhPtTrackInConeOtherBC  = new TH2F("hPtTrackInConeOtherBC",
3120                                          Form("#it{p}_{T} of tracks in isolation cone for #it{R} =  %2.2f, TOF from BC!=0",r),
3121                                          nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
3122       fhPtTrackInConeOtherBC->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
3123       fhPtTrackInConeOtherBC->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3124       outputContainer->Add(fhPtTrackInConeOtherBC) ;
3125
3126       fhPtTrackInConeOtherBCPileUpSPD  = new TH2F("hPtTrackInConeOtherBCPileUpSPD",
3127                                                   Form("#it{p}_{T} of tracks in isolation cone for #it{R} =  %2.2f, TOF from BC!=0, pile-up from SPD",r),
3128                                                   nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
3129       fhPtTrackInConeOtherBCPileUpSPD->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
3130       fhPtTrackInConeOtherBCPileUpSPD->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3131       outputContainer->Add(fhPtTrackInConeOtherBCPileUpSPD) ;
3132
3133       fhPtTrackInConeBC0  = new TH2F("hPtTrackInConeBC0",
3134                                      Form("#it{p}_{T} of tracks in isolation cone for #it{R} =  %2.2f, TOF from BC==0",r),
3135                                      nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
3136       fhPtTrackInConeBC0->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
3137       fhPtTrackInConeBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3138       outputContainer->Add(fhPtTrackInConeBC0) ;
3139
3140       fhPtTrackInConeVtxBC0  = new TH2F("hPtTrackInConeVtxBC0",
3141                                         Form("#it{p}_{T} of tracks in isolation cone for #it{R} =  %2.2f, TOF from BC==0",r),
3142                                         nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
3143       fhPtTrackInConeVtxBC0->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
3144       fhPtTrackInConeVtxBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3145       outputContainer->Add(fhPtTrackInConeVtxBC0) ;
3146
3147
3148       fhPtTrackInConeBC0PileUpSPD  = new TH2F("hPtTrackInConeBC0PileUpSPD",
3149                                               Form("#it{p}_{T} of tracks in isolation cone for #it{R} =  %2.2f, TOF from BC==0, pile-up from SPD",r),
3150                                               nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
3151       fhPtTrackInConeBC0PileUpSPD->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
3152       fhPtTrackInConeBC0PileUpSPD->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3153       outputContainer->Add(fhPtTrackInConeBC0PileUpSPD) ;
3154
3155
3156       for (Int_t i = 0; i < 7 ; i++)
3157       {
3158         fhPtInConePileUp[i]  = new TH2F(Form("hPtInConePileUp%s",pileUpName[i].Data()),
3159                                         Form("#it{p}_{T} in isolation cone for #it{R} =  %2.2f, from pile-up (%s)",r,pileUpName[i].Data()),
3160                                         nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
3161         fhPtInConePileUp[i]->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
3162         fhPtInConePileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3163         outputContainer->Add(fhPtInConePileUp[i]) ;
3164       }
3165     }
3166
3167     if(IsDataMC())
3168     {
3169       // For histograms in arrays, index in the array, corresponding to any particle origin
3170
3171       for(Int_t i = 0; i < fgkNmcPrimTypes; i++)
3172       {
3173         fhEPrimMC[i]  = new TH1F(Form("hEPrim_MC%s",ppname[i].Data()),
3174                                  Form("primary photon  %s : #it{E}, %s",pptype[i].Data(),parTitle.Data()),
3175                                  nptbins,ptmin,ptmax);
3176         fhEPrimMC[i]->SetXTitle("#it{E} (GeV)");
3177         outputContainer->Add(fhEPrimMC[i]) ;
3178
3179         fhPtPrimMC[i]  = new TH1F(Form("hPtPrim_MC%s",ppname[i].Data()),
3180                                  Form("primary photon  %s : #it{p}_{T}, %s",pptype[i].Data(),parTitle.Data()),
3181                                  nptbins,ptmin,ptmax);
3182         fhPtPrimMC[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3183         outputContainer->Add(fhPtPrimMC[i]) ;
3184
3185         fhPtPrimMCiso[i]  = new TH1F(Form("hPtPrim_MCiso%s",ppname[i].Data()),
3186                                      Form("primary isolated photon %s : #it{p}_{T}, %s",pptype[i].Data(),parTitle.Data()),
3187                                      nptbins,ptmin,ptmax);
3188         fhPtPrimMCiso[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3189         outputContainer->Add(fhPtPrimMCiso[i]) ;
3190
3191         fhEtaPrimMC[i]  = new TH2F(Form("hEtaPrim_MC%s",ppname[i].Data()),
3192                                    Form("primary photon %s : #eta vs #it{p}_{T}, %s",pptype[i].Data(),parTitle.Data()),
3193                                    nptbins,ptmin,ptmax,200,-2,2);
3194         fhEtaPrimMC[i]->SetYTitle("#eta");
3195         fhEtaPrimMC[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3196         outputContainer->Add(fhEtaPrimMC[i]) ;
3197
3198         fhPhiPrimMC[i]  = new TH2F(Form("hPhiPrim_MC%s",ppname[i].Data()),
3199                                    Form("primary photon %s : #phi vs #it{p}_{T}, %s",pptype[i].Data(),parTitle.Data()),
3200                                    nptbins,ptmin,ptmax,200,0.,TMath::TwoPi());
3201         fhPhiPrimMC[i]->SetYTitle("#phi");
3202         fhPhiPrimMC[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3203         outputContainer->Add(fhPhiPrimMC[i]) ;
3204       }
3205
3206       if(fMakePrimaryPi0DecayStudy)
3207       {
3208         fhPtPrimMCPi0DecayPairAcceptInConeLowPt  = new TH1F("hPtPrim_MCPhotonPi0DecayPairAcceptInConeLowPt",
3209                                                             Form("primary photon  %s : #it{p}_{T}, pair in cone, %s",pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3210                                                             nptbins,ptmin,ptmax);
3211         fhPtPrimMCPi0DecayPairAcceptInConeLowPt->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3212         outputContainer->Add(fhPtPrimMCPi0DecayPairAcceptInConeLowPt) ;
3213
3214         fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPt  = new TH1F("hPtPrim_MCisoPhotonPi0DecayPairAcceptInConeLowPt",
3215                                                                Form("isolated primary photon %s, pair in cone : #it{p}_{T}, %s",
3216                                                                     pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3217                                                                nptbins,ptmin,ptmax);
3218         fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPt->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3219         outputContainer->Add(fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPt) ;
3220
3221         fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlap  = new TH1F("hPtPrim_MCPhotonPi0DecayPairAcceptInConeLowPtNoOverlap",
3222                                                                      Form("primary photon  %s, no overlap, pair in cone : #it{p}_{T}, %s",
3223                                                                           pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3224                                                                      nptbins,ptmin,ptmax);
3225         fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlap->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3226         outputContainer->Add(fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlap) ;
3227
3228         fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlap  = new TH1F("hPtPrim_MCisoPhotonPi0DecayPairAcceptInConeLowPtNoOverlap",
3229                                                                         Form("isolated primary photon  %s, pair in cone,no overlap : #it{p}_{T}, %s",
3230                                                                              pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3231                                                                         nptbins,ptmin,ptmax);
3232         fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlap->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3233         outputContainer->Add(fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlap) ;
3234
3235         fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlapCaloE  = new TH1F("hPtPrim_MCPhotonPi0DecayPairAcceptInConeLowPtNoOverlapCaloE",
3236                                                                      Form("primary photon  %s, no overlap, pair in cone, E > calo min: #it{p}_{T}, %s",
3237                                                                           pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3238                                                                      nptbins,ptmin,ptmax);
3239         fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlapCaloE->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3240         outputContainer->Add(fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlapCaloE) ;
3241
3242         fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlapCaloE  = new TH1F("hPtPrim_MCisoPhotonPi0DecayPairAcceptInConeLowPtNoOverlapCaloE",
3243                                                                         Form("isolated primary photon  %s, pair in cone,no overlap, E > calo min: #it{p}_{T}, %s",
3244                                                                              pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3245                                                                         nptbins,ptmin,ptmax);
3246         fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlapCaloE->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3247         outputContainer->Add(fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlapCaloE) ;
3248
3249
3250         fhPtPrimMCPi0DecayPairNoOverlap  = new TH1F("hPtPrim_MCPhotonPi0DecayPairNoOverlap",
3251                                                                      Form("primary photon  %s, no overlap: #it{p}_{T}, %s",
3252                                                                           pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3253                                                                      nptbins,ptmin,ptmax);
3254         fhPtPrimMCPi0DecayPairNoOverlap->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3255         outputContainer->Add(fhPtPrimMCPi0DecayPairNoOverlap) ;
3256
3257         fhPtPrimMCPi0DecayIsoPairNoOverlap  = new TH1F("hPtPrim_MCisoPhotonPi0DecayPairNoOverlap",
3258                                                     Form("isolated primary photon  %s, no overlap: #it{p}_{T}, %s",
3259                                                          pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3260                                                     nptbins,ptmin,ptmax);
3261         fhPtPrimMCPi0DecayIsoPairNoOverlap->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3262         outputContainer->Add(fhPtPrimMCPi0DecayIsoPairNoOverlap) ;
3263
3264         fhPtPrimMCPi0DecayPairOutOfCone  = new TH1F("hPtPrim_MCPhotonPi0DecayPairOutOfCone",
3265                                                     Form("primary photon %s : #it{p}_{T}, pair out of cone, %s",pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3266                                                     nptbins,ptmin,ptmax);
3267         fhPtPrimMCPi0DecayPairOutOfCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3268         outputContainer->Add(fhPtPrimMCPi0DecayPairOutOfCone) ;
3269
3270         fhPtPrimMCPi0DecayIsoPairOutOfCone  = new TH1F("hPtPrim_MCisoPhotonPi0DecayPairOutOfCone",
3271                                                        Form("isolated primary photon %s, pair out of cone : #it{p}_{T}, %s",
3272                                                             pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3273                                                        nptbins,ptmin,ptmax);
3274         fhPtPrimMCPi0DecayIsoPairOutOfCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3275         outputContainer->Add(fhPtPrimMCPi0DecayIsoPairOutOfCone) ;
3276
3277         fhPtPrimMCPi0DecayPairOutOfAcceptance  = new TH1F("hPtPrim_MCPhotonPi0DecayPairOutOfAcceptance",
3278                                                           Form("primary photon %s : #it{p}_{T}, pair out of acceptance, %s",pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3279                                                           nptbins,ptmin,ptmax);
3280         fhPtPrimMCPi0DecayPairOutOfAcceptance->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3281         outputContainer->Add(fhPtPrimMCPi0DecayPairOutOfAcceptance) ;
3282
3283         fhPtPrimMCPi0DecayPairOutOfAcceptanceNoOverlap  = new TH1F("hPtPrim_MCPhotonPi0DecayPairOutOfAcceptanceNoOverlap",
3284                                                           Form("primary photon %s : #it{p}_{T}, pair out of acceptance, no overlap, %s",pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3285                                                           nptbins,ptmin,ptmax);
3286         fhPtPrimMCPi0DecayPairOutOfAcceptanceNoOverlap->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3287         outputContainer->Add(fhPtPrimMCPi0DecayPairOutOfAcceptanceNoOverlap) ;
3288
3289         fhPtPrimMCPi0DecayIsoPairOutOfAcceptance  = new TH1F("hPtPrim_MCisoPhotonPi0DecayPairOutOfAcceptance",
3290                                                              Form("isolated primary photon %s, pair out of acceptance : #it{p}_{T}, %s",
3291                                                                   pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3292                                                              nptbins,ptmin,ptmax);
3293         fhPtPrimMCPi0DecayIsoPairOutOfAcceptance->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3294         outputContainer->Add(fhPtPrimMCPi0DecayIsoPairOutOfAcceptance) ;
3295
3296         fhPtPrimMCPi0DecayIsoPairOutOfAcceptanceNoOverlap  = new TH1F("hPtPrim_MCisoPhotonPi0DecayPairOutOfAcceptanceNoOverlap",
3297                                                              Form("isolated primary photon %s, pair out of acceptance, no overlap : #it{p}_{T}, %s",
3298                                                                   pptype[kmcPrimPi0Decay].Data(),parTitle.Data()),
3299                                                              nptbins,ptmin,ptmax);
3300         fhPtPrimMCPi0DecayIsoPairOutOfAcceptanceNoOverlap->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3301         outputContainer->Add(fhPtPrimMCPi0DecayIsoPairOutOfAcceptanceNoOverlap) ;
3302
3303         fhPtPrimMCPi0Overlap  = new TH1F("hPtPrim_MCPi0Overlap",
3304                                          Form("primary %s, overlap: #it{p}_{T}, %s",
3305                                               pptype[kmcPrimPi0].Data(),parTitle.Data()),
3306                                          nptbins,ptmin,ptmax);
3307         fhPtPrimMCPi0Overlap->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3308         outputContainer->Add(fhPtPrimMCPi0Overlap) ;
3309
3310         fhPtPrimMCPi0IsoOverlap  = new TH1F("hPtPrim_MCisoPi0Overlap",
3311                                          Form("primary %s, overlap: #it{p}_{T}, %s",
3312                                               pptype[kmcPrimPi0].Data(),parTitle.Data()),
3313                                          nptbins,ptmin,ptmax);
3314         fhPtPrimMCPi0IsoOverlap->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3315         outputContainer->Add(fhPtPrimMCPi0IsoOverlap) ;
3316
3317       }
3318
3319     }//Histos with MC
3320
3321   }
3322
3323   if(fMakeSeveralIC)
3324   {
3325     const Int_t buffersize = 255;
3326     char name[buffersize];
3327     char title[buffersize];
3328     for(Int_t icone = 0; icone<fNCones; icone++)
3329     {
3330       // sum pt in cone vs. pt leading
3331       snprintf(name, buffersize,"hSumPtLeadingPt_Cone_%d",icone);
3332       snprintf(title, buffersize,"#Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",fConeSizes[icone]);
3333       fhSumPtLeadingPt[icone]  = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
3334       fhSumPtLeadingPt[icone] ->SetYTitle("#sum_{cone}#it{p}_{T} (GeV/#it{c})");//#Sigma #it{p}_{T}
3335       fhSumPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
3336       outputContainer->Add(fhSumPtLeadingPt[icone]) ;
3337
3338       // pt in cone vs. pt leading
3339       snprintf(name, buffersize,"hPtLeadingPt_Cone_%d",icone);
3340       snprintf(title, buffersize,"#it{p}_{T} in isolation cone for #it{R} =  %2.2f",fConeSizes[icone]);
3341       fhPtLeadingPt[icone]  = new TH2F(name, title,  nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
3342       fhPtLeadingPt[icone] ->SetYTitle("#it{p}_{T}^{cone} (GeV/#it{c})");
3343       fhPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
3344       outputContainer->Add(fhPtLeadingPt[icone]) ;
3345
3346       // sum pt in cone vs. pt leading in the forward region (for background subtraction studies)
3347       snprintf(name, buffersize,"hPerpSumPtLeadingPt_Cone_%d",icone);
3348       snprintf(title, buffersize,"#Sigma #it{p}_{T} in isolation cone for #it{R} =  %2.2f",fConeSizes[icone]);
3349       fhPerpSumPtLeadingPt[icone]  = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
3350       fhPerpSumPtLeadingPt[icone] ->SetYTitle("#sum_{cone}#it{p}_{T} (GeV/#it{c})");//#Sigma #it{p}_{T}
3351       fhPerpSumPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
3352       outputContainer->Add(fhPerpSumPtLeadingPt[icone]) ;
3353
3354       // pt in cone vs. pt leading in the forward region (for background subtraction studies)
3355       snprintf(name, buffersize,"hPerpPtLeadingPt_Cone_%d",icone);
3356       snprintf(title, buffersize,"#it{p}_{T} in isolation cone for #it{R} =  %2.2f",fConeSizes[icone]);
3357       fhPerpPtLeadingPt[icone]  = new TH2F(name, title,  nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
3358       fhPerpPtLeadingPt[icone] ->SetYTitle("#it{p}_{T}^{cone} (GeV/#it{c})");
3359       fhPerpPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
3360       outputContainer->Add(fhPerpPtLeadingPt[icone]) ;
3361
3362       if(IsDataMC())
3363       {
3364         for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
3365         {
3366           snprintf(name , buffersize,"hSumPtLeadingPt_MC%s_Cone_%d",mcPartName[imc].Data(),icone);
3367           snprintf(title, buffersize,"Candidate %s #it{p}_{T} vs cone #Sigma #it{p}_{T} for #it{R}=%2.2f",mcPartType[imc].Data(),fConeSizes[icone]);
3368           fhSumPtLeadingPtMC[imc][icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
3369           fhSumPtLeadingPtMC[imc][icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
3370           fhSumPtLeadingPtMC[imc][icone]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
3371           outputContainer->Add(fhSumPtLeadingPtMC[imc][icone]) ;
3372         }
3373       }//Histos with MC
3374
3375       for(Int_t ipt = 0; ipt<fNPtThresFrac;ipt++)
3376       {
3377         snprintf(name, buffersize,"hPtThres_Cone_%d_Pt%d",icone,ipt);
3378         snprintf(title, buffersize,"Isolated candidate #it{p}_{T} distribution for #it{R} =  %2.2f and #it{p}_{T}^{th} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtThresholds[ipt]);
3379         fhPtThresIsolated[icone][ipt]  = new TH1F(name, title,nptbins,ptmin,ptmax);
3380         fhPtThresIsolated[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3381         outputContainer->Add(fhPtThresIsolated[icone][ipt]) ;
3382
3383         snprintf(name, buffersize,"hPtFrac_Cone_%d_Pt%d",icone,ipt);
3384         snprintf(title, buffersize,"Isolated candidate #it{p}_{T} distribution for #it{R} =  %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
3385         fhPtFracIsolated[icone][ipt]  = new TH1F(name, title,nptbins,ptmin,ptmax);
3386         fhPtFracIsolated[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3387         outputContainer->Add(fhPtFracIsolated[icone][ipt]) ;
3388
3389         snprintf(name, buffersize,"hSumPt_Cone_%d_Pt%d",icone,ipt);
3390         snprintf(title, buffersize,"Isolated candidate #it{p}_{T} distribution for #it{R} =  %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
3391         fhSumPtIsolated[icone][ipt]  = new TH1F(name, title,nptbins,ptmin,ptmax);
3392         // fhSumPtIsolated[icone][ipt]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
3393         fhSumPtIsolated[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3394         outputContainer->Add(fhSumPtIsolated[icone][ipt]) ;
3395
3396         snprintf(name, buffersize,"hPtSumDensity_Cone_%d_Pt%d",icone,ipt);
3397         snprintf(title, buffersize,"Isolated candidate #it{p}_{T} distribution for density in #it{R} =  %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
3398         fhPtSumDensityIso[icone][ipt]  = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
3399         //fhPtSumIsolated[icone][ipt]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
3400         fhPtSumDensityIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3401         outputContainer->Add(fhPtSumDensityIso[icone][ipt]) ;
3402
3403         snprintf(name, buffersize,"hPtFracPtSum_Cone_%d_Pt%d",icone,ipt);
3404         snprintf(title, buffersize,"Isolated candidate #it{p}_{T} distribution for PtFracPtSum in #it{R} =  %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
3405         fhPtFracPtSumIso[icone][ipt]  = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
3406         //fhPtSumIsolated[icone][ipt]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
3407         fhPtFracPtSumIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3408         outputContainer->Add(fhPtFracPtSumIso[icone][ipt]) ;
3409
3410         // eta:phi
3411         snprintf(name, buffersize,"hEtaPhiPtThres_Cone_%d_Pt%d",icone,ipt);
3412         snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for #it{R} =  %2.2f and #it{p}_{T}^{th} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtThresholds[ipt]);
3413         fhEtaPhiPtThresIso[icone][ipt]  = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3414         fhEtaPhiPtThresIso[icone][ipt]->SetXTitle("#eta");
3415         fhEtaPhiPtThresIso[icone][ipt]->SetYTitle("#phi");
3416         outputContainer->Add(fhEtaPhiPtThresIso[icone][ipt]) ;
3417
3418         snprintf(name, buffersize,"hEtaPhiPtFrac_Cone_%d_Pt%d",icone,ipt);
3419         snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for #it{R} =  %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
3420         fhEtaPhiPtFracIso[icone][ipt]  = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3421         fhEtaPhiPtFracIso[icone][ipt]->SetXTitle("#eta");
3422         fhEtaPhiPtFracIso[icone][ipt]->SetYTitle("#phi");
3423         outputContainer->Add(fhEtaPhiPtFracIso[icone][ipt]) ;
3424
3425         snprintf(name, buffersize,"hEtaPhiPtSum_Cone_%d_Pt%d",icone,ipt);
3426         snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for #it{R} =  %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
3427         fhEtaPhiPtSumIso[icone][ipt]  = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3428         fhEtaPhiPtSumIso[icone][ipt]->SetXTitle("#eta");
3429         fhEtaPhiPtSumIso[icone][ipt]->SetYTitle("#phi");
3430         outputContainer->Add(fhEtaPhiPtSumIso[icone][ipt]) ;
3431
3432         snprintf(name, buffersize,"hEtaPhiSumDensity_Cone_%d_Pt%d",icone,ipt);
3433         snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for density #it{R} =  %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
3434         fhEtaPhiSumDensityIso[icone][ipt]  = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3435         fhEtaPhiSumDensityIso[icone][ipt]->SetXTitle("#eta");
3436         fhEtaPhiSumDensityIso[icone][ipt]->SetYTitle("#phi");
3437         outputContainer->Add(fhEtaPhiSumDensityIso[icone][ipt]) ;
3438
3439         snprintf(name, buffersize,"hEtaPhiFracPtSum_Cone_%d_Pt%d",icone,ipt);
3440         snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for FracPtSum #it{R} =  %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
3441         fhEtaPhiFracPtSumIso[icone][ipt]  = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3442         fhEtaPhiFracPtSumIso[icone][ipt]->SetXTitle("#eta");
3443         fhEtaPhiFracPtSumIso[icone][ipt]->SetYTitle("#phi");
3444         outputContainer->Add(fhEtaPhiFracPtSumIso[icone][ipt]) ;
3445
3446         if(fFillTaggedDecayHistograms)
3447         {
3448           // pt decays isolated
3449           snprintf(name, buffersize,"hPtThres_Decay_Cone_%d_Pt%d",icone,ipt);
3450           snprintf(title, buffersize,"Isolated decay candidate #it{p}_{T} distribution for #it{R} =  %2.2f and #it{p}_{T}^{th} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtThresholds[ipt]);
3451           fhPtPtThresDecayIso[icone][ipt]  = new TH1F(name, title,nptbins,ptmin,ptmax);
3452           fhPtPtThresDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3453           outputContainer->Add(fhPtPtThresDecayIso[icone][ipt]) ;
3454
3455           snprintf(name, buffersize,"hPtFrac_Decay_Cone_%d_Pt%d",icone,ipt);
3456           snprintf(title, buffersize,"Isolated decay candidate #it{p}_{T} distribution for #it{R} =  %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
3457           fhPtPtFracDecayIso[icone][ipt]  = new TH1F(name, title,nptbins,ptmin,ptmax);
3458           fhPtPtFracDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3459           outputContainer->Add(fhPtPtFracDecayIso[icone][ipt]) ;
3460
3461           snprintf(name, buffersize,"hPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
3462           snprintf(title, buffersize,"Isolated decay candidate #it{p}_{T} distribution for #it{R} =  %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
3463           fhPtPtSumDecayIso[icone][ipt]  = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
3464           //  fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
3465           fhPtPtSumDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3466           outputContainer->Add(fhPtPtSumDecayIso[icone][ipt]) ;
3467
3468           snprintf(name, buffersize,"hPtSumDensity_Decay_Cone_%d_Pt%d",icone,ipt);
3469           snprintf(title, buffersize,"Isolated decay candidate #it{p}_{T} distribution for density in #it{R} =  %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
3470           fhPtSumDensityDecayIso[icone][ipt]  = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
3471           //  fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
3472           fhPtSumDensityDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3473           outputContainer->Add(fhPtSumDensityDecayIso[icone][ipt]) ;
3474
3475           snprintf(name, buffersize,"hPtFracPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
3476           snprintf(title, buffersize,"Isolated decay candidate #it{p}_{T} distribution for PtFracPtSum in #it{R} =  %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
3477           fhPtFracPtSumDecayIso[icone][ipt]  = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
3478           //  fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
3479           fhPtFracPtSumDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3480           outputContainer->Add(fhPtFracPtSumDecayIso[icone][ipt]) ;
3481
3482           // eta:phi decays
3483           snprintf(name, buffersize,"hEtaPhiPtThres_Decay_Cone_%d_Pt%d",icone,ipt);
3484           snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for #it{R} =  %2.2f and #it{p}_{T}^{th} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtThresholds[ipt]);
3485           fhEtaPhiPtThresDecayIso[icone][ipt]  = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3486           fhEtaPhiPtThresDecayIso[icone][ipt]->SetXTitle("#eta");
3487           fhEtaPhiPtThresDecayIso[icone][ipt]->SetYTitle("#phi");
3488           outputContainer->Add(fhEtaPhiPtThresDecayIso[icone][ipt]) ;
3489
3490           snprintf(name, buffersize,"hEtaPhiPtFrac_Decay_Cone_%d_Pt%d",icone,ipt);
3491           snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for #it{R} =  %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
3492           fhEtaPhiPtFracDecayIso[icone][ipt]  = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3493           fhEtaPhiPtFracDecayIso[icone][ipt]->SetXTitle("#eta");
3494           fhEtaPhiPtFracDecayIso[icone][ipt]->SetYTitle("#phi");
3495           outputContainer->Add(fhEtaPhiPtFracDecayIso[icone][ipt]) ;
3496
3497
3498           snprintf(name, buffersize,"hEtaPhiPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
3499           snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for #it{R} =  %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
3500           fhEtaPhiPtSumDecayIso[icone][ipt]  = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3501           fhEtaPhiPtSumDecayIso[icone][ipt]->SetXTitle("#eta");
3502           fhEtaPhiPtSumDecayIso[icone][ipt]->SetYTitle("#phi");
3503           outputContainer->Add(fhEtaPhiPtSumDecayIso[icone][ipt]) ;
3504
3505           snprintf(name, buffersize,"hEtaPhiSumDensity_Decay_Cone_%d_Pt%d",icone,ipt);
3506           snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for density #it{R} =  %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
3507           fhEtaPhiSumDensityDecayIso[icone][ipt]  = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3508           fhEtaPhiSumDensityDecayIso[icone][ipt]->SetXTitle("#eta");
3509           fhEtaPhiSumDensityDecayIso[icone][ipt]->SetYTitle("#phi");
3510           outputContainer->Add(fhEtaPhiSumDensityDecayIso[icone][ipt]) ;
3511
3512           snprintf(name, buffersize,"hEtaPhiFracPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
3513           snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for FracPtSum #it{R} =  %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
3514           fhEtaPhiFracPtSumDecayIso[icone][ipt]  = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3515           fhEtaPhiFracPtSumDecayIso[icone][ipt]->SetXTitle("#eta");
3516           fhEtaPhiFracPtSumDecayIso[icone][ipt]->SetYTitle("#phi");
3517           outputContainer->Add(fhEtaPhiFracPtSumDecayIso[icone][ipt]) ;
3518
3519         }
3520
3521         if(IsDataMC())
3522         {
3523           for(Int_t imc = 0; imc < fgkNmcTypes; imc++)
3524           {
3525             snprintf(name , buffersize,"hPtThreshMC%s_Cone_%d_Pt%d",mcPartName[imc].Data(),icone,ipt);
3526             snprintf(title, buffersize,"Isolated %s #it{p}_{T} for #it{R}=%2.2f and #it{p}_{T}^{th}=%2.2f",
3527                      mcPartType[imc].Data(),fConeSizes[icone], fPtThresholds[ipt]);
3528             fhPtThresIsolatedMC[imc][icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
3529             fhPtThresIsolatedMC[imc][icone][ipt]->SetYTitle("#it{counts}");
3530             fhPtThresIsolatedMC[imc][icone][ipt]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
3531             outputContainer->Add(fhPtThresIsolatedMC[imc][icone][ipt]) ;
3532
3533
3534             snprintf(name , buffersize,"hPtFracMC%s_Cone_%d_Pt%d",mcPartName[imc].Data(),icone,ipt);
3535             snprintf(title, buffersize,"Isolated %s #it{p}_{T} for #it{R}=%2.2f and #Sigma #it{p}_{T}^{in cone}/#it{p}_{T}^{trig}=%2.2f",
3536                      mcPartType[imc].Data(),fConeSizes[icone], fPtFractions[ipt]);
3537             fhPtFracIsolatedMC[imc][icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
3538             fhPtFracIsolatedMC[imc][icone][ipt]->SetYTitle("#it{counts}");
3539             fhPtFracIsolatedMC[imc][icone][ipt]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
3540             outputContainer->Add(fhPtFracIsolatedMC[imc][icone][ipt]) ;
3541
3542             snprintf(name , buffersize,"hSumPtMC%s_Cone_%d_Pt%d",mcPartName[imc].Data(),icone,ipt);
3543             snprintf(title, buffersize,"Isolated %s #it{p}_{T} for #it{R}=%2.2f and #Sigma #it{p}_{T}^{in cone}=%2.2f",
3544                      mcPartType[imc].Data(),fConeSizes[icone], fSumPtThresholds[ipt]);
3545             fhSumPtIsolatedMC[imc][icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
3546             fhSumPtIsolatedMC[imc][icone][ipt]->SetYTitle("#it{counts}");
3547             fhSumPtIsolatedMC[imc][icone][ipt]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
3548             outputContainer->Add(fhSumPtIsolatedMC[imc][icone][ipt]) ;
3549           }
3550         }//Histos with MC
3551       }//icone loop
3552     }//ipt loop
3553   }
3554
3555   if(IsPileUpAnalysisOn())
3556   {
3557     for (Int_t i = 0; i < 7 ; i++)
3558     {
3559       fhEIsoPileUp[i]   = new TH1F(Form("hEPileUp%s",pileUpName[i].Data()),
3560                                    Form("Number of isolated particles vs E, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
3561                                    nptbins,ptmin,ptmax);
3562       fhEIsoPileUp[i]->SetYTitle("d#it{N} / d#it{E}");
3563       fhEIsoPileUp[i]->SetXTitle("#it{E} (GeV)");
3564       outputContainer->Add(fhEIsoPileUp[i]) ;
3565
3566       fhPtIsoPileUp[i]  = new TH1F(Form("hPtPileUp%s",pileUpName[i].Data()),
3567                                    Form("Number of isolated particles vs #it{p}_{T}, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
3568                                    nptbins,ptmin,ptmax);
3569       fhPtIsoPileUp[i]->SetYTitle("d#it{N} / #it{p}_{T}");
3570       fhPtIsoPileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3571       outputContainer->Add(fhPtIsoPileUp[i]) ;
3572
3573       fhENoIsoPileUp[i]   = new TH1F(Form("hENoIsoPileUp%s",pileUpName[i].Data()),
3574                                      Form("Number of not isolated particles vs E, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
3575                                      nptbins,ptmin,ptmax);
3576       fhENoIsoPileUp[i]->SetYTitle("d#it{N} / dE");
3577       fhENoIsoPileUp[i]->SetXTitle("#it{E} (GeV)");
3578       outputContainer->Add(fhENoIsoPileUp[i]) ;
3579
3580       fhPtNoIsoPileUp[i]  = new TH1F(Form("hPtNoIsoPileUp%s",pileUpName[i].Data()),
3581                                      Form("Number of not isolated particles vs #it{p}_{T}, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
3582                                      nptbins,ptmin,ptmax);
3583       fhPtNoIsoPileUp[i]->SetYTitle("d#it{N} / #it{p}_{T}");
3584       fhPtNoIsoPileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
3585       outputContainer->Add(fhPtNoIsoPileUp[i]) ;
3586     }
3587
3588     fhTimeENoCut  = new TH2F ("hTimeE_NoCut","time of cluster vs E of clusters, no cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
3589     fhTimeENoCut->SetXTitle("#it{E} (GeV)");
3590     fhTimeENoCut->SetYTitle("#it{time} (ns)");
3591     outputContainer->Add(fhTimeENoCut);
3592
3593     fhTimeESPD  = new TH2F ("hTimeE_SPD","time of cluster vs E of clusters, SPD cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
3594     fhTimeESPD->SetXTitle("#it{E} (GeV)");
3595     fhTimeESPD->SetYTitle("#it{time} (ns)");
3596     outputContainer->Add(fhTimeESPD);
3597
3598     fhTimeESPDMulti  = new TH2F ("hTimeE_SPDMulti","time of cluster vs E of clusters, SPD multi cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
3599     fhTimeESPDMulti->SetXTitle("#it{E} (GeV)");
3600     fhTimeESPDMulti->SetYTitle("#it{time} (ns)");
3601     outputContainer->Add(fhTimeESPDMulti);
3602
3603     fhTimeNPileUpVertSPD  = new TH2F ("hTime_NPileUpVertSPD","time of cluster vs N pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50);
3604     fhTimeNPileUpVertSPD->SetYTitle("# vertex ");
3605     fhTimeNPileUpVertSPD->SetXTitle("#it{time} (ns)");
3606     outputContainer->Add(fhTimeNPileUpVertSPD);
3607
3608     fhTimeNPileUpVertTrack  = new TH2F ("hTime_NPileUpVertTracks","time of cluster vs N pile-up Tracks vertex", ntimebins,timemin,timemax, 50,0,50 );
3609     fhTimeNPileUpVertTrack->SetYTitle("# vertex ");
3610     fhTimeNPileUpVertTrack->SetXTitle("#it{time} (ns)");
3611     outputContainer->Add(fhTimeNPileUpVertTrack);
3612
3613     fhTimeNPileUpVertContributors  = new TH2F ("hTime_NPileUpVertContributors","time of cluster vs N constributors to pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50);
3614     fhTimeNPileUpVertContributors->SetYTitle("# vertex ");
3615     fhTimeNPileUpVertContributors->SetXTitle("#it{time} (ns)");
3616     outputContainer->Add(fhTimeNPileUpVertContributors);
3617
3618     fhTimePileUpMainVertexZDistance  = new TH2F ("hTime_PileUpMainVertexZDistance","time of cluster vs distance in Z pile-up SPD vertex - main SPD vertex",ntimebins,timemin,timemax,100,0,50);
3619     fhTimePileUpMainVertexZDistance->SetYTitle("distance #it{z} (cm) ");
3620     fhTimePileUpMainVertexZDistance->SetXTitle("#it{time} (ns)");
3621     outputContainer->Add(fhTimePileUpMainVertexZDistance);
3622
3623     fhTimePileUpMainVertexZDiamond  = new TH2F ("hTime_PileUpMainVertexZDiamond","time of cluster vs distance in Z pile-up SPD vertex - z diamond",ntimebins,timemin,timemax,100,0,50);
3624     fhTimePileUpMainVertexZDiamond->SetYTitle("diamond distance #it{z} (cm) ");
3625     fhTimePileUpMainVertexZDiamond->SetXTitle("#it{time} (ns)");
3626     outputContainer->Add(fhTimePileUpMainVertexZDiamond);
3627   }
3628
3629   return outputContainer ;
3630
3631 }
3632
3633 //____________________________________________________
3634 Int_t AliAnaParticleIsolation::GetMCIndex(Int_t mcTag)
3635 {
3636   // Histogram index depending on origin of candidate
3637
3638   if(!IsDataMC()) return -1;
3639
3640   if     (GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPrompt))
3641   {
3642     return kmcPrompt;
3643   }
3644   else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCFragmentation) ||
3645           GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCISR))
3646   {
3647     return kmcFragment;
3648   }
3649   else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0))
3650   {
3651     return kmcPi0;
3652   }
3653   else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0Decay))
3654   {
3655     return kmcPi0Decay;
3656   }
3657   else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay))
3658   {
3659     return kmcEtaDecay;
3660   }
3661   else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCOtherDecay))
3662   {
3663     return kmcOtherDecay;
3664   }
3665   else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron))
3666   {
3667     return kmcElectron;
3668   }
3669   else // anything else
3670   {
3671     // careful can contain also other decays, to be checked.
3672     return kmcHadron;
3673   }
3674 }
3675
3676 //__________________________________
3677 void AliAnaParticleIsolation::Init()
3678 {
3679   // Do some checks and init stuff
3680
3681   // In case of several cone and thresholds analysis, open the cuts for the filling of the
3682   // track and cluster reference arrays in cone when done in the MakeAnalysisFillAOD().
3683   // The different cones, thresholds are tested for this list of tracks, clusters.
3684   if(fMakeSeveralIC)
3685   {
3686     AliInfo("Open default isolation cuts for multiple Isolation analysis");
3687     GetIsolationCut()->SetPtThreshold(100);
3688     GetIsolationCut()->SetPtFraction(100);
3689     GetIsolationCut()->SetConeSize(1);
3690   }
3691
3692   if(!GetReader()->IsCTSSwitchedOn() && GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::kOnlyNeutral)
3693     AliFatal("STOP!: You want to use CTS tracks in analysis but not read!! \n!!Check the configuration file!!");
3694
3695 }
3696
3697 //____________________________________________
3698 void AliAnaParticleIsolation::InitParameters()
3699 {
3700
3701   //Initialize the parameters of the analysis.
3702   SetInputAODName("PWG4Particle");
3703   SetAODObjArrayName("IsolationCone");
3704   AddToHistogramsName("AnaIsolation_");
3705
3706   fIsoDetectorString = "EMCAL" ;
3707   fIsoDetector       = kEMCAL  ;
3708
3709   fReMakeIC = kFALSE ;
3710   fMakeSeveralIC = kFALSE ;
3711
3712   fMinCellsAngleOverlap = 3.;
3713
3714   fLeadingOnly = kTRUE;
3715   fCheckLeadingWithNeutralClusters = kTRUE;
3716
3717   fNDecayBits = 1;
3718   fDecayBits[0] = AliNeutralMesonSelection::kPi0;
3719   fDecayBits[1] = AliNeutralMesonSelection::kEta;
3720   fDecayBits[2] = AliNeutralMesonSelection::kPi0Side;
3721   fDecayBits[3] = AliNeutralMesonSelection::kEtaSide;
3722
3723   fNBkgBin = 11;
3724   fBkgBinLimit[ 0] = 00.0; fBkgBinLimit[ 1] = 00.2; fBkgBinLimit[ 2] = 00.3; fBkgBinLimit[ 3] = 00.4; fBkgBinLimit[ 4] = 00.5;
3725   fBkgBinLimit[ 5] = 01.0; fBkgBinLimit[ 6] = 01.5; fBkgBinLimit[ 7] = 02.0; fBkgBinLimit[ 8] = 03.0; fBkgBinLimit[ 9] = 05.0;
3726   fBkgBinLimit[10] = 10.0; fBkgBinLimit[11] = 100.;
3727   for(Int_t ibin = fNBkgBin+1; ibin < 20; ibin++) fBkgBinLimit[ibin] = 00.0;
3728
3729   fNPtTrigBin = 6;
3730   fPtTrigBinLimit[ 0] =  8; fPtTrigBinLimit[ 1] = 10; fPtTrigBinLimit[ 2] = 12; fPtTrigBinLimit[ 3] = 14; fPtTrigBinLimit[ 4] = 16;
3731   fPtTrigBinLimit[ 5] = 20; fPtTrigBinLimit[ 6] = 25; ;
3732   for(Int_t ibin = fNPtTrigBin+1; ibin < 20; ibin++) fPtTrigBinLimit[ibin] = 00.0;
3733
3734   //----------- Several IC-----------------
3735   fNCones             = 5 ;
3736   fNPtThresFrac       = 5 ;
3737   fConeSizes      [0] = 0.1;     fConeSizes      [1] = 0.2;   fConeSizes      [2] = 0.3; fConeSizes      [3] = 0.4;  fConeSizes      [4] = 0.5;
3738   fPtThresholds   [0] = 1.;      fPtThresholds   [1] = 2.;    fPtThresholds   [2] = 3.;  fPtThresholds   [3] = 4.;   fPtThresholds   [4] = 5.;
3739   fPtFractions    [0] = 0.05;    fPtFractions    [1] = 0.075; fPtFractions    [2] = 0.1; fPtFractions    [3] = 1.25; fPtFractions    [4] = 1.5;
3740   fSumPtThresholds[0] = 1.;      fSumPtThresholds[1] = 2.;    fSumPtThresholds[2] = 3.;  fSumPtThresholds[3] = 4.;   fSumPtThresholds[4] = 5.;
3741
3742 }
3743
3744 //_________________________________________________________________________________________
3745 Bool_t AliAnaParticleIsolation::IsTriggerTheNearSideEventLeadingParticle(Int_t & idLeading)
3746 {
3747   // Check if the what of the selected isolation candidates is leading particle in the same hemisphere
3748   // comparing with all the candidates, all the tracks or all the clusters.
3749
3750   Double_t ptTrig      = GetMinPt();
3751   Double_t phiTrig     = 0 ;
3752   Int_t index          =-1 ;
3753   AliAODPWG4ParticleCorrelation* pLeading = 0;
3754
3755   // Loop on stored AOD particles, find leading trigger on the selected list, with at least min pT.
3756
3757   for(Int_t iaod = 0; iaod < GetInputAODBranch()->GetEntriesFast() ; iaod++)
3758   {
3759     AliAODPWG4ParticleCorrelation* particle =  (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
3760     particle->SetLeadingParticle(kFALSE); // set it later
3761
3762     // Vertex cut in case of mixing
3763     if(GetMixedEvent())
3764     {
3765       Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0));
3766       if(check ==  0) continue;
3767       if(check == -1) return kFALSE; // not sure if it is correct.
3768     }
3769
3770     //check if it is low pt trigger particle
3771     if((particle->Pt() < GetIsolationCut()->GetPtThreshold() ||
3772         particle->Pt() < GetIsolationCut()->GetSumPtThreshold()) &&
3773        !fMakeSeveralIC)
3774     {
3775       continue ; //trigger should not come from underlying event
3776     }
3777
3778     // find the leading particles with highest momentum
3779     if (particle->Pt() > ptTrig)
3780     {
3781       ptTrig   = particle->Pt() ;
3782       phiTrig  = particle->Phi();
3783       index    = iaod     ;
3784       pLeading = particle ;
3785     }
3786   }// finish search of leading trigger particle on the AOD branch.
3787
3788   if(index < 0) return kFALSE;
3789
3790   idLeading = index;
3791
3792   //printf("AOD leading pT %2.2f, ID %d\n", pLeading->Pt(),pLeading->GetCaloLabel(0));
3793
3794   if(phiTrig < 0 ) phiTrig += TMath::TwoPi();
3795
3796   // Compare if it is the leading of all tracks
3797
3798   for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
3799   {
3800     AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
3801
3802     if(track->GetID() == pLeading->GetTrackLabel(0) || track->GetID() == pLeading->GetTrackLabel(1) ||
3803        track->GetID() == pLeading->GetTrackLabel(2) || track->GetID() == pLeading->GetTrackLabel(3)   ) continue ;
3804
3805     fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
3806     Float_t pt   = fTrackVector.Pt();
3807     Float_t phi  = fTrackVector.Phi() ;
3808     if(phi < 0) phi+=TMath::TwoPi();
3809
3810     //skip this event if near side associated particle pt larger than trigger
3811
3812     Float_t deltaPhi = phiTrig-phi;
3813     //
3814     // Calculate deltaPhi shift so that for the particles on the opposite side
3815     // it is defined between 90 and 270 degrees
3816     // Shift [-360,-90]  to [0, 270]
3817     // and [270,360] to [-90,0]
3818     if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
3819     if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
3820
3821     if(pt > ptTrig && deltaPhi < TMath::PiOver2())  return kFALSE;
3822
3823   }// track loop
3824
3825   // Compare if it is leading of all calorimeter clusters
3826
3827   if(fCheckLeadingWithNeutralClusters)
3828   {
3829     // Select the calorimeter cluster list
3830     TObjArray * nePl = 0x0;
3831     if      (pLeading->GetDetectorTag() == kPHOS )
3832       nePl = GetPHOSClusters();
3833     else
3834       nePl = GetEMCALClusters();
3835
3836     if(!nePl) return kTRUE; // Do the selection just with the tracks if no calorimeter is available.
3837
3838     for(Int_t ipr = 0;ipr < nePl->GetEntriesFast() ; ipr ++ )
3839     {
3840       AliVCluster * cluster = (AliVCluster *) (nePl->At(ipr)) ;
3841
3842       if(cluster->GetID() == pLeading->GetCaloLabel(0) || cluster->GetID() == pLeading->GetCaloLabel(1) ) continue ;
3843
3844       cluster->GetMomentum(fMomentum,GetVertex(0));
3845
3846       Float_t pt   = fMomentum.Pt();
3847       Float_t phi  = fMomentum.Phi() ;
3848       if(phi < 0) phi+=TMath::TwoPi();
3849
3850       if(IsTrackMatched(cluster,GetReader()->GetInputEvent())) continue ; // avoid charged clusters, already covered by tracks, or cluster merging with track.
3851
3852       // skip this event if near side associated particle pt larger than trigger
3853       // not really needed for calorimeter, unless DCal is included
3854
3855       Float_t deltaPhi = phiTrig-phi;
3856       if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
3857       if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
3858
3859       if(pt > ptTrig && deltaPhi < TMath::PiOver2()) return kFALSE ;
3860
3861     }// cluster loop
3862   } // check neutral clusters
3863
3864   idLeading = index ;
3865   pLeading->SetLeadingParticle(kTRUE);
3866
3867   AliDebug(1,Form("Particle AOD with index %d is leading with pT %2.2f",idLeading, pLeading->Pt()));
3868
3869   return kTRUE;
3870
3871 }
3872
3873 //__________________________________________________
3874 void  AliAnaParticleIsolation::MakeAnalysisFillAOD()
3875 {
3876   // Do analysis and fill aods
3877   // Search for the isolated photon in GetCalorimeter() with GetMinPt() < pt < GetMaxPt()
3878   // and if the particle is leading in the near side (if requested)
3879
3880   if(!GetInputAODBranch())
3881     AliFatal(Form("No input particles in AOD with name branch < %s >, STOP",GetInputAODName().Data()));
3882
3883   if(strcmp(GetInputAODBranch()->GetClass()->GetName(), "AliAODPWG4ParticleCorrelation"))
3884     AliFatal(Form("Wrong type of AOD object, change AOD class name in input AOD: It should be <AliAODPWG4ParticleCorrelation> and not <%s>",
3885                   GetInputAODBranch()->GetClass()->GetName()));
3886
3887   Int_t n = 0, nfrac = 0;
3888   Bool_t  isolated  = kFALSE ;
3889   Float_t coneptsum = 0, coneptlead = 0;
3890   TObjArray * pl    = 0x0; ;
3891
3892   //Select the calorimeter for candidate isolation with neutral particles
3893   if      (GetCalorimeter() == kPHOS )
3894     pl = GetPHOSClusters();
3895   else if (GetCalorimeter() == kEMCAL)
3896     pl = GetEMCALClusters();
3897
3898   //Loop on AOD branch, filled previously in AliAnaPhoton, find leading particle to do isolation only with it
3899   Int_t idLeading = -1 ;
3900   Int_t iaod0 = 0;
3901   Int_t naod  = GetInputAODBranch()->GetEntriesFast();
3902
3903   AliDebug(1,Form("Input aod branch entries %d", naod));
3904
3905   if(IsLeadingOnlyOn())
3906   {
3907     Bool_t leading = IsTriggerTheNearSideEventLeadingParticle(idLeading);
3908     if(!leading)
3909     {
3910       AliDebug(1,"Not leading; End fill AODs");
3911       return;
3912     }
3913     iaod0 = idLeading  ; // first entry in particle loop
3914     naod  = idLeading+1; // last entry in particle loop
3915   }
3916
3917   // Check isolation of list of candidate particles or leading particle
3918
3919   for(Int_t iaod = iaod0; iaod < naod; iaod++)
3920   {
3921     AliAODPWG4ParticleCorrelation * aodinput =  (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
3922
3923     // Check isolation only of clusters in fiducial region
3924
3925     if(IsFiducialCutOn())
3926     {
3927       Bool_t in = GetFiducialCut()->IsInFiducialCut(aodinput->Eta(), aodinput->Phi(), aodinput->GetDetectorTag()) ;
3928       if(! in ) continue ;
3929     }
3930
3931     //If too small or too large pt, skip
3932     Float_t pt = aodinput->Pt();
3933     if(pt < GetMinPt() || pt > GetMaxPt() ) continue ;
3934
3935
3936     //check if it is low pt trigger particle
3937     if( ( pt < GetIsolationCut()->GetPtThreshold() ||  pt < GetIsolationCut()->GetSumPtThreshold() ) &&
3938        !fMakeSeveralIC)
3939     {
3940       continue ; //trigger should not come from underlying event
3941     }
3942
3943     //After cuts, study isolation
3944     n=0; nfrac = 0; isolated = kFALSE; coneptsum = 0; coneptlead = 0;
3945     GetIsolationCut()->MakeIsolationCut(GetCTSTracks(),pl,
3946                                         GetReader(), GetCaloPID(),
3947                                         kTRUE, aodinput, GetAODObjArrayName(),
3948                                         n,nfrac,coneptsum,coneptlead,isolated);
3949
3950     if(!fMakeSeveralIC) aodinput->SetIsolated(isolated);
3951
3952     AliDebug(1,Form("Particle isolated? %i; if so with index %d",isolated,iaod));
3953
3954
3955   } // particle isolation loop
3956
3957 }
3958
3959 //_________________________________________________________
3960 void  AliAnaParticleIsolation::MakeAnalysisFillHistograms()
3961 {
3962   // Do analysis and fill histograms
3963
3964   // In case of simulated data, fill acceptance histograms
3965   // Not ready for multiple case analysis.
3966   if(IsDataMC() && !fMakeSeveralIC) FillAcceptanceHistograms();
3967
3968   //Loop on stored AOD
3969   Int_t naod = GetInputAODBranch()->GetEntriesFast();
3970   AliDebug(1,Form("Histo aod branch entries %d", naod));
3971
3972   for(Int_t iaod = 0; iaod < naod ; iaod++)
3973   {
3974     AliAODPWG4ParticleCorrelation* aod =  (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
3975
3976     if(IsLeadingOnlyOn() && !aod->IsLeadingParticle()) continue; // Try to isolate only leading cluster or track
3977
3978     // Check isolation only of clusters in fiducial region
3979     if(IsFiducialCutOn())
3980     {
3981       Bool_t in = GetFiducialCut()->IsInFiducialCut(aod->Eta(),aod->Phi(),aod->GetDetectorTag()) ;
3982       if(! in ) continue ;
3983     }
3984
3985     Float_t pt         = aod->Pt();
3986
3987     //If too small or too large pt, skip
3988     if(pt < GetMinPt() || pt > GetMaxPt() ) continue ;
3989
3990     Int_t mcTag        = aod->GetTag() ;
3991     Int_t mcIndex      = GetMCIndex(mcTag);
3992
3993     // --- In case of redoing isolation from delta AOD ----
3994     // Not standard case, not used since its implementation
3995     if(fMakeSeveralIC)
3996     {
3997       //Analysis of multiple IC at same time
3998       MakeSeveralICAnalysis(aod,mcIndex);
3999       continue;
4000     }
4001
4002     // --- In case of redoing isolation multiple cuts ----
4003
4004     if(fReMakeIC)
4005     {
4006       //In case a more strict IC is needed in the produced AOD
4007       Bool_t  isolated = kFALSE;
4008       Int_t   n = 0, nfrac = 0;
4009       Float_t coneptsum = 0, coneptlead = 0;
4010
4011       //Recover reference arrays with clusters and tracks
4012       TObjArray * refclusters = aod->GetObjArray(GetAODObjArrayName()+"Clusters");
4013       TObjArray * reftracks   = aod->GetObjArray(GetAODObjArrayName()+"Tracks");
4014
4015       GetIsolationCut()->MakeIsolationCut(reftracks,   refclusters,
4016                                           GetReader(), GetCaloPID(),
4017                                           kFALSE, aod, "",
4018                                           n,nfrac,coneptsum,coneptlead,isolated);
4019     }
4020
4021     Bool_t  isolated   = aod->IsIsolated();
4022     Float_t energy     = aod->E();
4023     Float_t phi        = aod->Phi();
4024     Float_t eta        = aod->Eta();
4025
4026     AliDebug(1,Form("pt %1.1f, eta %1.1f, phi %1.1f, Isolated %d",pt, eta, phi, isolated));
4027
4028     //---------------------------------------------------------------
4029     // Fill pt/sum pT distribution of particles in cone or in UE band
4030     //---------------------------------------------------------------
4031
4032     Float_t coneptLeadCluster= 0;
4033     Float_t coneptLeadTrack  = 0;
4034     Float_t coneptsumCluster = 0;
4035     Float_t coneptsumTrack   = 0;
4036     Float_t coneptsumCell    = 0;
4037     Float_t etaBandptsumClusterNorm = 0;
4038     Float_t etaBandptsumTrackNorm   = 0;
4039
4040     CalculateTrackSignalInCone   (aod,coneptsumTrack  , coneptLeadTrack  );
4041     CalculateCaloSignalInCone    (aod,coneptsumCluster, coneptLeadCluster);
4042     if(fFillCellHistograms)
4043       CalculateCaloCellSignalInCone(aod,coneptsumCell   );
4044
4045     if(GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged)
4046     {
4047       fhConeSumPtClustervsTrack ->Fill(coneptsumCluster, coneptsumTrack );
4048       fhConePtLeadClustervsTrack->Fill(coneptLeadCluster,coneptLeadTrack);
4049
4050       if(coneptsumTrack  > 0) fhConeSumPtClusterTrackFrac ->Fill(pt, coneptsumCluster /coneptsumTrack );
4051       if(coneptLeadTrack > 0) fhConePtLeadClusterTrackFrac->Fill(pt, coneptLeadCluster/coneptLeadTrack);
4052
4053       if(fFillCellHistograms)
4054       {
4055         fhConeSumPtCellvsTrack        ->Fill(coneptsumCell,   coneptsumTrack);
4056         fhConeSumPtCellTrack          ->Fill(pt,     coneptsumTrack+coneptsumCell);
4057         fhConeSumPtCellTrackTrigEtaPhi->Fill(eta,phi,coneptsumTrack+coneptsumCell);
4058       }
4059     }
4060
4061     fhConeSumPt              ->Fill(pt,     coneptsumTrack+coneptsumCluster);
4062     fhConeSumPtTrigEtaPhi    ->Fill(eta,phi,coneptsumTrack+coneptsumCluster);
4063
4064     Float_t coneptLead = coneptLeadTrack;
4065     if(coneptLeadCluster > coneptLeadTrack) coneptLead = coneptLeadCluster;
4066     fhConePtLead->Fill(pt, coneptLead );
4067
4068     AliDebug(1,Form("Particle %d Energy Sum in Isolation Cone %2.2f, Leading pT in cone %2.2f",
4069              iaod, coneptsumTrack+coneptsumCluster, coneptLead));
4070
4071     //normalize phi/eta band per area unit
4072     if(fFillUEBandSubtractHistograms)
4073       CalculateNormalizeUEBandPerUnitArea(aod, coneptsumCluster, coneptsumCell, coneptsumTrack, etaBandptsumTrackNorm, etaBandptsumClusterNorm) ;
4074
4075     //  printf("Histograms analysis : cluster pt = %f, etaBandTrack = %f, etaBandCluster = %f, isolation = %d\n",aod->Pt(),etaBandptsumTrackNorm,etaBandptsumClusterNorm,aod->IsIsolated());
4076
4077     //---------------------------------------------------------------
4078     // Fill Shower shape and track matching histograms
4079     //---------------------------------------------------------------
4080
4081     FillTrackMatchingShowerShapeControlHistograms(aod, coneptsumTrack+coneptsumCluster, coneptLead, mcIndex);
4082
4083     //---------------------------------------------------------------
4084     // Isolated/ Non isolated histograms
4085     //---------------------------------------------------------------
4086
4087     if(isolated)
4088     {
4089       AliDebug(1,Form("Particle %d ISOLATED: fill histograms", iaod));
4090
4091       fhEIso      ->Fill(energy);
4092       fhPtIso     ->Fill(pt);
4093       fhPhiIso    ->Fill(pt,phi);
4094       fhEtaIso    ->Fill(pt,eta);
4095       fhEtaPhiIso ->Fill(eta,phi);
4096
4097       if(IsDataMC())
4098       {
4099         // For histograms in arrays, index in the array, corresponding to any particle origin
4100         if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
4101         {
4102           fhPtIsoMC [kmcPhoton]->Fill(pt);
4103           fhPhiIsoMC[kmcPhoton]->Fill(pt,phi);
4104           fhEtaIsoMC[kmcPhoton]->Fill(pt,eta);
4105         }
4106
4107         if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==kmcPi0Decay )
4108         {
4109           fhPtIsoMC [kmcPi0DecayLostPair]->Fill(pt);
4110           fhPhiIsoMC[kmcPi0DecayLostPair]->Fill(pt,phi);
4111           fhEtaIsoMC[kmcPi0DecayLostPair]->Fill(pt,eta);
4112         }
4113
4114         fhPtIsoMC [mcIndex]->Fill(pt);
4115         fhPhiIsoMC[mcIndex]->Fill(pt,phi);
4116         fhEtaIsoMC[mcIndex]->Fill(pt,eta);
4117       }//Histograms with MC
4118
4119       if(fFillNLMHistograms)
4120         fhPtNLocMaxIso ->Fill(pt,aod->GetNLM()) ;
4121
4122       if(IsHighMultiplicityAnalysisOn())
4123       {
4124         fhPtCentralityIso ->Fill(pt,GetEventCentrality()) ;
4125         fhPtEventPlaneIso ->Fill(pt,GetEventPlaneAngle() ) ;
4126       }
4127
4128       if(IsPileUpAnalysisOn())
4129       {
4130         if(GetReader()->IsPileUpFromSPD())               { fhEIsoPileUp[0] ->Fill(energy) ; fhPtIsoPileUp[0]->Fill(pt) ; }
4131         if(GetReader()->IsPileUpFromEMCal())             { fhEIsoPileUp[1] ->Fill(energy) ; fhPtIsoPileUp[1]->Fill(pt) ; }
4132         if(GetReader()->IsPileUpFromSPDOrEMCal())        { fhEIsoPileUp[2] ->Fill(energy) ; fhPtIsoPileUp[2]->Fill(pt) ; }
4133         if(GetReader()->IsPileUpFromSPDAndEMCal())       { fhEIsoPileUp[3] ->Fill(energy) ; fhPtIsoPileUp[3]->Fill(pt) ; }
4134         if(GetReader()->IsPileUpFromSPDAndNotEMCal())    { fhEIsoPileUp[4] ->Fill(energy) ; fhPtIsoPileUp[4]->Fill(pt) ; }
4135         if(GetReader()->IsPileUpFromEMCalAndNotSPD())    { fhEIsoPileUp[5] ->Fill(energy) ; fhPtIsoPileUp[5]->Fill(pt) ; }
4136         if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhEIsoPileUp[6] ->Fill(energy) ; fhPtIsoPileUp[6]->Fill(pt) ; }
4137
4138         // Fill histograms to undertand pile-up before other cuts applied
4139         // Remember to relax time cuts in the reader
4140         FillPileUpHistograms(aod->GetCaloLabel(0));
4141       }
4142
4143     }//Isolated histograms
4144     else // NON isolated
4145     {
4146       AliDebug(1,Form("Particle %d NOT ISOLATED, fill histograms", iaod));
4147
4148       fhENoIso        ->Fill(energy);
4149       fhPtNoIso       ->Fill(pt);
4150       fhEtaPhiNoIso   ->Fill(eta,phi);
4151
4152       if(IsDataMC())
4153       {
4154         if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) )
4155           fhPtNoIsoMC[kmcPhoton]->Fill(pt);
4156
4157         if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==kmcPi0Decay )
4158           fhPtNoIsoMC[kmcPi0DecayLostPair]->Fill(pt);
4159
4160         fhPtNoIsoMC[mcIndex]->Fill(pt);
4161       }
4162
4163       if(fFillNLMHistograms)
4164         fhPtNLocMaxNoIso ->Fill(pt,aod->GetNLM());
4165
4166       if(IsPileUpAnalysisOn())
4167       {
4168         if(GetReader()->IsPileUpFromSPD())                { fhENoIsoPileUp[0] ->Fill(energy) ; fhPtNoIsoPileUp[0]->Fill(pt) ; }
4169         if(GetReader()->IsPileUpFromEMCal())              { fhENoIsoPileUp[1] ->Fill(energy) ; fhPtNoIsoPileUp[1]->Fill(pt) ; }
4170         if(GetReader()->IsPileUpFromSPDOrEMCal())         { fhENoIsoPileUp[2] ->Fill(energy) ; fhPtNoIsoPileUp[2]->Fill(pt) ; }
4171         if(GetReader()->IsPileUpFromSPDAndEMCal())        { fhENoIsoPileUp[3] ->Fill(energy) ; fhPtNoIsoPileUp[3]->Fill(pt) ; }
4172         if(GetReader()->IsPileUpFromSPDAndNotEMCal())     { fhENoIsoPileUp[4] ->Fill(energy) ; fhPtNoIsoPileUp[4]->Fill(pt) ; }
4173         if(GetReader()->IsPileUpFromEMCalAndNotSPD())     { fhENoIsoPileUp[5] ->Fill(energy) ; fhPtNoIsoPileUp[5]->Fill(pt) ; }
4174         if(GetReader()->IsPileUpFromNotSPDAndNotEMCal())  { fhENoIsoPileUp[6] ->Fill(energy) ; fhPtNoIsoPileUp[6]->Fill(pt) ; }
4175       }
4176     } // non iso
4177   }// aod loop
4178
4179 }
4180
4181 //______________________________________________________
4182 void AliAnaParticleIsolation::FillAcceptanceHistograms()
4183 {
4184   // Fill acceptance histograms if MC data is available
4185   // Only when particle is in the calorimeter. Rethink if CTS is used.
4186
4187   AliDebug(1,"Start");
4188
4189   //Double_t photonY   = -100 ;
4190   Double_t photonE   = -1 ;
4191   Double_t photonPt  = -1 ;
4192   Double_t photonPhi =  100 ;
4193   Double_t photonEta = -1 ;
4194
4195   Int_t    pdg       =  0 ;
4196   Int_t    status    =  0 ;
4197   Int_t    tag       =  0 ;
4198   Int_t    mcIndex   =  0 ;
4199   Int_t    nprim     = 0;
4200
4201   TParticle        * primStack = 0;
4202   AliAODMCParticle * primAOD   = 0;
4203
4204   // Calorimeter cluster merging angle
4205   // angle smaller than 3 cells  6 cm (0.014) in EMCal, 2.2 cm in PHOS (0.014*(2.2/6))
4206   Float_t overlapAngle = 0;
4207   Float_t minECalo     = 0;
4208   if      (GetCalorimeter()==kEMCAL)
4209   {
4210     overlapAngle = fMinCellsAngleOverlap*0.014  ;
4211     minECalo = GetReader()->GetEMCALEMin();
4212   }
4213   else if (GetCalorimeter()==kPHOS )
4214   {
4215     overlapAngle = fMinCellsAngleOverlap*0.00382;
4216     minECalo = GetReader()->GetPHOSEMin();
4217   }
4218
4219   // Get the ESD MC particles container
4220   AliStack * stack = 0;
4221   if( GetReader()->ReadStack() )
4222   {
4223     stack = GetMCStack();
4224     if(!stack ) return;
4225     nprim = stack->GetNtrack();
4226   }
4227
4228   // Get the AOD MC particles container
4229   TClonesArray * mcparticles = 0;
4230   if( GetReader()->ReadAODMCParticles() )
4231   {
4232     mcparticles = GetReader()->GetAODMCParticles();
4233     if( !mcparticles ) return;
4234     nprim = mcparticles->GetEntriesFast();
4235   }
4236
4237   for(Int_t i=0 ; i < nprim; i++)
4238   {
4239     if(GetReader()->AcceptOnlyHIJINGLabels() && !GetReader()->IsHIJINGLabel(i)) continue ;
4240
4241     if(GetReader()->ReadStack())
4242     {
4243       primStack = stack->Particle(i) ;
4244       if(!primStack)
4245       {
4246         AliWarning("ESD primaries pointer not available!!");
4247         continue;
4248       }
4249
4250       pdg    = primStack->GetPdgCode();
4251       status = primStack->GetStatusCode();
4252
4253       if(primStack->Energy() == TMath::Abs(primStack->Pz()))  continue ; //Protection against floating point exception
4254
4255       //printf("i %d, %s %d  %s %d \n",i, stack->Particle(i)->GetName(), stack->Particle(i)->GetPdgCode(),
4256       //       prim->GetName(), prim->GetPdgCode());
4257
4258       //photonY   = 0.5*TMath::Log((prim->Energy()+prim->Pz())/(prim->Energy()-prim->Pz())) ;
4259
4260       //Photon kinematics
4261       primStack->Momentum(fMomentum);
4262
4263     }
4264     else
4265     {
4266       primAOD = (AliAODMCParticle *) mcparticles->At(i);
4267       if(!primAOD)
4268       {
4269         AliWarning("AOD primaries pointer not available!!");
4270         continue;
4271       }
4272
4273       pdg    = primAOD->GetPdgCode();
4274       status = primAOD->GetStatus();
4275
4276       if(primAOD->E() == TMath::Abs(primAOD->Pz()))  continue ; //Protection against floating point exception
4277
4278       //photonY   = 0.5*TMath::Log((prim->Energy()+prim->Pz())/(prim->Energy()-prim->Pz())) ;
4279
4280       //Photon kinematics
4281       fMomentum.SetPxPyPzE(primAOD->Px(),primAOD->Py(),primAOD->Pz(),primAOD->E());
4282     }
4283
4284     // Select only photons in the final state
4285     if(pdg != 22  && pdg!=111) continue ;
4286
4287     // Consider only final state particles, but this depends on generator,
4288     // status 1 is the usual one, in case of not being ok, leave the possibility
4289     // to not consider this.
4290     if( pdg == 22 && status != 1 &&
4291         GetMCAnalysisUtils()->GetMCGenerator() != AliMCAnalysisUtils::kBoxLike ) continue ;
4292
4293     // If too small or too large pt, skip, same cut as for data analysis
4294     photonPt  = fMomentum.Pt () ;
4295
4296     if(photonPt < GetMinPt() || photonPt > GetMaxPt() ) continue ;
4297
4298     photonE   = fMomentum.E  () ;
4299     photonEta = fMomentum.Eta() ;
4300     photonPhi = fMomentum.Phi() ;
4301
4302     if(photonPhi < 0) photonPhi+=TMath::TwoPi();
4303
4304     // Check if photons hit the Calorimeter acceptance
4305     if(IsRealCaloAcceptanceOn() && fIsoDetector!=kCTS) // defined on base class
4306     {
4307       if(GetReader()->ReadStack()          &&
4308          !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(fIsoDetector, primStack)) continue ;
4309       if(GetReader()->ReadAODMCParticles() &&
4310          !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(fIsoDetector, primAOD  )) continue ;
4311     }
4312
4313     // Check same fidutial borders as in data analysis on top of real acceptance if real was requested.
4314     if(!GetFiducialCut()->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),fIsoDetector)) continue ;
4315
4316     // Get tag of this particle photon from fragmentation, decay, prompt ...
4317     // Set the origin of the photon.
4318     tag = GetMCAnalysisUtils()->CheckOrigin(i,GetReader(),fIsoDetector);
4319
4320     if(pdg == 22 && !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4321     {
4322       // A conversion photon from a hadron, skip this kind of photon
4323       // printf("AliAnaPhoton::FillAcceptanceHistograms() - not a photon, weird!\n ");
4324       // GetMCAnalysisUtils()->PrintMCTag(tag);
4325
4326       continue;
4327     }
4328
4329     // Check the origin of the photon or if it is a pi0, assing a tag
4330     Int_t pi0d1Label = -1, pi0d2Label = -1;
4331     Bool_t overlapPi0 = kTRUE;
4332     if(pdg==111)
4333     {
4334       mcIndex = kmcPrimPi0;
4335       //printf("check pi0\n");
4336       // Get the labels of the decay particles, remove them from isolation cone
4337       // Get also the opening angle and check if decays likely overlap
4338       Bool_t okpi0 = kFALSE;
4339       Int_t ndaugh = GetMCAnalysisUtils()->GetNDaughters(i,GetReader(), okpi0);
4340       //printf("OK pi0 %d, ndaugh %d\n",okpi0,ndaugh);
4341       Int_t d1Pdg = 0, d1Status = 0; Bool_t ok1 = kFALSE;
4342       Int_t d2Pdg = 0, d2Status = 0; Bool_t ok2 = kFALSE;
4343
4344       if ( ndaugh > 0 ) fMomDaugh1 = GetMCAnalysisUtils()->GetDaughter(0,i,GetReader(),d1Pdg, d1Status,ok1, pi0d1Label);
4345       if ( ndaugh > 1 ) fMomDaugh2 = GetMCAnalysisUtils()->GetDaughter(1,i,GetReader(),d2Pdg, d2Status,ok2, pi0d2Label);
4346
4347       //printf("pi0 daug %d: a) %d, b) %d, c) %d\n", ndaugh,pi0d1Label,pi0d2Label);
4348       //if ( ndaugh !=2 ) printf("PDG: %d, %d, %d\n",d1Pdg,d2Pdg);
4349
4350       // Select decays in 2 photons
4351       if( ndaugh!=2 || (d2Pdg != d1Pdg && d1Pdg!=22)) okpi0 = kFALSE;
4352
4353       // Check overlap of decays
4354       if( okpi0 && fMakePrimaryPi0DecayStudy)
4355       {
4356         Float_t d12Angle = fMomDaugh1.Angle(fMomDaugh2.Vect());
4357         if(d12Angle > overlapAngle) overlapPi0 = kFALSE;
4358         //printf("  -- d12 angle %2.3f, angle limit %2.3f, overlap %d\n",d12Angle,overlapAngle,overlapPi0);
4359       }
4360     }
4361     else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt) )
4362     {
4363       mcIndex = kmcPrimPrompt;
4364     }
4365     else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation) )
4366     {
4367       mcIndex = kmcPrimFrag ;
4368     }
4369     else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR))
4370     {
4371       mcIndex = kmcPrimISR;
4372     }
4373     else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay))
4374     {
4375       mcIndex = kmcPrimPi0Decay;
4376     }
4377     else if( (GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay) ||
4378               GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay)))
4379     {
4380       mcIndex = kmcPrimOtherDecay;
4381     }
4382     else
4383     {
4384       // Other decay but from non final state particle
4385       mcIndex = kmcPrimOtherDecay;
4386     }//Other origin
4387
4388     // ////////////////////ISO MC/////////////////////////
4389     Double_t sumPtInCone = 0; Double_t dR=0. ;
4390     TParticle        * mcisopStack = 0;
4391     AliAODMCParticle * mcisopAOD   = 0;
4392     Int_t partInConeStatus = -1, partInConeMother = -1;
4393     Double_t partInConePt = 0, partInConeE = 0, partInConeEta = 0, partInConePhi = 0;
4394     Int_t partInConeCharge = 0, npart = 0;
4395     for(Int_t ip = 0; ip < nprim ; ip++)
4396     {
4397       if(ip==i) continue;
4398
4399       if( pdg==111 && ( ip == pi0d1Label || ip == pi0d2Label ) )
4400       {
4401         //printf("Do not count pi0 decays in cone when isolating pi0 \n");
4402         continue;
4403       }
4404
4405       if( GetReader()->ReadStack() )
4406       {
4407         mcisopStack = static_cast<TParticle*>(stack->Particle(ip));
4408         if( !mcisopStack ) continue;
4409         partInConeStatus = mcisopStack->GetStatusCode();
4410
4411         // Consider only final state particles, but this depends on generator,
4412         // status 1 is the usual one, in case of not being ok, leave the possibility
4413         // to not consider this.
4414         if( partInConeStatus != 1 &&
4415             GetMCAnalysisUtils()->GetMCGenerator()!= AliMCAnalysisUtils::kBoxLike ) continue ;
4416
4417         partInConeMother = mcisopStack->GetMother(0);
4418         partInConePt     = mcisopStack->Pt();
4419         partInConeE      = mcisopStack->Energy();
4420         partInConeEta    = mcisopStack->Eta();
4421         partInConePhi    = mcisopStack->Phi();
4422         partInConeCharge = TMath::Abs((Int_t) TDatabasePDG::Instance()->GetParticle(mcisopStack->GetPdgCode())->Charge());
4423         mcisopStack->Momentum(fMomIso);
4424       }
4425       else
4426       {
4427         mcisopAOD   = (AliAODMCParticle *) mcparticles->At(ip);
4428         if( !mcisopAOD )   continue;
4429
4430         partInConeStatus = mcisopAOD->GetStatus();
4431         // Consider only final state particles, but this depends on generator,
4432         // status 1 is the usual one, in case of not being ok, leave the possibility
4433         // to not consider this.
4434         if( partInConeStatus != 1 &&
4435             GetMCAnalysisUtils()->GetMCGenerator() != AliMCAnalysisUtils::kBoxLike ) continue ;
4436
4437         partInConeMother = mcisopAOD->GetMother();
4438         partInConePt     = mcisopAOD->Pt();
4439         partInConeE      = mcisopAOD->E();
4440         partInConeEta    = mcisopAOD->Eta();
4441         partInConePhi    = mcisopAOD->Phi();
4442         partInConeCharge = TMath::Abs(mcisopAOD->Charge());
4443         fMomIso.SetPxPyPzE(mcisopAOD->Px(),mcisopAOD->Py(),mcisopAOD->Pz(),mcisopAOD->E());
4444       }
4445
4446       if( partInConeMother == i ) continue;
4447
4448       //
4449       // Apply acceptance and energy/pt cut for particles in cone
4450       if(fSelectPrimariesInCone)
4451       {
4452         if( partInConeCharge > 0) // charged pT cut and acceptance
4453         {
4454           if( GetIsolationCut()->GetParticleTypeInCone() == AliIsolationCut::kOnlyNeutral ) continue;
4455
4456           if( partInConePt < GetReader()->GetCTSPtMin () ) continue;
4457
4458           if(!GetReader()->GetFiducialCut()->IsInFiducialCut(fMomIso.Eta(),fMomIso.Phi(),kCTS)) continue ;
4459         }
4460         else // neutrals E cut and acceptance
4461         {
4462           if( GetIsolationCut()->GetParticleTypeInCone() == AliIsolationCut::kOnlyCharged ) continue;
4463
4464           if( partInConeE  <= minECalo ) continue;
4465
4466           if(!GetReader()->GetFiducialCut()->IsInFiducialCut(fMomIso.Eta(),fMomIso.Phi(),GetCalorimeter())) continue ;
4467
4468           if(IsRealCaloAcceptanceOn()) // defined on base class
4469           {
4470             if(GetReader()->ReadStack()          &&
4471                !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(GetCalorimeter(), mcisopStack)) continue ;
4472             if(GetReader()->ReadAODMCParticles() &&
4473                !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(GetCalorimeter(), mcisopAOD  )) continue ;
4474           }
4475         }
4476       }
4477       //
4478
4479       dR = GetIsolationCut()->Radius(photonEta, photonPhi, partInConeEta, partInConePhi);
4480
4481       if(dR > GetIsolationCut()->GetConeSize())
4482         continue;
4483
4484       sumPtInCone += partInConePt;
4485       if(partInConePt > GetIsolationCut()->GetPtThreshold() &&
4486          partInConePt < GetIsolationCut()->GetPtThresholdMax()) npart++;
4487     }
4488
4489     ///////END ISO MC/////////////////////////
4490
4491     // Fill the histograms, only those in the defined calorimeter acceptance
4492
4493     fhEtaPrimMC[kmcPrimPhoton]->Fill(photonPt , photonEta) ;
4494     fhPhiPrimMC[kmcPrimPhoton]->Fill(photonPt , photonPhi) ;
4495     fhEPrimMC  [kmcPrimPhoton]->Fill(photonE) ;
4496     fhPtPrimMC [kmcPrimPhoton]->Fill(photonPt) ;
4497
4498     fhEtaPrimMC[mcIndex]->Fill(photonPt , photonEta) ;
4499     fhPhiPrimMC[mcIndex]->Fill(photonPt , photonPhi) ;
4500     fhEPrimMC  [mcIndex]->Fill(photonE ) ;
4501     fhPtPrimMC [mcIndex]->Fill(photonPt) ;
4502
4503     // In case the photon is a decay from pi0,
4504     // study how the decay kinematics affects the isolation
4505     Int_t  ndaugh   = -1;
4506     Bool_t okpi0    =  0, ok1     =  0, ok2     =  0;
4507     Int_t  pi0label = -1, d1Label = -1, d2Label = -1;
4508     Bool_t d2Acc   = kTRUE, overlap = kTRUE;
4509     Int_t  d2AbsId = -1;
4510     Float_t dRdaugh2 = 0, d12Angle = 0;
4511     if(mcIndex == kmcPrimPi0Decay && fMakePrimaryPi0DecayStudy)
4512     {
4513       GetMCAnalysisUtils()->GetMotherWithPDG(i,111,GetReader(),okpi0, pi0label);
4514       if(okpi0)
4515       {
4516         ndaugh = GetMCAnalysisUtils()->GetNDaughters(pi0label,GetReader(), okpi0);
4517         if(ndaugh==2)
4518         {
4519           Int_t d1Pdg = 0, d1Status = 0;
4520           fMomDaugh1 = GetMCAnalysisUtils()->GetDaughter(0,pi0label,GetReader(),d1Pdg, d1Status,ok1, d1Label);
4521           Int_t d2Pdg = 0, d2Status = 0;
4522           fMomDaugh2 = GetMCAnalysisUtils()->GetDaughter(1,pi0label,GetReader(),d2Pdg, d2Status,ok2, d2Label);
4523           if(d2Pdg != d1Pdg && d1Pdg!=22) okpi0 = kFALSE;
4524
4525           // Check the momentum and location of second daughter
4526           if(okpi0)
4527           {
4528             // assign current trigger to first daughter
4529             if(d1Label!=i)
4530             {
4531               Int_t tmpLabel = d2Label;
4532               d2Label = d1Label;
4533               d1Label = tmpLabel;
4534               fMomentum  = fMomDaugh2;
4535               fMomDaugh2 = fMomDaugh1;
4536               fMomDaugh1 = fMomentum;
4537             }
4538
4539             // Check if photons hit the Calorimeter acceptance
4540             if(IsRealCaloAcceptanceOn() && fIsoDetector!=kCTS) // defined on base class
4541                  d2Acc = GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(fIsoDetector,fMomDaugh2.Eta(),
4542                                                                              fMomDaugh2.Theta(),fMomDaugh2.Phi(),d2AbsId) ;
4543
4544             //printf("D2  (eta %2.2f,phi %2.2f)in real calo %d, with absId %d\n",
4545             //       daugh2mom.Eta(), daugh2mom.Phi()*TMath::RadToDeg(),d2Acc,d2AbsId);
4546
4547             // Check same fidutial borders as in data analysis on top of real acceptance if real was requested.
4548             if(d2Acc) d2Acc = GetReader()->GetFiducialCut()->IsInFiducialCut(fMomDaugh2.Eta(),fMomDaugh2.Phi(),fIsoDetector);
4549             //printf("D2 fidcut %d\n",d2Acc);
4550
4551             Float_t phiDaugh2 = fMomDaugh2.Phi();
4552             if(phiDaugh2 < 0) phiDaugh2+=TMath::TwoPi();
4553             dRdaugh2 = GetIsolationCut()->Radius(photonEta, photonPhi, fMomDaugh2.Eta(),phiDaugh2);
4554
4555             // Opening angle, check if pairs will likely overlap
4556             d12Angle = fMomDaugh1.Angle(fMomDaugh2.Vect());
4557             if(d12Angle > overlapAngle) overlap = kFALSE;
4558
4559           }
4560         }
4561       }
4562
4563       //printf("Check mother of label %d: mom label %d, okmom %d ndaugh %d, daugh label1 %d, label2 %d, ok1 %d, ok2 %d, R %2.3f, opening angle %2.3f, overlap %d\n",
4564       //       i, pi0label,okpi0,ndaugh,d1Label,d2Label,ok1,ok2, dRdaugh2, d12Angle, overlap);
4565
4566       // Second decay out of cone
4567       if(dRdaugh2 > GetIsolationCut()->GetConeSize())
4568         fhPtPrimMCPi0DecayPairOutOfCone->Fill(photonPt);
4569
4570       // Second decay out of acceptance
4571       if(!ok2 || !d2Acc || fMomDaugh2.E() <= minECalo)
4572       {
4573         fhPtPrimMCPi0DecayPairOutOfAcceptance->Fill(photonPt);
4574         if(!overlap) fhPtPrimMCPi0DecayPairOutOfAcceptanceNoOverlap->Fill(photonPt);
4575       }
4576
4577       // Not Overlapped decay
4578       if(!overlap) fhPtPrimMCPi0DecayPairNoOverlap->Fill(photonPt);
4579
4580       // Second decay pt smaller than threshold
4581       if(d2Acc && dRdaugh2 < GetIsolationCut()->GetConeSize() &&
4582          fMomDaugh2.E() < GetIsolationCut()->GetPtThreshold())
4583       {
4584         fhPtPrimMCPi0DecayPairAcceptInConeLowPt->Fill(photonPt);
4585         if(!overlap)
4586         {
4587           fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlap->Fill(photonPt);
4588           if(fMomDaugh2.E() > minECalo) fhPtPrimMCPi0DecayPairAcceptInConeLowPtNoOverlapCaloE->Fill(photonPt);
4589         }
4590       }
4591     } // pi0 decay
4592
4593     if(mcIndex == kmcPrimPi0 && fMakePrimaryPi0DecayStudy && overlapPi0)
4594       fhPtPrimMCPi0Overlap->Fill(photonPt);
4595
4596     // Isolated?
4597     Bool_t isolated = kFALSE;
4598     if(GetIsolationCut()->GetICMethod() == AliIsolationCut::kSumPtIC   &&
4599        (sumPtInCone < GetIsolationCut()->GetSumPtThreshold() ||
4600         sumPtInCone > GetIsolationCut()->GetSumPtThresholdMax()))
4601       isolated = kTRUE;
4602
4603     if(GetIsolationCut()->GetICMethod() == AliIsolationCut::kPtThresIC &&
4604        npart == 0)
4605       isolated = kTRUE;
4606
4607     if(isolated)
4608     {
4609       fhPtPrimMCiso [mcIndex]      ->Fill(photonPt) ;
4610       fhPtPrimMCiso [kmcPrimPhoton]->Fill(photonPt) ;
4611       if(mcIndex == kmcPrimPi0Decay && fMakePrimaryPi0DecayStudy)
4612       {
4613         // Not Overlapped decay
4614         if(!overlap) fhPtPrimMCPi0DecayIsoPairNoOverlap->Fill(photonPt);
4615
4616         // Second decay out of cone
4617         if(dRdaugh2 > GetIsolationCut()->GetConeSize())
4618           fhPtPrimMCPi0DecayIsoPairOutOfCone->Fill(photonPt);
4619
4620         // Second decay out of acceptance
4621         if(!ok2 || !d2Acc || fMomDaugh2.E() <= minECalo)
4622         {
4623           fhPtPrimMCPi0DecayIsoPairOutOfAcceptance->Fill(photonPt);
4624           if(!overlap) fhPtPrimMCPi0DecayIsoPairOutOfAcceptanceNoOverlap->Fill(photonPt);
4625         }
4626
4627         // Second decay pt smaller than threshold
4628         if(d2Acc && dRdaugh2 < GetIsolationCut()->GetConeSize() &&
4629            fMomDaugh2.E() < GetIsolationCut()->GetPtThreshold())
4630         {
4631           fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPt->Fill(photonPt);
4632           if(!overlap)
4633           {
4634             fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlap->Fill(photonPt);
4635             if(fMomDaugh2.E() > minECalo) fhPtPrimMCPi0DecayIsoPairAcceptInConeLowPtNoOverlapCaloE->Fill(photonPt);
4636           }
4637         }
4638       }// pi0 decay
4639
4640       if(mcIndex == kmcPrimPi0 && fMakePrimaryPi0DecayStudy && overlapPi0)
4641         fhPtPrimMCPi0IsoOverlap->Fill(photonPt);
4642
4643     } // isolated
4644   }//loop on primaries
4645
4646   AliDebug(1,"End");
4647
4648 }
4649
4650
4651 //_____________________________________________________________________________________
4652 void  AliAnaParticleIsolation::MakeSeveralICAnalysis(AliAODPWG4ParticleCorrelation* ph,
4653                                                      Int_t mcIndex)
4654 {
4655
4656   //Isolation Cut Analysis for both methods and different pt cuts and cones
4657   Float_t ptC   = ph->Pt();
4658   Float_t etaC  = ph->Eta();
4659   Float_t phiC  = ph->Phi();
4660   if(phiC<0) phiC += TMath::TwoPi();
4661   Int_t   tag   = ph->GetTag();
4662
4663   Int_t   decayTag = 0;
4664   if(fFillTaggedDecayHistograms)
4665   {
4666     decayTag = ph->DecayTag();
4667     if(decayTag < 0) decayTag = 0;
4668   }
4669
4670   AliDebug(1,Form("Isolate pT %2.2f, decay tag %d",ptC, decayTag));
4671
4672   //Keep original setting used when filling AODs, reset at end of analysis
4673   Float_t ptthresorg = GetIsolationCut()->GetPtThreshold();
4674   Float_t ptfracorg  = GetIsolationCut()->GetPtFraction();
4675   Float_t ptsumcorg  = GetIsolationCut()->GetSumPtThreshold();
4676   Float_t rorg       = GetIsolationCut()->GetConeSize();
4677
4678   Float_t coneptsum = 0, coneptlead = 0;
4679   Int_t   n    [10][10];//[fNCones][fNPtThresFrac];
4680   Int_t   nfrac[10][10];//[fNCones][fNPtThresFrac];
4681   Bool_t  isolated  = kFALSE;
4682
4683   // Fill hist with all particles before isolation criteria
4684   fhENoIso     ->Fill(ph->E());
4685   fhPtNoIso    ->Fill(ptC);
4686   fhEtaPhiNoIso->Fill(etaC,phiC);
4687
4688   if(IsDataMC())
4689   {
4690     if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4691       fhPtNoIsoMC[kmcPhoton]->Fill(ptC);
4692
4693     if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==kmcPi0Decay )
4694       fhPtNoIsoMC[kmcPi0DecayLostPair]->Fill(ptC);
4695
4696     fhPtNoIsoMC[mcIndex]->Fill(ptC);
4697   }
4698
4699   // Candidates tagged as decay in another analysis (AliAnaPi0EbE)
4700   if(fFillTaggedDecayHistograms && decayTag > 0)
4701   {
4702     for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
4703     {
4704       if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
4705       {
4706         fhPtDecay    [0][ibit]->Fill(ptC);
4707         fhEtaPhiDecay[0][ibit]->Fill(etaC,phiC);
4708
4709         if(IsDataMC())
4710         {
4711           if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4712             fhPtDecayMC[0][ibit][kmcPhoton]->Fill(ptC);
4713
4714           if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==kmcPi0Decay )
4715             fhPtDecayMC[0][ibit][kmcPi0DecayLostPair]->Fill(ptC);
4716
4717           fhPtDecayMC[0][ibit][mcIndex]->Fill(ptC);
4718         }
4719       } // bit ok
4720     } // bit loop
4721   } // decay histograms
4722
4723   //Get vertex for photon momentum calculation
4724   Double_t vertex[] = {0,0,0} ; //vertex ;
4725   if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
4726     GetReader()->GetVertex(vertex);
4727
4728   //Loop on cone sizes
4729   for(Int_t icone = 0; icone<fNCones; icone++)
4730   {
4731     //Recover reference arrays with clusters and tracks
4732     TObjArray * refclusters = ph->GetObjArray(GetAODObjArrayName()+"Clusters");
4733     TObjArray * reftracks   = ph->GetObjArray(GetAODObjArrayName()+"Tracks");
4734
4735     //If too small or too large pt, skip
4736     if(ptC < GetMinPt() || ptC > GetMaxPt() ) continue ;
4737
4738     //In case a more strict IC is needed in the produced AOD
4739
4740     isolated = kFALSE; coneptsum = 0; coneptlead = 0;
4741
4742     GetIsolationCut()->SetSumPtThreshold(100);
4743     GetIsolationCut()->SetPtThreshold(100);
4744     GetIsolationCut()->SetPtFraction(100);
4745     GetIsolationCut()->SetConeSize(fConeSizes[icone]);
4746
4747     // retreive pt tracks to fill histo vs. pt leading
4748     //Fill pt distribution of particles in cone
4749     //fhPtLeadingPt(),fhPerpSumPtLeadingPt(),fhPerpPtLeadingPt(),
4750
4751     // Tracks in perpendicular cones
4752     Double_t sumptPerp = 0. ;
4753     TObjArray * trackList   = GetCTSTracks() ;
4754     for(Int_t itrack=0; itrack < trackList->GetEntriesFast(); itrack++)
4755     {
4756       AliVTrack* track = (AliVTrack *) trackList->At(itrack);
4757       //fill the histograms at forward range
4758       if(!track)
4759       {
4760         AliDebug(1,"Track not available?");
4761         continue;
4762       }
4763
4764       Double_t dPhi = phiC - track->Phi() + TMath::PiOver2();
4765       Double_t dEta = etaC - track->Eta();
4766       Double_t arg  = dPhi*dPhi + dEta*dEta;
4767       if(TMath::Sqrt(arg) < fConeSizes[icone])
4768       {
4769         fhPerpPtLeadingPt[icone]->Fill(ptC,TMath::Sqrt(track->Px()*track->Px()+track->Py()*track->Py()));
4770         sumptPerp+=track->Pt();
4771       }
4772
4773       dPhi = phiC - track->Phi() - TMath::PiOver2();
4774       arg  = dPhi*dPhi + dEta*dEta;
4775       if(TMath::Sqrt(arg) < fConeSizes[icone])
4776       {
4777         fhPerpPtLeadingPt[icone]->Fill(ptC,TMath::Sqrt(track->Px()*track->Px()+track->Py()*track->Py()));
4778         sumptPerp+=track->Pt();
4779       }
4780     }
4781
4782     fhPerpSumPtLeadingPt[icone]->Fill(ptC,sumptPerp);
4783
4784     // Tracks in isolation cone, pT distribution and sum
4785     if(reftracks && GetIsolationCut()->GetParticleTypeInCone()!= AliIsolationCut::kOnlyNeutral)
4786     {
4787       for(Int_t itrack=0; itrack < reftracks->GetEntriesFast(); itrack++)
4788       {
4789         AliVTrack* track = (AliVTrack *) reftracks->At(itrack);
4790
4791         Float_t rad = GetIsolationCut()->Radius(etaC, phiC, track->Eta(), track->Phi());
4792
4793         if(rad > fConeSizes[icone]) continue ;
4794
4795         fhPtLeadingPt[icone]->Fill(ptC, track->Pt());
4796         coneptsum += track->Pt();
4797       }
4798     }
4799
4800     // Clusters in isolation cone, pT distribution and sum
4801     if(refclusters && GetIsolationCut()->GetParticleTypeInCone()!= AliIsolationCut::kOnlyCharged)
4802     {
4803       for(Int_t icalo=0; icalo < refclusters->GetEntriesFast(); icalo++)
4804       {
4805         AliVCluster* calo = (AliVCluster *) refclusters->At(icalo);
4806
4807         calo->GetMomentum(fMomentum,vertex) ;//Assume that come from vertex in straight line
4808
4809         Float_t rad = GetIsolationCut()->Radius(etaC, phiC, fMomentum.Eta(), fMomentum.Phi());
4810
4811         if(rad > fConeSizes[icone]) continue ;
4812
4813         fhPtLeadingPt[icone]->Fill(ptC, fMomentum.Pt());
4814         coneptsum += fMomentum.Pt();
4815       }
4816     }
4817
4818     fhSumPtLeadingPt[icone]->Fill(ptC,coneptsum);
4819
4820     if(IsDataMC())
4821     {
4822       if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4823         fhSumPtLeadingPtMC[kmcPhoton][icone]->Fill(ptC,coneptsum) ;
4824
4825       if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==kmcPi0Decay )
4826         fhSumPtLeadingPtMC[kmcPi0DecayLostPair][icone]->Fill(ptC,coneptsum) ;
4827
4828       fhSumPtLeadingPtMC[mcIndex][icone]->Fill(ptC,coneptsum) ;
4829     }
4830
4831     ///////////////////
4832
4833     //Loop on pt thresholds
4834     for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
4835     {
4836       n    [icone][ipt]=0;
4837       nfrac[icone][ipt]=0;
4838       GetIsolationCut()->SetPtThreshold(fPtThresholds[ipt]);
4839       GetIsolationCut()->SetPtFraction(fPtFractions[ipt]) ;
4840       GetIsolationCut()->SetSumPtThreshold(fSumPtThresholds[ipt]);
4841
4842       GetIsolationCut()->MakeIsolationCut(reftracks, refclusters,
4843                                           GetReader(), GetCaloPID(),
4844                                           kFALSE, ph, "",
4845                                           n[icone][ipt],nfrac[icone][ipt],
4846                                           coneptsum, coneptlead, isolated);
4847
4848       // Normal pT threshold cut
4849
4850       AliDebug(1,Form("Cone size %1.1f, ptThres  %1.1f, sumptThresh  %1.1f",fConeSizes[icone],fPtThresholds[ipt],fSumPtThresholds[ipt]));
4851       AliDebug(1,Form("\t n %d, nfrac %d, coneptsum %2.2f",n[icone][ipt],nfrac[icone][ipt],coneptsum));
4852       AliDebug(1,Form("pt %1.1f, eta %1.1f, phi %1.1f",ptC, etaC, phiC));
4853
4854       if(n[icone][ipt] == 0)
4855       {
4856         AliDebug(1,"Filling pt threshold loop");
4857
4858         fhPtThresIsolated [icone][ipt]->Fill(ptC);
4859         fhEtaPhiPtThresIso[icone][ipt]->Fill(etaC,phiC);
4860
4861         if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
4862         {
4863           if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
4864           {
4865             fhPtPtThresDecayIso    [icone][ipt]->Fill(ptC);
4866             fhEtaPhiPtThresDecayIso[icone][ipt]->Fill(etaC,phiC);
4867           }
4868         }
4869
4870         if(IsDataMC())
4871         {
4872           if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) )
4873             fhPtThresIsolatedMC[kmcPhoton][icone][ipt]->Fill(ptC) ;
4874
4875           if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==kmcPi0Decay )
4876             fhPtThresIsolatedMC[kmcPi0DecayLostPair][icone][ipt]->Fill(ptC) ;
4877
4878           fhPtThresIsolatedMC[mcIndex][icone][ipt]->Fill(ptC) ;
4879
4880         }
4881       }
4882
4883       // pt in cone fraction
4884       if(nfrac[icone][ipt] == 0)
4885       {
4886         AliDebug(1,"Filling frac loop");
4887
4888         fhPtFracIsolated [icone][ipt]->Fill(ptC);
4889         fhEtaPhiPtFracIso[icone][ipt]->Fill(etaC,phiC);
4890
4891         if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
4892         {
4893           if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
4894           {
4895             fhPtPtFracDecayIso    [icone][ipt]->Fill(ptC);
4896             fhEtaPhiPtFracDecayIso[icone][ipt]->Fill(etaC,phiC);
4897           }
4898         }
4899
4900         if(IsDataMC())
4901         {
4902           if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4903             fhPtFracIsolatedMC[kmcPhoton][icone][ipt]->Fill(ptC) ;
4904
4905           if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==kmcPi0Decay )
4906             fhPtFracIsolatedMC[kmcPi0DecayLostPair][icone][ipt]->Fill(ptC) ;
4907
4908           fhPtFracIsolatedMC[mcIndex][icone][ipt]->Fill(ptC) ;
4909         }
4910       }
4911
4912       AliDebug(1,Form("Checking IC method : %i",GetIsolationCut()->GetICMethod()));
4913
4914       //Pt threshold on pt cand/ sum in cone histograms
4915       if(coneptsum < fSumPtThresholds[ipt])
4916       {
4917         AliDebug(1,"Filling sum loop");
4918
4919         fhSumPtIsolated [icone][ipt]->Fill(ptC) ;
4920         fhEtaPhiPtSumIso[icone][ipt]->Fill(etaC, phiC) ;
4921
4922         if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
4923         {
4924           if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
4925           {
4926             fhPtPtSumDecayIso[icone][ipt]->Fill(ptC);
4927             fhEtaPhiPtSumDecayIso[icone][ipt]->Fill(etaC, phiC) ;
4928           }
4929         }
4930
4931         if(IsDataMC())
4932         {
4933           if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4934             fhSumPtIsolatedMC[kmcPhoton][icone][ipt]->Fill(ptC) ;
4935
4936           if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==kmcPi0Decay )
4937             fhSumPtIsolatedMC[kmcPi0DecayLostPair][icone][ipt]->Fill(ptC) ;
4938
4939           fhSumPtIsolatedMC[mcIndex][icone][ipt]->Fill(ptC) ;
4940         }
4941       }
4942
4943       // pt sum pt frac method
4944       //    if( ((fPtFractions[ipt]*ptC < fSumPtThresholds[ipt]) && (coneptsum < fSumPtThresholds[ipt])) || ((fPtFractions[ipt]*ptC > fSumPtThresholds[ipt]) && (coneptsum < fPtFractions[ipt]*ptC)) )
4945
4946       if(coneptsum < fPtFractions[ipt]*ptC)
4947       {
4948         AliDebug(1,"Filling PtFrac PtSum loop");
4949
4950         fhPtFracPtSumIso    [icone][ipt]->Fill(ptC) ;
4951         fhEtaPhiFracPtSumIso[icone][ipt]->Fill(etaC,phiC) ;
4952
4953         if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
4954         {
4955           if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
4956           {
4957             fhPtFracPtSumDecayIso    [icone][ipt]->Fill(ptC);
4958             fhEtaPhiFracPtSumDecayIso[icone][ipt]->Fill(etaC,phiC);
4959           }
4960         }
4961       }
4962
4963       // density method
4964       Float_t cellDensity = GetIsolationCut()->GetCellDensity( ph, GetReader());
4965       if(coneptsum < fSumPtThresholds[ipt]*cellDensity)
4966       {
4967         AliDebug(1,"Filling density loop");
4968
4969         fhPtSumDensityIso    [icone][ipt]->Fill(ptC) ;
4970         fhEtaPhiSumDensityIso[icone][ipt]->Fill(etaC,phiC) ;
4971
4972         if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
4973         {
4974           if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
4975           {
4976             fhPtSumDensityDecayIso    [icone][ipt]->Fill(ptC);
4977             fhEtaPhiSumDensityDecayIso[icone][ipt]->Fill(etaC, phiC);
4978           }
4979         }
4980       }
4981     }//pt thresh loop
4982
4983
4984   }//cone size loop
4985
4986   //Reset original parameters for AOD analysis
4987   GetIsolationCut()->SetPtThreshold(ptthresorg);
4988   GetIsolationCut()->SetPtFraction(ptfracorg);
4989   GetIsolationCut()->SetSumPtThreshold(ptsumcorg);
4990   GetIsolationCut()->SetConeSize(rorg);
4991
4992 }
4993
4994 //_____________________________________________________________
4995 void AliAnaParticleIsolation::Print(const Option_t * opt) const
4996 {
4997
4998   //Print some relevant parameters set for the analysis
4999   if(! opt)
5000     return;
5001
5002   printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
5003   AliAnaCaloTrackCorrBaseClass::Print(" ");
5004
5005   printf("ReMake Isolation          = %d \n",  fReMakeIC) ;
5006   printf("Make Several Isolation    = %d \n",  fMakeSeveralIC) ;
5007   printf("Calorimeter for isolation = %s \n",  GetCalorimeterString().Data()) ;
5008   printf("Detector for candidate isolation = %s \n", fIsoDetectorString.Data()) ;
5009
5010   if(fMakeSeveralIC)
5011   {
5012     printf("N Cone Sizes       =     %d\n", fNCones) ;
5013     printf("Cone Sizes          =    \n") ;
5014     for(Int_t i = 0; i < fNCones; i++)
5015       printf("  %1.2f;",  fConeSizes[i]) ;
5016     printf("    \n") ;
5017
5018     printf("N pT thresholds/fractions = %d\n", fNPtThresFrac) ;
5019     printf(" pT thresholds         =    \n") ;
5020     for(Int_t i = 0; i < fNPtThresFrac; i++)
5021       printf("   %2.2f;",  fPtThresholds[i]) ;
5022
5023     printf("    \n") ;
5024
5025     printf(" pT fractions         =    \n") ;
5026     for(Int_t i = 0; i < fNPtThresFrac; i++)
5027       printf("   %2.2f;",  fPtFractions[i]) ;
5028
5029     printf("    \n") ;
5030
5031     printf("sum pT thresholds         =    \n") ;
5032     for(Int_t i = 0; i < fNPtThresFrac; i++)
5033       printf("   %2.2f;",  fSumPtThresholds[i]) ;
5034
5035
5036   }
5037
5038   printf("    \n") ;
5039
5040 }
5041
5042 //_____________________________________________________________
5043 void AliAnaParticleIsolation::SetTriggerDetector(TString & det)
5044 {
5045   // Set the detrimeter for the analysis
5046
5047   fIsoDetectorString = det;
5048
5049   if     (det=="EMCAL") fIsoDetector = kEMCAL;
5050   else if(det=="PHOS" ) fIsoDetector = kPHOS;
5051   else if(det=="CTS")   fIsoDetector = kCTS;
5052   else if(det=="DCAL")  fIsoDetector = kDCAL;
5053   else if(det.Contains("DCAL") && det.Contains("PHOS")) fIsoDetector = kDCALPHOS;
5054   else AliFatal(Form("Detector < %s > not known!", det.Data()));
5055
5056 }
5057
5058 //_________________________________________________________
5059 void AliAnaParticleIsolation::SetTriggerDetector(Int_t det)
5060 {
5061   // Set the detrimeter for the analysis
5062
5063   fIsoDetector = det;
5064
5065   if     (det==kEMCAL)    fIsoDetectorString = "EMCAL";
5066   else if(det==kPHOS )    fIsoDetectorString = "PHOS";
5067   else if(det==kCTS)      fIsoDetectorString = "CTS";
5068   else if(det==kDCAL)     fIsoDetectorString = "DCAL";
5069   else if(det==kDCALPHOS) fIsoDetectorString = "DCAL_PHOS";
5070   else AliFatal(Form("Detector < %d > not known!", det));
5071
5072 }
5073