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