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