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