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