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