]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/CaloTrackCorrelations/AliAnaParticleHadronCorrelation.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fix compilation warning
[u/mrichter/AliRoot.git] / PWGGA / CaloTrackCorrelations / AliAnaParticleHadronCorrelation.cxx
CommitLineData
e09cf5ef 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 is 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 **************************************************************************/
e09cf5ef 15
16//_________________________________________________________________________
17// Class for the analysis of particle - hadron correlations
18// Particle (for example direct gamma) must be found in a previous analysis
19//-- Author: Gustavo Conesa (LNF-INFN)
20
21// Modified by Yaxian Mao:
22// 1. add the UE subtraction for corrlation study
23// 2. change the correlation variable
24// 3. Only use leading particle(cluster/track) as trigger for correlation (2010/07/02)
25// 4. Make decay photon-hadron correlations where decay contribute pi0 mass (2010/09/09)
26// 5. fill the pout to extract kt at the end, also to study charge asymmetry(2010/10/06)
045396c8 27// 6. Add the possibility for event selection analysis based on vertex and multiplicity bins (10/10/2010)
28// 7. change the way of delta phi cut for UE study due to memory issue (reduce histograms)
29// 8. Add the possibility to request the absolute leading particle at the near side or not, set trigger bins, general clean-up (08/2011)
e09cf5ef 30//////////////////////////////////////////////////////////////////////////////
31
32
33// --- ROOT system ---
34//#include "TClonesArray.h"
907b38cd 35#include <TClass.h>
36#include <TMath.h>
37#include <TH2F.h>
38#include <TDatabasePDG.h>
e09cf5ef 39
40//---- ANALYSIS system ----
41#include "AliNeutralMesonSelection.h"
42#include "AliAnaParticleHadronCorrelation.h"
43#include "AliCaloTrackReader.h"
e09cf5ef 44#include "AliAODPWG4ParticleCorrelation.h"
45#include "AliFiducialCut.h"
46#include "AliVTrack.h"
47#include "AliVCluster.h"
48#include "AliMCAnalysisUtils.h"
49#include "TParticle.h"
50#include "AliStack.h"
51#include "AliAODMCParticle.h"
52#include "AliMixedEvent.h"
029dea5a 53#include "AliAnalysisManager.h"
54#include "AliInputEventHandler.h"
2e876d85 55#include "AliEventplane.h"
e09cf5ef 56
57ClassImp(AliAnaParticleHadronCorrelation)
58
59
05d0d05d 60//___________________________________________________________________
e09cf5ef 61 AliAnaParticleHadronCorrelation::AliAnaParticleHadronCorrelation():
745913ae 62 AliAnaCaloTrackCorrBaseClass(),
66e64043 63 fMinTriggerPt(0.),
64 fMaxAssocPt(1000.), fMinAssocPt(0.),
05d0d05d 65 fDeltaPhiMaxCut(0.), fDeltaPhiMinCut(0.),
66 fSelectIsolated(0), fMakeSeveralUE(0),
67 fUeDeltaPhiMaxCut(0.), fUeDeltaPhiMinCut(0.),
68 fPi0AODBranchName(""), fNeutralCorr(0),
907b38cd 69 fPi0Trigger(0), fDecayTrigger(0),
3f150b4b 70 fMakeAbsoluteLeading(0), fMakeNearSideLeading(0),
907b38cd 71 fLeadingTriggerIndex(-1), fHMPIDCorrelation(0), fFillBradHisto(0),
05d0d05d 72 fNAssocPtBins(0), fAssocPtBinLimit(),
7d306daf 73 fCorrelVzBin(0),
2bb7ac98 74 fListMixTrackEvents(), fListMixCaloEvents(),
75 fUseMixStoredInReader(0), fFillNeutralEventMixPool(0),
b1f720a7 76 fM02MaxCut(0), fM02MinCut(0),
560498d1 77 fFillPileUpHistograms(0),
05d0d05d 78 //Histograms
7d306daf 79 fhPtInput(0), fhPtFidCut(0),
cc944149 80 fhPtLeading(0), fhPtLeadingVtxBC0(0),
b1f720a7 81 fhPtLeadingVzBin(0), fhPtLeadingBin(0),
764ab1f4 82 fhPhiLeading(0), fhEtaLeading(0),
83 fhPtLeadingMC(),
68cd2624 84 fhPtLeadingCentrality(0), fhPtLeadingEventPlane(0),
d0b625bc 85 fhLeadingEventPlaneCentrality(0),
7d306daf 86 fhPtLeadingMixed(0), fhPtLeadingMixedVzBin(0), fhPtLeadingMixedBin(0),
d0b625bc 87 fhPhiLeadingMixed(0), fhEtaLeadingMixed(0),
88 fhDeltaPhiDeltaEtaCharged(0),
05d0d05d 89 fhPhiCharged(0), fhEtaCharged(0),
90 fhDeltaPhiCharged(0), fhDeltaEtaCharged(0),
91 fhDeltaPhiChargedPt(0), fhDeltaPhiUeChargedPt(0),
9623bf34 92 fhUePart(0),
3f150b4b 93 fhXECharged(0), fhXEUeCharged(0),
94 fhXEPosCharged(0), fhXENegCharged(0),
95 fhPtHbpXECharged(0), fhPtHbpXEUeCharged(0),
96 fhZTCharged(0), fhZTUeCharged(0),
97 fhZTPosCharged(0), fhZTNegCharged(0),
98 fhPtHbpZTCharged(0), fhPtHbpZTUeCharged(0),
b1f720a7 99 fhXEChargedMC(), fhDeltaPhiChargedMC(),
100 fhDeltaPhiDeltaEtaChargedPtA3GeV(0),
101 fhDeltaPhiChargedPtA3GeV(0), fhDeltaEtaChargedPtA3GeV(0),
102 //Pile-Up
17af6e24 103 fhDeltaPhiChargedPileUp(), fhDeltaEtaChargedPileUp(),
fedea415 104 fhDeltaPhiChargedPtA3GeVPileUp(), fhDeltaEtaChargedPtA3GeVPileUp(),
105 fhXEChargedPileUp(), fhXEUeChargedPileUp(),
17af6e24 106 fhZTChargedPileUp(), fhZTUeChargedPileUp(),
107 fhPtTrigChargedPileUp(),
fedea415 108 fhDeltaPhiChargedOtherBC(), fhDeltaPhiChargedPtA3GeVOtherBC(),
109 fhXEChargedOtherBC(), fhXEUeChargedOtherBC(),
110 fhZTChargedOtherBC(), fhZTUeChargedOtherBC(),
111 fhPtTrigChargedOtherBC(),
2a9171b5 112 fhDeltaPhiChargedBC0(), fhDeltaPhiChargedPtA3GeVBC0(),
113 fhXEChargedBC0(), fhXEUeChargedBC0(),
114 fhZTChargedBC0(), fhZTUeChargedBC0(),
115 fhPtTrigChargedBC0(),
cc944149 116 fhDeltaPhiChargedVtxBC0(), fhDeltaPhiChargedPtA3GeVVtxBC0(),
117 fhXEChargedVtxBC0(), fhXEUeChargedVtxBC0(),
118 fhZTChargedVtxBC0(), fhZTUeChargedVtxBC0(),
119 fhPtTrigChargedVtxBC0(),
05d0d05d 120 fhDeltaPhiUeLeftCharged(0), fhDeltaPhiUeRightCharged(0),
8cc41381 121 fhDeltaPhiUeLeftUpCharged(0), fhDeltaPhiUeRightUpCharged(0),
122 fhDeltaPhiUeLeftDownCharged(0), fhDeltaPhiUeRightDownCharged(0),
3f150b4b 123 fhXEUeLeftCharged(0), fhXEUeRightCharged(0),
8cc41381 124 fhXEUeLeftUpCharged(0), fhXEUeRightUpCharged(0),
125 fhXEUeLeftDownCharged(0), fhXEUeRightDownCharged(0),
3f150b4b 126 fhPtHbpXEUeLeftCharged(0), fhPtHbpXEUeRightCharged(0),
127 fhZTUeLeftCharged(0), fhZTUeRightCharged(0),
128 fhPtHbpZTUeLeftCharged(0), fhPtHbpZTUeRightCharged(0),
05d0d05d 129 fhPtTrigPout(0), fhPtTrigCharged(0),
130 fhTrigDeltaPhiCharged(0x0), fhTrigDeltaEtaCharged(0x0),
3f150b4b 131 fhTrigXECorr(0x0), fhTrigXEUeCorr(0x0),
132 fhTrigZTCorr(0x0), fhTrigZTUeCorr(0x0),
8cc41381 133 fhAssocPtBkg(0), fhDeltaPhiDeltaEtaAssocPtBin(0),
134 fhDeltaPhiAssocPtBin(0),
135 fhDeltaPhiAssocPtBinDEta08(0), fhDeltaPhiAssocPtBinDEta0(0),
2013f378 136 fhDeltaPhiAssocPtBinHMPID(0), fhDeltaPhiAssocPtBinHMPIDAcc(0),
66e64043 137 fhDeltaPhiBradAssocPtBin(0), fhDeltaPhiBrad(0),
907b38cd 138 fhXEAssocPtBin(0), fhZTAssocPtBin(0),
e09cf5ef 139 fhDeltaPhiDeltaEtaNeutral(0),
05d0d05d 140 fhPhiNeutral(0), fhEtaNeutral(0),
141 fhDeltaPhiNeutral(0), fhDeltaEtaNeutral(0),
142 fhDeltaPhiNeutralPt(0), fhDeltaPhiUeNeutralPt(0),
3f150b4b 143 fhXENeutral(0), fhXEUeNeutral(0),
144 fhPtHbpXENeutral(0), fhPtHbpXEUeNeutral(0),
145 fhZTNeutral(0), fhZTUeNeutral(0),
146 fhPtHbpZTNeutral(0), fhPtHbpZTUeNeutral(0),
05d0d05d 147 fhDeltaPhiUeLeftNeutral(0), fhDeltaPhiUeRightNeutral(0),
3f150b4b 148 fhXEUeLeftNeutral(0), fhXEUeRightNeutral(0),
149 fhPtHbpXEUeLeftNeutral(0), fhPtHbpXEUeRightNeutral(0),
150 fhZTUeLeftNeutral(0), fhZTUeRightNeutral(0),
151 fhPtHbpZTUeLeftNeutral(0), fhPtHbpZTUeRightNeutral(0),
e09cf5ef 152 fhPtPi0DecayRatio(0),
3f150b4b 153 fhDeltaPhiDecayCharged(0), fhXEDecayCharged(0), fhZTDecayCharged(0),
154 fhDeltaPhiDecayNeutral(0), fhXEDecayNeutral(0), fhZTDecayNeutral(0),
907b38cd 155 fhDeltaPhiDecayChargedAssocPtBin(0),
156 fhXEDecayChargedAssocPtBin(0), fhZTDecayChargedAssocPtBin(0),
9623bf34 157 fh2phiLeadingParticle(0x0), fhMCPtLeading(0),
08f220c8 158 fhMCPhiLeading(0), fhMCEtaLeading(0),
05d0d05d 159 fhMCEtaCharged(0), fhMCPhiCharged(0),
160 fhMCDeltaEtaCharged(0), fhMCDeltaPhiCharged(0x0),
161 fhMCDeltaPhiDeltaEtaCharged(0), fhMCDeltaPhiChargedPt(0),
9623bf34 162 fhMCPtXECharged(0), fhMCPtXEUeCharged(0),
163 fhMCPtHbpXECharged(0), fhMCPtHbpXEUeCharged(0),
164 fhMCUePart(0),
3f150b4b 165 fhMCPtZTCharged(0), fhMCPtHbpZTCharged(0),
029dea5a 166 fhMCPtTrigPout(0), fhMCPtAssocDeltaPhi(0),
167 //Mixing
31864468 168 fhNEventsTrigger(0), fhNtracksMB(0), fhNclustersMB(0),
029dea5a 169 fhMixDeltaPhiCharged(0), fhMixDeltaPhiDeltaEtaCharged(0),
18838011 170 fhMixXECharged(0), fhMixXEUeCharged(0), fhMixHbpXECharged(0),
2013f378 171 fhMixDeltaPhiChargedAssocPtBin(),
172 fhMixDeltaPhiChargedAssocPtBinDEta08(),
8cc41381 173 fhMixDeltaPhiChargedAssocPtBinDEta0(),
2013f378 174 fhMixDeltaPhiDeltaEtaChargedAssocPtBin(),
68cd2624 175 fhEventBin(0), fhEventMixBin(0)
029dea5a 176{
8cc41381 177 //Default Ctor
029dea5a 178
e09cf5ef 179 //Initialize parameters
180 InitParameters();
764ab1f4 181
b1f720a7 182 for(Int_t i = 0; i < 7; i++)
764ab1f4 183 {
184 fhPtLeadingMC[i] = 0;
185 fhXEChargedMC[i] = 0;
b1f720a7 186 fhDeltaPhiChargedMC[i] = 0;
764ab1f4 187 }
188
17af6e24 189 for(Int_t i = 0; i < 7; i++)
190 {
191 fhPtLeadingPileUp [i] = 0 ;
192 fhDeltaPhiChargedPileUp [i] = 0 ; fhDeltaEtaChargedPileUp [i] = 0 ;
193 fhXEChargedPileUp [i] = 0 ; fhXEUeChargedPileUp [i] = 0 ;
194 fhZTChargedPileUp [i] = 0 ; fhZTUeChargedPileUp [i] = 0 ;
195 fhPtTrigChargedPileUp [i] = 0 ;
196 fhDeltaPhiChargedPtA3GeVPileUp[i] = 0 ; fhDeltaEtaChargedPtA3GeVPileUp[i] = 0 ;
17af6e24 197 }
198
e09cf5ef 199}
200
029dea5a 201//_________________________________________________________________
2bb7ac98 202AliAnaParticleHadronCorrelation::~AliAnaParticleHadronCorrelation()
029dea5a 203{
204 // Remove event containers
205
d07ffd54 206 if(DoOwnMix())
207 {
208 if(fListMixTrackEvents)
209 {
210 for(Int_t iz=0; iz < GetNZvertBin(); iz++)
029dea5a 211 {
d07ffd54 212 for(Int_t ic=0; ic < GetNCentrBin(); ic++)
213 {
214 for(Int_t irp=0; irp<GetNRPBin(); irp++)
215 {
216 Int_t bin = GetEventMixBin(ic, iz, irp);
217 fListMixTrackEvents[bin]->Delete() ;
218 delete fListMixTrackEvents[bin] ;
219 }
220 }
029dea5a 221 }
222 }
d07ffd54 223
224 delete[] fListMixTrackEvents;
225
226 if(fListMixCaloEvents)
227 {
228 for(Int_t iz=0; iz < GetNZvertBin(); iz++)
229 {
230 for(Int_t ic=0; ic < GetNCentrBin(); ic++)
231 {
232 for(Int_t irp=0; irp<GetNRPBin(); irp++)
233 {
234 Int_t bin = GetEventMixBin(ic, iz, irp);
235 fListMixCaloEvents[bin]->Delete() ;
236 delete fListMixCaloEvents[bin] ;
237 }
238 }
239 }
240 }
241
242 delete[] fListMixCaloEvents;
029dea5a 243
244 }
245}
246
907b38cd 247//______________________________________________________________________________________________________________________________________________________
22ad7981 248void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(Float_t ptAssoc, Float_t ptTrig, Int_t bin,
249 Float_t phiAssoc, Float_t phiTrig, Float_t & deltaPhi,
250 Float_t etaAssoc, Float_t etaTrig,
251 Bool_t decay, Float_t hmpidSignal, Int_t outTOF,
252 Int_t nTracks, Int_t mcTag)
907b38cd 253{
254 // Fill angular correlation related histograms
255
256 Float_t deltaEta = etaTrig-etaAssoc;
257 deltaPhi = phiTrig-phiAssoc;
258 Float_t deltaPhiOrg = deltaPhi;
259
260 if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
261 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
262
b1f720a7 263 fhEtaCharged ->Fill(ptAssoc,etaAssoc);
264 fhPhiCharged ->Fill(ptAssoc,phiAssoc);
265 fhDeltaEtaCharged ->Fill(ptTrig ,deltaEta);
266 fhDeltaPhiCharged ->Fill(ptTrig ,deltaPhi);
267 fhDeltaPhiChargedPt->Fill(ptAssoc, deltaPhi);
268 fhDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta);
269
270 if(ptAssoc > 3 )
271 {
272 fhDeltaEtaChargedPtA3GeV ->Fill(ptTrig ,deltaEta);
273 fhDeltaPhiChargedPtA3GeV ->Fill(ptTrig ,deltaPhi);
274 fhDeltaPhiDeltaEtaChargedPtA3GeV->Fill(deltaPhi, deltaEta);
275 }
907b38cd 276
b1f720a7 277 // Pile up studies
17af6e24 278
279 if(fFillPileUpHistograms)
b1f720a7 280 {
2a9171b5 281 if (outTOF==1)
fedea415 282 {
560498d1 283 fhDeltaPhiChargedOtherBC->Fill(ptTrig ,deltaPhi) ;
fedea415 284 if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVOtherBC->Fill(ptTrig ,deltaPhi) ;
285 }
2a9171b5 286 else if(outTOF==0)
287 {
288 fhDeltaPhiChargedBC0->Fill(ptTrig ,deltaPhi) ;
289 if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVBC0->Fill(ptTrig ,deltaPhi) ;
290 }
fedea415 291
cc944149 292 Int_t vtxBC = GetReader()->GetVertexBC();
293 if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
294 {
295 fhDeltaPhiChargedVtxBC0->Fill(ptTrig ,deltaPhi) ;
296 if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVVtxBC0->Fill(ptTrig ,deltaPhi) ;
297 }
298
17af6e24 299 if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[0]->Fill(ptTrig ,deltaPhi) ; }
300 if(GetReader()->IsPileUpFromEMCal()) { fhDeltaEtaChargedPileUp[1]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[1]->Fill(ptTrig ,deltaPhi) ; }
301 if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhDeltaEtaChargedPileUp[2]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[2]->Fill(ptTrig ,deltaPhi) ; }
302 if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhDeltaEtaChargedPileUp[3]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[3]->Fill(ptTrig ,deltaPhi) ; }
303 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhDeltaEtaChargedPileUp[4]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[4]->Fill(ptTrig ,deltaPhi) ; }
304 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhDeltaEtaChargedPileUp[5]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[5]->Fill(ptTrig ,deltaPhi) ; }
305 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhDeltaEtaChargedPileUp[6]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[6]->Fill(ptTrig ,deltaPhi) ; }
306
b1f720a7 307 if(ptAssoc > 3 )
308 {
17af6e24 309 if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaPhi) ; }
310 if(GetReader()->IsPileUpFromEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[1]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[1]->Fill(ptTrig ,deltaPhi) ; }
311 if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[2]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[2]->Fill(ptTrig ,deltaPhi) ; }
312 if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[3]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[3]->Fill(ptTrig ,deltaPhi) ; }
313 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[4]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[4]->Fill(ptTrig ,deltaPhi) ; }
314 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhDeltaEtaChargedPtA3GeVPileUp[5]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[5]->Fill(ptTrig ,deltaPhi) ; }
315 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[6]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[6]->Fill(ptTrig ,deltaPhi) ; }
b1f720a7 316 }
317 }
318
319 if(IsDataMC())
320 {
321 Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
322 fhDeltaPhiChargedMC[mcIndex]->Fill(ptTrig , deltaPhi);
323 }
907b38cd 324
325 if(fDecayTrigger && decay) fhDeltaPhiDecayCharged ->Fill(ptTrig , deltaPhi);
326
327 Double_t dphiBrad = -100;
328 if(fFillBradHisto)
329 {
330 dphiBrad = atan2(sin(deltaPhiOrg), cos(deltaPhiOrg))/TMath::Pi();//-1 to 1
331 if(TMath::Abs(dphiBrad)>0.325 && TMath::Abs(dphiBrad)<0.475) //Hardcoded values, BAD, FIXME
332 {
333 fhAssocPtBkg->Fill(ptTrig, ptAssoc);
334 }
335
336 if(dphiBrad<-1./3) dphiBrad += 2;
337 fhDeltaPhiBrad->Fill(ptTrig, dphiBrad);
338 }
339
340 // Fill histograms in bins of associated particle pT
8cc41381 341 if(bin>=0)
907b38cd 342 {
8cc41381 343 fhDeltaPhiDeltaEtaAssocPtBin [bin]->Fill(deltaPhi,deltaEta);
344
345 fhDeltaPhiAssocPtBin [bin]->Fill(ptTrig, deltaPhi);
2013f378 346
347 if(TMath::Abs(deltaEta)> 0.8)
8cc41381 348 fhDeltaPhiAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi);
349
03a96401 350 if(TMath::Abs(deltaEta)< 0.01)
8cc41381 351 fhDeltaPhiAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi);
2013f378 352
353 if (fFillBradHisto)
8cc41381 354 fhDeltaPhiBradAssocPtBin [bin]->Fill(ptTrig, dphiBrad);
2013f378 355
356 if(fDecayTrigger && decay)
8cc41381 357 fhDeltaPhiDecayChargedAssocPtBin[bin]->Fill(ptTrig, deltaPhi);
907b38cd 358
359 if(fHMPIDCorrelation)
360 {
361 if( hmpidSignal > 0 )
362 {
363 //printf("Track pt %f with HMPID signal %f \n",pt,hmpidSignal);
8cc41381 364 fhDeltaPhiAssocPtBinHMPID[bin]->Fill(ptTrig, deltaPhi);
907b38cd 365 }
366
367 if(phiAssoc > 5*TMath::DegToRad() && phiAssoc < 20*TMath::DegToRad())
368 {
369 //printf("Track pt %f in HMPID acceptance phi %f \n ",pt,phi*TMath::RadToDeg() );
8cc41381 370 fhDeltaPhiAssocPtBinHMPIDAcc[bin]->Fill(ptTrig, deltaPhi);
907b38cd 371 }
372 }
373 }
374
375 //fill different multiplicity histogram
376 if(DoEventSelect())
377 {
378 for(Int_t im = 0; im<GetMultiBin(); im++)
379 {
380 if(nTracks < ( GetMaxMulti() - GetMinMulti() )/GetMultiBin()*(im+1))
381 {
382 fhTrigDeltaPhiCharged[im]->Fill(ptTrig,deltaPhi);
383 fhTrigDeltaEtaCharged[im]->Fill(ptTrig,deltaEta);
384 }
385 }
386 }
387}
388
389//____________________________________________________________________________________________________________________________________________________
22ad7981 390Bool_t AliAnaParticleHadronCorrelation::FillChargedMCCorrelationHistograms(Float_t mcAssocPt, Float_t mcAssocPhi, Float_t mcAssocEta,
391 Float_t mcTrigPt, Float_t mcTrigPhi, Float_t mcTrigEta)
907b38cd 392{
393 // Fill MC histograms independently of AOD or ESD
394
395 //Select only hadrons in pt range
396 if(mcAssocPt < fMinAssocPt || mcAssocPt > fMaxAssocPt) return kTRUE ; // exclude but continue
397
398 if(mcAssocPhi < 0) mcAssocPhi+=TMath::TwoPi();
399
400 //remove trigger itself for correlation when use charged triggers
401 if(TMath::Abs(mcAssocPt -mcTrigPt ) < 1e-6 &&
402 TMath::Abs(mcAssocPhi-mcTrigPhi) < 1e-6 &&
403 TMath::Abs(mcAssocEta-mcTrigEta) < 1e-6) return kTRUE ; // exclude but continue
404
405 // Absolute leading?
406 if( fMakeAbsoluteLeading && mcAssocPt > mcTrigPt ) return kFALSE; // jump event
407
408 //jump out this event if near side associated partile pt larger than trigger
409 if( fMakeNearSideLeading && mcAssocPt > mcTrigPt &&
410 TMath::Abs(mcAssocPhi-mcTrigPhi)<TMath::PiOver2() ) return kFALSE; // jump event
411
412 Float_t mcdeltaPhi= mcTrigPhi-mcAssocPhi;
413 if(mcdeltaPhi <= -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi();
414 if(mcdeltaPhi > 3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi();
415
416 Float_t mcxE =-mcAssocPt/mcTrigPt*TMath::Cos(mcdeltaPhi);// -(mcAssocPx*pxprim+mcAssocPy*pyprim)/(mcTrigPt*mcTrigPt);
417 Float_t mchbpXE =-100 ;
f16872ec 418 if(mcxE > 0 ) mchbpXE = TMath::Log(1./mcxE);
907b38cd 419
420 Float_t mczT = mcAssocPt/mcTrigPt ;
421 Float_t mchbpZT =-100 ;
f16872ec 422 if(mczT > 0 ) mchbpZT = TMath::Log(1./mczT);
907b38cd 423
424 //Selection within angular range
425 if( mcdeltaPhi< -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi();
426 if( mcdeltaPhi>3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi();
427
428 Double_t mcpout = mcAssocPt*TMath::Sin(mcdeltaPhi) ;
429
430 if(GetDebug() > 0 )
431 printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation() - Charged hadron: track Pt %f, track Phi %f, phi trigger %f. Cuts: delta phi %2.2f < %2.2f < %2.2f, pT min %2.2f \n",
432 mcAssocPt,mcAssocPhi, mcTrigPhi,fDeltaPhiMinCut, mcdeltaPhi, fDeltaPhiMaxCut, GetMinPt());
433
434 // Fill Histograms
435 fhMCEtaCharged ->Fill(mcAssocPt, mcAssocEta);
436 fhMCPhiCharged ->Fill(mcAssocPt, mcAssocPhi);
437 fhMCDeltaEtaCharged->Fill(mcTrigPt, mcTrigEta-mcAssocEta);
438 fhMCDeltaPhiCharged->Fill(mcTrigPt, mcdeltaPhi);
439 fhMCPtAssocDeltaPhi->Fill(mcAssocPt, mcdeltaPhi);
440
441 fhMCDeltaPhiDeltaEtaCharged->Fill(mcdeltaPhi,mcTrigEta-mcAssocEta);
442
443 //delta phi cut for correlation
444 if( (mcdeltaPhi > fDeltaPhiMinCut) && (mcdeltaPhi < fDeltaPhiMaxCut) )
445 {
446 fhMCDeltaPhiChargedPt->Fill(mcAssocPt,mcdeltaPhi);
447 fhMCPtXECharged ->Fill(mcTrigPt,mcxE);
448 fhMCPtHbpXECharged ->Fill(mcTrigPt,mchbpXE);
449 fhMCPtZTCharged ->Fill(mcTrigPt,mczT);
450 fhMCPtHbpZTCharged ->Fill(mcTrigPt,mchbpZT);
451 fhMCPtTrigPout ->Fill(mcTrigPt, mcpout) ;
452 }
9623bf34 453
454 //underlying event
455 if ( (mcdeltaPhi > fUeDeltaPhiMinCut) && (mcdeltaPhi < fUeDeltaPhiMaxCut) )
456 {
457 Double_t randomphi = gRandom->Uniform(TMath::Pi()/2,3*TMath::Pi()/2);
458 Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi);
459
460 if(mcUexE < 0.) mcUexE = -mcUexE;
461
462 fhMCPtXEUeCharged->Fill(mcTrigPt,mcUexE);
463 if(mcUexE > 0) fhMCPtHbpXEUeCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE));
464
465 fhMCUePart->Fill(mcTrigPt);
466 }
907b38cd 467
468 return kTRUE;
469}
470
471//___________________________________________________________________________________________________________________
22ad7981 472void AliAnaParticleHadronCorrelation::FillChargedMomentumImbalanceHistograms(Float_t ptTrig, Float_t ptAssoc,
473 Float_t xE, Float_t hbpXE,
474 Float_t zT, Float_t hbpZT,
475 Float_t pout,
476 Int_t nTracks, Int_t charge,
477 Int_t bin, Bool_t decay,
478 Int_t outTOF, Int_t mcTag)
907b38cd 479
480{
481 // Fill mostly momentum imbalance related histograms
482
907b38cd 483 fhXECharged ->Fill(ptTrig , xE);
484 fhPtHbpXECharged ->Fill(ptTrig , hbpXE);
485 fhZTCharged ->Fill(ptTrig , zT);
486 fhPtHbpZTCharged ->Fill(ptTrig , hbpZT);
487 fhPtTrigPout ->Fill(ptTrig , pout) ;
488 fhPtTrigCharged ->Fill(ptTrig , ptAssoc) ;
489
b1f720a7 490 // Pile up studies
17af6e24 491 if(fFillPileUpHistograms)
b1f720a7 492 {
2a9171b5 493 if (outTOF==1)
fedea415 494 {
495 fhXEChargedOtherBC ->Fill(ptTrig,xE);
496 fhZTChargedOtherBC ->Fill(ptTrig,zT);
497 fhPtTrigChargedOtherBC->Fill(ptTrig,ptAssoc);
498 }
2a9171b5 499 else if(outTOF==0)
500 {
501 fhXEChargedBC0 ->Fill(ptTrig,xE);
502 fhZTChargedBC0 ->Fill(ptTrig,zT);
503 fhPtTrigChargedBC0->Fill(ptTrig,ptAssoc);
504 }
505
cc944149 506 Int_t vtxBC = GetReader()->GetVertexBC();
507 if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
508 {
509 fhXEChargedVtxBC0 ->Fill(ptTrig,xE);
510 fhZTChargedVtxBC0 ->Fill(ptTrig,zT);
511 fhPtTrigChargedVtxBC0->Fill(ptTrig,ptAssoc);
512 }
513
fedea415 514 if(GetReader()->IsPileUpFromSPD()) { fhXEChargedPileUp[0]->Fill(ptTrig,xE); fhZTChargedPileUp[0]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[0]->Fill(ptTrig,ptAssoc); }
515 if(GetReader()->IsPileUpFromEMCal()) { fhXEChargedPileUp[1]->Fill(ptTrig,xE); fhZTChargedPileUp[1]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[1]->Fill(ptTrig,ptAssoc); }
516 if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEChargedPileUp[2]->Fill(ptTrig,xE); fhZTChargedPileUp[2]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[2]->Fill(ptTrig,ptAssoc); }
517 if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhXEChargedPileUp[3]->Fill(ptTrig,xE); fhZTChargedPileUp[3]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[3]->Fill(ptTrig,ptAssoc); }
518 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhXEChargedPileUp[4]->Fill(ptTrig,xE); fhZTChargedPileUp[4]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[4]->Fill(ptTrig,ptAssoc); }
519 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhXEChargedPileUp[5]->Fill(ptTrig,xE); fhZTChargedPileUp[5]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[5]->Fill(ptTrig,ptAssoc); }
520 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhXEChargedPileUp[6]->Fill(ptTrig,xE); fhZTChargedPileUp[6]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[6]->Fill(ptTrig,ptAssoc); }
b1f720a7 521 }
522
764ab1f4 523 if(IsDataMC())
524 {
b1f720a7 525 Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
526 fhXEChargedMC [mcIndex]->Fill(ptTrig , xE );
764ab1f4 527 }
528
907b38cd 529 if(fDecayTrigger && decay)
530 {
531 fhXEDecayCharged->Fill(ptTrig,xE);
532 fhZTDecayCharged->Fill(ptTrig,zT);
533 } // photon decay pi0/eta trigger
534
8cc41381 535 if(bin >= 0 )//away side
907b38cd 536 {
8cc41381 537 fhXEAssocPtBin[bin]->Fill(ptTrig, xE) ;
538 fhZTAssocPtBin[bin]->Fill(ptTrig, zT) ;
907b38cd 539
540 if(fDecayTrigger && decay)
541 {
8cc41381 542 fhXEDecayChargedAssocPtBin[bin]->Fill(ptTrig, xE);
543 fhZTDecayChargedAssocPtBin[bin]->Fill(ptTrig, zT);
907b38cd 544 }
545 }
546
547 if(charge > 0)
548 {
549 fhXEPosCharged->Fill(ptTrig,xE) ;
550 fhZTPosCharged->Fill(ptTrig,zT) ;
551 }
552 else
553 {
554 fhXENegCharged->Fill(ptTrig,xE) ;
555 fhZTNegCharged->Fill(ptTrig,zT) ;
556 }
557
558 //fill different multiplicity histogram
559 if(DoEventSelect())
560 {
561 for(Int_t im=0; im<GetMultiBin(); im++)
562 {
563 if(nTracks < ( GetMaxMulti() - GetMinMulti() )/GetMultiBin()*(im+1))
564 {
565 fhTrigXECorr[im]->Fill(ptTrig,xE);
566 fhTrigZTCorr[im]->Fill(ptTrig,zT);
567 }
568 }
569 } //multiplicity events selection
570}
571
572//_______________________________________________________________________________________________________________________
22ad7981 573void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventHistograms(Float_t ptTrig, Float_t ptAssoc,
574 Float_t deltaPhi, Int_t nTracks, Int_t outTOF)
907b38cd 575{
576 // Fill underlying event histograms
577
578 fhDeltaPhiUeChargedPt->Fill(ptAssoc,deltaPhi);
579
08f220c8 580 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
907b38cd 581 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
582 Double_t uezT = ptAssoc/ptTrig;
583
584 if(uexE < 0.) uexE = -uexE;
585
586 fhXEUeCharged->Fill(ptTrig,uexE);
f16872ec 587 if(uexE > 0) fhPtHbpXEUeCharged->Fill(ptTrig,TMath::Log(1/uexE));
907b38cd 588
589 fhZTUeCharged->Fill(ptTrig,uezT);
f16872ec 590 if(uexE > 0) fhPtHbpZTUeCharged->Fill(ptTrig,TMath::Log(1/uezT));
907b38cd 591
b1f720a7 592 // Pile up studies
17af6e24 593
594 if(fFillPileUpHistograms)
b1f720a7 595 {
2a9171b5 596 if (outTOF==1)
fedea415 597 {
598 fhXEUeChargedOtherBC->Fill(ptTrig,uexE);
599 fhZTUeChargedOtherBC->Fill(ptTrig,uezT);
600 }
2a9171b5 601 else if(outTOF==0)
602 {
603 fhXEUeChargedBC0->Fill(ptTrig,uexE);
604 fhZTUeChargedBC0->Fill(ptTrig,uezT);
605 }
fedea415 606
cc944149 607 Int_t vtxBC = GetReader()->GetVertexBC();
608 if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
609 {
610 fhXEUeChargedVtxBC0->Fill(ptTrig,uexE);
611 fhZTUeChargedVtxBC0->Fill(ptTrig,uezT);
612 }
613
17af6e24 614 if(GetReader()->IsPileUpFromSPD()) { fhXEUeChargedPileUp[0]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[0]->Fill(ptTrig,uezT);}
615 if(GetReader()->IsPileUpFromEMCal()) { fhXEUeChargedPileUp[1]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[1]->Fill(ptTrig,uezT);}
616 if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEUeChargedPileUp[2]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[2]->Fill(ptTrig,uezT);}
617 if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhXEUeChargedPileUp[3]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[3]->Fill(ptTrig,uezT);}
618 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhXEUeChargedPileUp[4]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[4]->Fill(ptTrig,uezT);}
619 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhXEUeChargedPileUp[5]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[5]->Fill(ptTrig,uezT);}
620 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhXEUeChargedPileUp[6]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[6]->Fill(ptTrig,uezT);}
621 }
b1f720a7 622
907b38cd 623 if(DoEventSelect())
624 {
625 for(Int_t im=0; im<GetMultiBin(); im++)
626 {
627 if(nTracks < ( GetMaxMulti() - GetMinMulti() )/GetMultiBin()*(im+1))
628 {
629 fhTrigXEUeCorr[im]->Fill(ptTrig,uexE); // xE? CHECK
630 fhTrigZTUeCorr[im]->Fill(ptTrig,uezT); // zT? CHECK
631 }
632 }
633 } //multiplicity events selection
634}
635
8cc41381 636//_____________________________________________________________________________________________________
22ad7981 637void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventSidesHistograms(Float_t ptTrig,
638 Float_t ptAssoc,
639 Float_t deltaPhi)
907b38cd 640{
08f220c8 641 // Fill underlying event histograms to the left and right of trigger
642 if((deltaPhi<-fUeDeltaPhiMinCut) || (deltaPhi >2*fUeDeltaPhiMaxCut))
907b38cd 643 {
08f220c8 644 fhDeltaPhiUeLeftCharged->Fill(ptAssoc,deltaPhi);
645 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
646 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
647 Double_t uezT = ptAssoc/ptTrig;
648
649 if(uexE < 0.) uexE = -uexE;
650
651 fhXEUeLeftCharged->Fill(ptTrig,uexE);
652 if(uexE > 0) fhPtHbpXEUeLeftCharged->Fill(ptTrig,TMath::Log(1/uexE));
653
654 fhZTUeLeftCharged->Fill(ptTrig,uezT);
655 if(uexE > 0) fhPtHbpZTUeLeftCharged->Fill(ptTrig,TMath::Log(1/uezT));
907b38cd 656 fhDeltaPhiUeLeftCharged->Fill(ptAssoc, deltaPhi);
907b38cd 657 }
658
659 if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut))
660 {
08f220c8 661 fhDeltaPhiUeRightCharged->Fill(ptAssoc,deltaPhi);
662 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
663 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
664 Double_t uezT = ptAssoc/ptTrig;
665
666 if(uexE < 0.) uexE = -uexE;
667
668 fhXEUeRightCharged->Fill(ptTrig,uexE);
669 if(uexE > 0) fhPtHbpXEUeRightCharged->Fill(ptTrig,TMath::Log(1/uexE));
670
671 fhZTUeRightCharged->Fill(ptTrig,uezT);
672 if(uexE > 0) fhPtHbpZTUeRightCharged->Fill(ptTrig,TMath::Log(1/uezT));
907b38cd 673 fhDeltaPhiUeRightCharged->Fill(ptAssoc, deltaPhi);
907b38cd 674 }
8cc41381 675
676 if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-TMath::Pi()/2))
677 {
678 fhDeltaPhiUeLeftDownCharged->Fill(ptAssoc,deltaPhi);
679 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
680 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
681
682 if(uexE < 0.) uexE = -uexE;
683
684 fhXEUeLeftDownCharged->Fill(ptTrig,uexE);
685 }
686
687 if((deltaPhi>2*fUeDeltaPhiMaxCut) && (deltaPhi <3*TMath::Pi()/2))
688 {
689 fhDeltaPhiUeLeftUpCharged->Fill(ptAssoc,deltaPhi);
690 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
691 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
692
693 if(uexE < 0.) uexE = -uexE;
694
695 fhXEUeLeftUpCharged->Fill(ptTrig,uexE);
696 }
697
698 if((deltaPhi > TMath::Pi()/2) && (deltaPhi < fUeDeltaPhiMaxCut))
699 {
700 fhDeltaPhiUeRightUpCharged->Fill(ptAssoc,deltaPhi);
701 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
702 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
703
704 if(uexE < 0.) uexE = -uexE;
705
706 fhXEUeRightUpCharged->Fill(ptTrig,uexE);
707 }
708
709 if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < TMath::Pi()/2))
710 {
711 fhDeltaPhiUeRightDownCharged->Fill(ptAssoc,deltaPhi);
712 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
713 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
714
715 if(uexE < 0.) uexE = -uexE;
716
717 fhXEUeRightDownCharged->Fill(ptTrig,uexE);
718 }
907b38cd 719}
720
721//______________________________________________________________________________________________________________________________
22ad7981 722void AliAnaParticleHadronCorrelation::FillDecayPhotonCorrelationHistograms(Float_t ptAssoc, Float_t phiAssoc,
723 TLorentzVector mom1, TLorentzVector mom2,
724 Bool_t bChargedOrNeutral)
907b38cd 725{
726 // Do correlation with decay photons of triggered pi0 or eta
727
728 // Calculate the correlation parameters
729 Float_t ptDecay1 = mom1.Pt();
730 Float_t ptDecay2 = mom2.Pt();
731
732 Float_t zTDecay1 = -100, zTDecay2 = -100;
733 if(ptDecay1) zTDecay1 = ptAssoc/ptDecay1 ;
734 if(ptDecay2) zTDecay2 = ptAssoc/ptDecay2 ;
735
736 Float_t deltaPhiDecay1 = mom1.Phi()-phiAssoc;
737 if(deltaPhiDecay1< -TMath::PiOver2()) deltaPhiDecay1+=TMath::TwoPi();
738 if(deltaPhiDecay1>3*TMath::PiOver2()) deltaPhiDecay1-=TMath::TwoPi();
739
740 Float_t deltaPhiDecay2 = mom2.Phi()-phiAssoc;
741 if(deltaPhiDecay2< -TMath::PiOver2()) deltaPhiDecay2+=TMath::TwoPi();
742 if(deltaPhiDecay2>3*TMath::PiOver2()) deltaPhiDecay2-=TMath::TwoPi();
743
744 Float_t xEDecay1 =-zTDecay1*TMath::Cos(deltaPhiDecay1); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
745 Float_t xEDecay2 =-zTDecay2*TMath::Cos(deltaPhiDecay2); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
746
747 if(bChargedOrNeutral) // correlate with charges
748 {
749 fhDeltaPhiDecayCharged->Fill(ptDecay1, deltaPhiDecay1);
750 fhDeltaPhiDecayCharged->Fill(ptDecay2, deltaPhiDecay2);
751
2e876d85 752 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::FillDecayPhotonHistograms( Charged corr) - deltaPhoton1 = %f, deltaPhoton2 = %f \n", deltaPhiDecay1, deltaPhiDecay2);
907b38cd 753
754 if( (deltaPhiDecay1 > fDeltaPhiMinCut) && ( deltaPhiDecay1 < fDeltaPhiMaxCut) )
755 {
756 fhZTDecayCharged->Fill(ptDecay1,zTDecay1);
757 fhXEDecayCharged->Fill(ptDecay1,xEDecay1);
758 }
759 if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) )
760 {
761 fhZTDecayCharged->Fill(ptDecay2,zTDecay2);
762 fhXEDecayCharged->Fill(ptDecay2,xEDecay2);
763 }
764 }
765 else // correlate with neutrals
766 {
767 fhDeltaPhiDecayCharged->Fill(ptDecay1, deltaPhiDecay1);
768 fhDeltaPhiDecayCharged->Fill(ptDecay2, deltaPhiDecay2);
769
2e876d85 770 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::FillDecayPhotonHistograms(Neutral corr) - deltaPhoton1 = %f, deltaPhoton2 = %f \n", deltaPhiDecay1, deltaPhiDecay2);
907b38cd 771
772 if( (deltaPhiDecay1 > fDeltaPhiMinCut) && ( deltaPhiDecay1 < fDeltaPhiMaxCut) )
773 {
774 fhZTDecayCharged->Fill(ptDecay1,zTDecay1);
775 fhXEDecayCharged->Fill(ptDecay1,xEDecay1);
776 }
777 if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) )
778 {
779 fhZTDecayCharged->Fill(ptDecay2,zTDecay2);
780 fhXEDecayCharged->Fill(ptDecay2,xEDecay2);
781 }
782 }
783}
784
785//______________________________________________________________________________________________________________________________________________________
22ad7981 786void AliAnaParticleHadronCorrelation::FillNeutralAngularCorrelationHistograms(Float_t ptAssoc, Float_t ptTrig,
787 Float_t phiAssoc, Float_t phiTrig, Float_t & deltaPhi,
788 Float_t etaAssoc, Float_t etaTrig)
907b38cd 789{
790 // Fill angular correlation related histograms
791
792 Float_t deltaEta = etaTrig-etaAssoc;
793 deltaPhi = phiTrig-phiAssoc;
794
795 if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
796 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
797
798 fhEtaNeutral ->Fill(ptAssoc,etaAssoc);
799 fhPhiNeutral ->Fill(ptAssoc,phiAssoc);
800 fhDeltaEtaNeutral->Fill(ptTrig ,deltaEta);
801 fhDeltaPhiNeutral->Fill(ptTrig ,deltaPhi);
802
803 if(ptAssoc > 2 ) fhDeltaPhiDeltaEtaNeutral->Fill(deltaPhi, deltaEta);
804
805}
806
807//_____________________________________________________________________________________________________________________________
22ad7981 808void AliAnaParticleHadronCorrelation::FillNeutralUnderlyingEventSidesHistograms(Float_t ptTrig, Float_t ptAssoc,
809 Float_t xE, Float_t hbpXE,
810 Float_t zT, Float_t hbpZT,
811 Float_t deltaPhi)
907b38cd 812{
813 // Fill underlying event histograms to the left and right of trigger
814
815 if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-fUeDeltaPhiMaxCut))
816 {
817 fhDeltaPhiUeLeftNeutral->Fill(ptAssoc, deltaPhi);
818 fhXEUeLeftNeutral ->Fill(ptTrig , xE);
819 fhPtHbpXEUeLeftNeutral ->Fill(ptTrig , hbpXE);
820 fhZTUeLeftNeutral ->Fill(ptTrig , zT);
821 fhPtHbpZTUeLeftNeutral ->Fill(ptTrig , hbpZT);
822 }
823
824 if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut))
825 {
826 fhDeltaPhiUeRightNeutral->Fill(ptAssoc, deltaPhi);
827 fhXEUeRightNeutral ->Fill(ptTrig , xE);
828 fhPtHbpXEUeRightNeutral ->Fill(ptTrig , hbpXE);
829 fhZTUeRightNeutral ->Fill(ptTrig , zT);
830 fhPtHbpZTUeRightNeutral ->Fill(ptTrig , hbpZT);
831 }
832}
833
31864468 834//______________________________________________________
835void AliAnaParticleHadronCorrelation::FillEventMixPool()
836{
837 // Fill the pool with tracks if requested
838
839 if(DoOwnMix())
840 {
841 FillChargedEventMixPool();
842
843 if(OnlyIsolated() || fFillNeutralEventMixPool)
844 FillNeutralEventMixPool();
845 }
846
847}
848
029dea5a 849//_____________________________________________________________
850void AliAnaParticleHadronCorrelation::FillChargedEventMixPool()
851{
d07ffd54 852 // Mixed event pool filling for tracks
31864468 853
7ed3a248 854 if(fUseMixStoredInReader && GetReader()->GetLastTracksMixedEvent() == GetEventNumber())
855 {
856 //printf("%s : Pool already filled for this event !!!\n",GetInputAODName().Data());
857 return ; // pool filled previously for another trigger
858 }
859
029dea5a 860 Int_t nTracks = GetCTSTracks()->GetEntriesFast();
31864468 861
029dea5a 862 AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
863 AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
864
c6b4facc 865 if(!inputHandler) return ;
31864468 866
d07ffd54 867 // Do mixing only with MB event (or the chosen mask), if not skip
868 if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ;
869
870 fhNtracksMB->Fill(nTracks);
871
872 Int_t eventBin = GetEventMixBin();
873
874 //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
875 if(eventBin < 0) return;
876
877 TObjArray * mixEventTracks = new TObjArray;
878
879 if(fUseMixStoredInReader)
029dea5a 880 {
d07ffd54 881 fListMixTrackEvents[eventBin] = GetReader()->GetListWithMixedEventsForTracks(eventBin);
882 }
883
884 if(!fListMixTrackEvents[eventBin]) fListMixTrackEvents[eventBin] = new TList();
885
886 //printf("%s ***** Pool Event bin : %d - nTracks %d\n",GetInputAODName().Data(),eventBin, GetCTSTracks()->GetEntriesFast());
887
888 TList * pool = fListMixTrackEvents[eventBin];
889
890 TVector3 p3;
891 for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
892 {
893 AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
029dea5a 894
d07ffd54 895 Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
896 p3.SetXYZ(mom[0],mom[1],mom[2]);
897 Float_t pt = p3.Pt();
2e876d85 898
d07ffd54 899 //Select only hadrons in pt range
900 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
029dea5a 901
d07ffd54 902 AliAODPWG4Particle * mixedTrack = new AliAODPWG4Particle(mom[0],mom[1],mom[2],0);
903 mixedTrack->SetDetector("CTS");
904 mixedTrack->SetChargedBit(track->Charge()>0);
905 mixEventTracks->Add(mixedTrack);
906 }
907
908 //Set the event number where the last event was added, to avoid double pool filling
909 GetReader()->SetLastTracksMixedEvent(GetEventNumber());
910
911 //printf("Add event to pool with %d tracks \n ",mixEventTracks->GetEntries());
912 pool->AddFirst(mixEventTracks);
913 mixEventTracks = 0;
914
915 //printf("Pool size %d, max %d\n",pool->GetSize(), GetNMaxEvMix());
916
917 if(pool->GetSize() > GetNMaxEvMix())
918 {//Remove last event
919 TClonesArray * tmp = static_cast<TClonesArray*>(pool->Last()) ;
920 pool->RemoveLast() ;
921 delete tmp ;
922 }
923}
924
925//_____________________________________________________________
926void AliAnaParticleHadronCorrelation::FillNeutralEventMixPool()
927{
928 // Mixed event pool filling for neutral clusters
929 // Right now only for EMCAL and in isolation case
930
931 //printf("FillNeutralEventMixPool for %s\n",GetInputAODName().Data());
932
2bb7ac98 933 TObjArray * pl = GetEMCALClusters();
934 //if (GetAODObjArrayName.Contains("PHOS") )pl = GetPHOSClusters();
935 //else pl = GetEMCALClusters();
936
937 Int_t nClusters = pl->GetEntriesFast();
2bb7ac98 938
d07ffd54 939 if(fUseMixStoredInReader && GetReader()->GetLastCaloMixedEvent() == GetEventNumber())
940 {
941 //printf("%s : Pool already filled for this event !!!\n",GetInputAODName().Data());
942 return ; // pool filled previously for another trigger
943 }
944
d07ffd54 945 AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
946 AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
947
948 if(!inputHandler) return ;
31864468 949
d07ffd54 950 // Do mixing only with MB event (or the chosen mask), if not skip
951 if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ;
952
2bb7ac98 953 fhNclustersMB->Fill(nClusters);
d07ffd54 954
955 Int_t eventBin = GetEventMixBin();
956
957 //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
958 if(eventBin < 0) return;
959
960 TObjArray * mixEventCalo = new TObjArray;
961
962 if(fUseMixStoredInReader)
963 {
964 fListMixCaloEvents[eventBin] = GetReader()->GetListWithMixedEventsForCalo(eventBin);
965 }
966
967 if(!fListMixCaloEvents[eventBin]) fListMixCaloEvents[eventBin] = new TList();
968
969 TList * poolCalo = fListMixCaloEvents[eventBin];
970
d07ffd54 971 TLorentzVector mom;
2bb7ac98 972
973 for(Int_t ipr = 0;ipr < nClusters ; ipr ++ )
d07ffd54 974 {
975 AliVCluster * calo = (AliVCluster *) (pl->At(ipr)) ;
976
977 // remove matched clusters
978 if( IsTrackMatched( calo, GetReader()->GetInputEvent() ) ) continue ;
283f989c 979
2bb7ac98 980 //Cluster momentum calculation
d07ffd54 981 if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
283f989c 982 {
d07ffd54 983 calo->GetMomentum(mom,GetVertex(0)) ;
984 }//Assume that come from vertex in straight line
985 else
029dea5a 986 {
d07ffd54 987 Double_t vertex[]={0,0,0};
988 calo->GetMomentum(mom,vertex) ;
029dea5a 989 }
990
d07ffd54 991 Float_t pt = mom.Pt();
992 //Select only clusters in pt range
993 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
2e876d85 994
d07ffd54 995 AliAODPWG4Particle * mixedCalo = new AliAODPWG4Particle(mom);
996 mixedCalo->SetDetector("EMCAL");
997 mixEventCalo->Add(mixedCalo);
998 }
999
1000 //Set the event number where the last event was added, to avoid double pool filling
1001 GetReader()->SetLastCaloMixedEvent(GetEventNumber());
1002
1003 //printf("Add event to pool with %d clusters \n ",mixEventCalo->GetEntries());
1004 poolCalo->AddFirst(mixEventCalo);
1005 mixEventCalo = 0;
1006
1007 //printf("Pool size %d, max %d\n",poolCalo->GetSize(), GetNMaxEvMix());
029dea5a 1008
d07ffd54 1009 if(poolCalo->GetSize() > GetNMaxEvMix())
1010 {//Remove last event
1011 TClonesArray * tmp = static_cast<TClonesArray*>(poolCalo->Last()) ;
1012 poolCalo->RemoveLast() ;
1013 delete tmp ;
1014 }
029dea5a 1015}
1016
05d0d05d 1017//____________________________________________________________
1018TObjString* AliAnaParticleHadronCorrelation::GetAnalysisCuts()
1019{
1020 //Save parameters used for analysis
1021 TString parList ; //this will be list of parameters used for this analysis.
1022 const Int_t buffersize = 560;
1023 char onePar[buffersize] ;
1024
1025 snprintf(onePar,buffersize,"--- AliAnaPaticleHadronCorrelation ---\n") ;
1026 parList+=onePar ;
66e64043 1027 snprintf(onePar,buffersize," Pt Trigger > %3.2f ", fMinTriggerPt) ;
05d0d05d 1028 parList+=onePar ;
66e64043 1029 snprintf(onePar,buffersize," %3.2f < Pt associated < %3.2f ", fMinAssocPt, fMaxAssocPt) ;
05d0d05d 1030 parList+=onePar ;
66e64043 1031 snprintf(onePar,buffersize," %3.2f < Phi trigger particle-Hadron < %3.2f ", fDeltaPhiMinCut, fDeltaPhiMaxCut) ;
05d0d05d 1032 parList+=onePar ;
66e64043 1033 snprintf(onePar,buffersize," %3.2f < Phi trigger particle-UeHadron < %3.2f ", fUeDeltaPhiMinCut, fUeDeltaPhiMaxCut) ;
05d0d05d 1034 parList+=onePar ;
66e64043 1035 snprintf(onePar,buffersize,"Isolated Trigger? %d\n", fSelectIsolated) ;
05d0d05d 1036 parList+=onePar ;
66e64043 1037 snprintf(onePar,buffersize,"Several UE? %d\n", fMakeSeveralUE) ;
05d0d05d 1038 parList+=onePar ;
66e64043 1039 snprintf(onePar,buffersize,"Name of AOD Pi0 Branch %s ", fPi0AODBranchName.Data());
05d0d05d 1040 parList+=onePar ;
907b38cd 1041 snprintf(onePar,buffersize,"Do Decay-hadron correlation ? pi0 %d, decay %d", fPi0Trigger, fDecayTrigger) ;
05d0d05d 1042 parList+=onePar ;
3f150b4b 1043 snprintf(onePar,buffersize,"Select absolute leading for cluster triggers ? %d or Near Side Leading %d \n",
1044 fMakeAbsoluteLeading, fMakeNearSideLeading) ;
05d0d05d 1045 parList+=onePar ;
1046 snprintf(onePar,buffersize,"Associated particle pt bins %d: ", fNAssocPtBins) ;
1047 parList+=onePar ;
1048 for (Int_t ibin = 0; ibin<fNAssocPtBins; ibin++) {
1049 snprintf(onePar,buffersize,"bin %d = [%2.1f,%2.1f];", ibin, fAssocPtBinLimit[ibin], fAssocPtBinLimit[ibin+1]) ;
1050 }
1051 parList+=onePar ;
1052
1053 //Get parameters set in base class.
1054 parList += GetBaseParametersList() ;
1055
05d0d05d 1056 //Get parameters set in FiducialCut class (not available yet)
1057 //parlist += GetFidCut()->GetFidCutParametersList()
1058
1059 return new TObjString(parList) ;
1060
1061}
1062
1063//________________________________________________________________
e09cf5ef 1064TList * AliAnaParticleHadronCorrelation::GetCreateOutputObjects()
1065{
1066
1067 // Create histograms to be saved in output file and
1068 // store them in fOutputContainer
029dea5a 1069
e09cf5ef 1070 TList * outputContainer = new TList() ;
1071 outputContainer->SetName("CorrelationHistos") ;
1072
62f2fe4d 1073 Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins(); Int_t netabins = GetHistogramRanges()->GetHistoEtaBins(); Int_t ndeltaphibins = GetHistogramRanges()->GetHistoDeltaPhiBins(); Int_t ndeltaetabins = GetHistogramRanges()->GetHistoDeltaEtaBins();
1074 Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t phimax = GetHistogramRanges()->GetHistoPhiMax(); Float_t etamax = GetHistogramRanges()->GetHistoEtaMax(); Float_t deltaphimax = GetHistogramRanges()->GetHistoDeltaPhiMax(); Float_t deltaetamax = GetHistogramRanges()->GetHistoDeltaEtaMax();
1075 Float_t ptmin = GetHistogramRanges()->GetHistoPtMin(); Float_t phimin = GetHistogramRanges()->GetHistoPhiMin(); Float_t etamin = GetHistogramRanges()->GetHistoEtaMin(); Float_t deltaphimin = GetHistogramRanges()->GetHistoDeltaPhiMin(); Float_t deltaetamin = GetHistogramRanges()->GetHistoDeltaEtaMin();
e09cf5ef 1076
d0b625bc 1077 Int_t nMixBins = GetNCentrBin()*GetNZvertBin()*GetNRPBin();
1078
17af6e24 1079 TString nameMC[] = {"Photon","Pi0","Pi0Decay","EtaDecay","OtherDecay","Electron","Hadron"};
1080 TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ;
1081
7d306daf 1082 // For vz dependent histograms, if option ON
1083 Int_t nz = 1 ;
1084 if(fCorrelVzBin) nz = GetNZvertBin();
1085 TString sz = "" ;
1086 TString tz = "" ;
1087
764ab1f4 1088 fhPtInput = new TH1F("hPtInput","p_{T} distribution of input trigger particles", nptbins,ptmin,ptmax);
7d306daf 1089 fhPtInput->SetXTitle("p_{T}^{trig} (GeV/c)");
1090 outputContainer->Add(fhPtInput);
1091
764ab1f4 1092 fhPtFidCut = new TH1F("hPtFidCut","p_{T} distribution of input trigger particles after fiducial cut", nptbins,ptmin,ptmax);
7d306daf 1093 fhPtFidCut->SetXTitle("p_{T}^{trig} (GeV/c)");
1094 outputContainer->Add(fhPtFidCut);
1095
764ab1f4 1096 fhPtLeading = new TH1F("hPtLeading","p_{T} distribution of leading particles", nptbins,ptmin,ptmax);
e09cf5ef 1097 fhPtLeading->SetXTitle("p_{T}^{trig} (GeV/c)");
7d306daf 1098 outputContainer->Add(fhPtLeading);
ca17b39f 1099
764ab1f4 1100 if(IsDataMC())
1101 {
b1f720a7 1102 for(Int_t i=0; i < 7; i++)
764ab1f4 1103 {
1104 fhPtLeadingMC[i] = new TH1F(Form("hPtLeading_MC%s",nameMC[i].Data()),
1105 Form("p_{T} distribution of leading particles, trigger origin is %s",nameMC[i].Data()),
1106 nptbins,ptmin,ptmax);
1107 fhPtLeadingMC[i]->SetXTitle("p_{T}^{trig} (GeV/c)");
1108 outputContainer->Add(fhPtLeadingMC[i]);
1109 }
1110 }
1111
7d306daf 1112 if(fCorrelVzBin)
1113 {
764ab1f4 1114 fhPtLeadingVzBin = new TH2F("hPtLeadingVzBin","p_{T} distribution of leading particles vs vz bin", nptbins,ptmin,ptmax,GetNZvertBin(),0,GetNZvertBin());
7d306daf 1115 fhPtLeadingVzBin->SetXTitle("p_{T}^{trig} (GeV/c)");
1116 fhPtLeadingVzBin->SetYTitle("v_{z} bin");
1117 outputContainer->Add(fhPtLeadingVzBin);
1118 }
1119
764ab1f4 1120 fhPtLeadingBin = new TH2F ("hPtLeadingBin","p_{T} distribution of leading particles", nptbins,ptmin,ptmax,nMixBins,0,nMixBins);
d0b625bc 1121 fhPtLeadingBin->SetXTitle("p_{T}^{trig} (GeV/c)");
1122 fhPtLeadingBin->SetYTitle("Bin");
7d306daf 1123 outputContainer->Add(fhPtLeadingBin);
d0b625bc 1124
e09cf5ef 1125 fhPhiLeading = new TH2F ("hPhiLeading","#phi distribution of leading Particles",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
1126 fhPhiLeading->SetYTitle("#phi (rad)");
7d306daf 1127 outputContainer->Add(fhPhiLeading);
1128
e09cf5ef 1129 fhEtaLeading = new TH2F ("hEtaLeading","#eta distribution of leading",nptbins,ptmin,ptmax, netabins,etamin,etamax);
1130 fhEtaLeading->SetYTitle("#eta ");
e09cf5ef 1131 outputContainer->Add(fhEtaLeading);
1132
68cd2624 1133 fhPtLeadingCentrality = new TH2F("hPtLeadingCentrality","Leading particle p_{T} vs centrality",nptbins,ptmin,ptmax,100,0.,100) ;
1134 fhPtLeadingCentrality->SetXTitle("p_{T}^{trig} (GeV/c)");
1135 fhPtLeadingCentrality->SetYTitle("Centrality (%)");
1136 outputContainer->Add(fhPtLeadingCentrality) ;
1137
1138 fhPtLeadingEventPlane = new TH2F("hPtLeadingEventPlane","Leading particle p_{T} vs event plane angle",nptbins,ptmin,ptmax, 100,0.,TMath::Pi()) ;
1139 fhPtLeadingEventPlane->SetXTitle("p_{T}^{trig} (GeV/c)");
1140 fhPtLeadingEventPlane->SetXTitle("EP angle (rad)");
1141 outputContainer->Add(fhPtLeadingEventPlane) ;
1142
1143 fhLeadingEventPlaneCentrality = new TH2F("hLeadingEventPlane","Leading particle centrality vs event plane angle",100,0.,100,100,0.,TMath::Pi()) ;
1144 fhLeadingEventPlaneCentrality->SetXTitle("Centrality (%)");
1145 fhLeadingEventPlaneCentrality->SetYTitle("EP angle (rad)");
1146 outputContainer->Add(fhLeadingEventPlaneCentrality) ;
1147
e09cf5ef 1148 //Correlation with charged hadrons
547c2f01 1149 if(GetReader()->IsCTSSwitchedOn())
1150 {
e09cf5ef 1151 fhDeltaPhiDeltaEtaCharged = new TH2F
62f2fe4d 1152 ("hDeltaPhiDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}}",
1153 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
2bb7ac98 1154 fhDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
e09cf5ef 1155 fhDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
1156
b1f720a7 1157 fhDeltaPhiDeltaEtaChargedPtA3GeV = new TH2F
1158 ("hDeltaPhiDeltaEtaChargedPtA3GeV","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}, p_{TA}>3 GeV/c}",
1159 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
2bb7ac98 1160 fhDeltaPhiDeltaEtaChargedPtA3GeV->SetXTitle("#Delta #phi (rad)");
b1f720a7 1161 fhDeltaPhiDeltaEtaChargedPtA3GeV->SetYTitle("#Delta #eta");
1162
e09cf5ef 1163 fhPhiCharged = new TH2F
babcbc9d 1164 ("hPhiCharged","#phi_{h^{#pm}} vs p_{T #pm}",
e09cf5ef 1165 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
1166 fhPhiCharged->SetYTitle("#phi_{h^{#pm}} (rad)");
1167 fhPhiCharged->SetXTitle("p_{T #pm} (GeV/c)");
1168
1169 fhEtaCharged = new TH2F
babcbc9d 1170 ("hEtaCharged","#eta_{h^{#pm}} vs p_{T #pm}",
e09cf5ef 1171 nptbins,ptmin,ptmax,netabins,etamin,etamax);
1172 fhEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)");
1173 fhEtaCharged->SetXTitle("p_{T #pm} (GeV/c)");
1174
1175 fhDeltaPhiCharged = new TH2F
babcbc9d 1176 ("hDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",
62f2fe4d 1177 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1178 fhDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
e09cf5ef 1179 fhDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)");
1180
b1f720a7 1181 fhDeltaPhiChargedPtA3GeV = new TH2F
1182 ("hDeltaPhiChargedPtA3GeV","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c",
1183 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1184 fhDeltaPhiChargedPtA3GeV->SetYTitle("#Delta #phi (rad)");
b1f720a7 1185 fhDeltaPhiChargedPtA3GeV->SetXTitle("p_{T trigger} (GeV/c)");
1186
1187
e09cf5ef 1188 fhDeltaPhiChargedPt = new TH2F
babcbc9d 1189 ("hDeltaPhiChargedPt","#phi_{trigger} - #phi_{#h^{#pm}} vs p_{T h^{#pm}}",
62f2fe4d 1190 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1191 fhDeltaPhiChargedPt->SetYTitle("#Delta #phi (rad)");
e09cf5ef 1192 fhDeltaPhiChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1193
1194 fhDeltaPhiUeChargedPt = new TH2F
babcbc9d 1195 ("hDeltaPhiUeChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}}",
62f2fe4d 1196 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1197 fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi (rad)");
e09cf5ef 1198 fhDeltaPhiUeChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1199
9623bf34 1200 fhUePart = new TH1F("hUePart","UE particles distribution vs pt trig",
1201 nptbins,ptmin,ptmax);
1202 fhUePart->SetYTitle("dNch");
2bb7ac98 1203 fhUePart->SetXTitle("p_{T trigger} (GeV/c)");
9623bf34 1204
1205
e09cf5ef 1206 fhDeltaEtaCharged = new TH2F
babcbc9d 1207 ("hDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}",
62f2fe4d 1208 nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
e09cf5ef 1209 fhDeltaEtaCharged->SetYTitle("#Delta #eta");
1210 fhDeltaEtaCharged->SetXTitle("p_{T trigger} (GeV/c)");
1211
b1f720a7 1212 fhDeltaEtaChargedPtA3GeV = new TH2F
1213 ("hDeltaEtaChargedPtA3GeV","#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c",
1214 nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
1215 fhDeltaEtaChargedPtA3GeV->SetYTitle("#Delta #eta");
1216 fhDeltaEtaChargedPtA3GeV->SetXTitle("p_{T trigger} (GeV/c)");
1217
3f150b4b 1218 fhXECharged =
1219 new TH2F("hXECharged","x_{E} for charged tracks",
e09cf5ef 1220 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1221 fhXECharged->SetYTitle("x_{E}");
2bb7ac98 1222 fhXECharged->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 1223
3f150b4b 1224 fhXEUeCharged =
1225 new TH2F("hXEUeCharged","x_{E} for Underlying Event",
e09cf5ef 1226 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1227 fhXEUeCharged->SetYTitle("x_{E}");
2bb7ac98 1228 fhXEUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 1229
3f150b4b 1230 fhXEPosCharged =
1231 new TH2F("hXEPositiveCharged","x_{E} for positive charged tracks",
e09cf5ef 1232 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1233 fhXEPosCharged->SetYTitle("x_{E}");
2bb7ac98 1234 fhXEPosCharged->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 1235
3f150b4b 1236 fhXENegCharged =
1237 new TH2F("hXENegativeCharged","x_{E} for negative charged tracks",
e09cf5ef 1238 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1239 fhXENegCharged->SetYTitle("x_{E}");
2bb7ac98 1240 fhXENegCharged->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 1241
3f150b4b 1242 fhPtHbpXECharged =
1243 new TH2F("hHbpXECharged","#xi = ln(1/x_{E}) with charged hadrons",
e09cf5ef 1244 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1245 fhPtHbpXECharged->SetYTitle("ln(1/x_{E})");
2bb7ac98 1246 fhPtHbpXECharged->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 1247
3f150b4b 1248 fhPtHbpXEUeCharged =
1249 new TH2F("hHbpXEUeCharged","#xi = ln(1/x_{E}) with charged hadrons,Underlying Event",
e09cf5ef 1250 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1251 fhPtHbpXEUeCharged->SetYTitle("ln(1/x_{E})");
2bb7ac98 1252 fhPtHbpXEUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1253
1254 fhZTCharged =
1255 new TH2F("hZTCharged","z_{T} for charged tracks",
1256 nptbins,ptmin,ptmax,200,0.,2.);
1257 fhZTCharged->SetYTitle("z_{T}");
1258 fhZTCharged->SetXTitle("p_{T trigger}");
1259
1260 fhZTUeCharged =
1261 new TH2F("hZTUeCharged","z_{T} for Underlying Event",
1262 nptbins,ptmin,ptmax,200,0.,2.);
1263 fhZTUeCharged->SetYTitle("z_{T}");
2bb7ac98 1264 fhZTUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1265
1266 fhZTPosCharged =
1267 new TH2F("hZTPositiveCharged","z_{T} for positive charged tracks",
1268 nptbins,ptmin,ptmax,200,0.,2.);
1269 fhZTPosCharged->SetYTitle("z_{T}");
2bb7ac98 1270 fhZTPosCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1271
1272 fhZTNegCharged =
1273 new TH2F("hZTNegativeCharged","z_{T} for negative charged tracks",
1274 nptbins,ptmin,ptmax,200,0.,2.);
1275 fhZTNegCharged->SetYTitle("z_{T}");
2bb7ac98 1276 fhZTNegCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1277
1278 fhPtHbpZTCharged =
1279 new TH2F("hHbpZTCharged","#xi = ln(1/z_{T}) with charged hadrons",
1280 nptbins,ptmin,ptmax,200,0.,10.);
1281 fhPtHbpZTCharged->SetYTitle("ln(1/z_{T})");
2bb7ac98 1282 fhPtHbpZTCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1283
1284 fhPtHbpZTUeCharged =
1285 new TH2F("hHbpZTUeCharged","#xi = ln(1/z_{T}) with charged hadrons,Underlying Event",
1286 nptbins,ptmin,ptmax,200,0.,10.);
1287 fhPtHbpZTUeCharged->SetYTitle("ln(1/x_{E})");
2bb7ac98 1288 fhPtHbpZTUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 1289
1290 fhPtTrigPout =
babcbc9d 1291 new TH2F("hPtTrigPout","Pout with triggers",
e09cf5ef 1292 nptbins,ptmin,ptmax,2*nptbins,-ptmax,ptmax);
1293 fhPtTrigPout->SetYTitle("p_{out} (GeV/c)");
1294 fhPtTrigPout->SetXTitle("p_{T trigger} (GeV/c)");
1295
e09cf5ef 1296 fhPtTrigCharged =
b1f720a7 1297 new TH2F("hPtTrigCharged","trigger and charged tracks pt distribution",
e09cf5ef 1298 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
1299 fhPtTrigCharged->SetYTitle("p_{T h^{#pm}} (GeV/c)");
1300 fhPtTrigCharged->SetXTitle("p_{T trigger} (GeV/c)");
1301
1302 outputContainer->Add(fhDeltaPhiDeltaEtaCharged);
b1f720a7 1303 outputContainer->Add(fhDeltaPhiDeltaEtaChargedPtA3GeV);
e09cf5ef 1304 outputContainer->Add(fhPhiCharged) ;
1305 outputContainer->Add(fhEtaCharged) ;
1306 outputContainer->Add(fhDeltaPhiCharged) ;
b1f720a7 1307 outputContainer->Add(fhDeltaPhiChargedPtA3GeV) ;
e09cf5ef 1308 outputContainer->Add(fhDeltaEtaCharged) ;
b1f720a7 1309 outputContainer->Add(fhDeltaEtaChargedPtA3GeV) ;
e09cf5ef 1310 outputContainer->Add(fhDeltaPhiChargedPt) ;
1311 outputContainer->Add(fhDeltaPhiUeChargedPt) ;
9623bf34 1312 outputContainer->Add(fhUePart);
050ad675 1313
3f150b4b 1314 outputContainer->Add(fhXECharged) ;
560498d1 1315
764ab1f4 1316 if(IsDataMC())
1317 {
b1f720a7 1318 for(Int_t i=0; i < 7; i++)
764ab1f4 1319 {
b1f720a7 1320
1321 fhDeltaPhiChargedMC[i] = new TH2F(Form("hDeltaPhiCharged_MC%s",nameMC[i].Data()),
1322 Form("#Delta #phi for charged tracks, trigger origin is %s",nameMC[i].Data()),
1323 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
1324 fhDeltaPhiChargedMC[i]->SetYTitle("x_{E}");
2bb7ac98 1325 fhDeltaPhiChargedMC[i]->SetXTitle("p_{T trigger} (GeV/c)");
b1f720a7 1326 outputContainer->Add(fhDeltaPhiChargedMC[i]) ;
1327
764ab1f4 1328 fhXEChargedMC[i] = new TH2F(Form("hXECharged_MC%s",nameMC[i].Data()),
1329 Form("x_{E} for charged tracks, trigger origin is %s",nameMC[i].Data()),
1330 nptbins,ptmin,ptmax,200,0.,2.);
1331 fhXEChargedMC[i]->SetYTitle("x_{E}");
2bb7ac98 1332 fhXEChargedMC[i]->SetXTitle("p_{T trigger} (GeV/c)");
764ab1f4 1333 outputContainer->Add(fhXEChargedMC[i]) ;
1334 }
1335 }
1336
3f150b4b 1337 outputContainer->Add(fhXEPosCharged) ;
1338 outputContainer->Add(fhXENegCharged) ;
1339 outputContainer->Add(fhXEUeCharged) ;
1340 outputContainer->Add(fhPtHbpXECharged) ;
1341 outputContainer->Add(fhPtHbpXEUeCharged) ;
050ad675 1342
3f150b4b 1343 outputContainer->Add(fhZTCharged) ;
1344 outputContainer->Add(fhZTPosCharged) ;
1345 outputContainer->Add(fhZTNegCharged) ;
1346 outputContainer->Add(fhZTUeCharged) ;
1347 outputContainer->Add(fhPtHbpZTCharged) ;
1348 outputContainer->Add(fhPtHbpZTUeCharged) ;
1349
e09cf5ef 1350 outputContainer->Add(fhPtTrigPout) ;
e09cf5ef 1351 outputContainer->Add(fhPtTrigCharged) ;
1352
b1f720a7 1353 if(fFillPileUpHistograms)
1354 {
560498d1 1355 fhDeltaPhiChargedOtherBC = new TH2F
1356 ("hDeltaPhiChargedOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, track BC!=0",
1357 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1358 fhDeltaPhiChargedOtherBC->SetYTitle("#Delta #phi (rad)");
1359 fhDeltaPhiChargedOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
1360
1361 fhDeltaPhiChargedPtA3GeVOtherBC = new TH2F
1362 ("hDeltaPhiChargedPtA3GeVOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, track BC!=0",
1363 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1364 fhDeltaPhiChargedPtA3GeVOtherBC->SetYTitle("#Delta #phi (rad)");
1365 fhDeltaPhiChargedPtA3GeVOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
1366
1367 fhPtTrigChargedOtherBC =
1368 new TH2F("hPtTrigChargedOtherBC","trigger and charged tracks pt distribution, track BC!=0",
1369 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
1370 fhPtTrigChargedOtherBC->SetYTitle("p_{T h^{#pm}} (GeV/c)");
1371 fhPtTrigChargedOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
1372
1373 fhXEChargedOtherBC =
1374 new TH2F("hXEChargedOtherBC","x_{E} for charged tracks, track BC!=0",
1375 nptbins,ptmin,ptmax,200,0.,2.);
1376 fhXEChargedOtherBC->SetYTitle("x_{E}");
1377 fhXEChargedOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
1378
1379 fhXEUeChargedOtherBC =
1380 new TH2F("hXEUeChargedOtherBC","x_{E} for Underlying Event, track BC!=0",
1381 nptbins,ptmin,ptmax,200,0.,2.);
1382 fhXEUeChargedOtherBC->SetYTitle("x_{E}");
1383 fhXEUeChargedOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
1384
1385 fhZTChargedOtherBC =
1386 new TH2F("hZTChargedOtherBC","z_{T} for charged tracks, track BC!=0",
1387 nptbins,ptmin,ptmax,200,0.,2.);
1388 fhZTChargedOtherBC->SetYTitle("z_{T}");
1389 fhZTChargedOtherBC->SetXTitle("p_{T trigger}");
1390
1391 fhZTUeChargedOtherBC =
1392 new TH2F("hZTUeChargedOtherBC","z_{T} for Underlying Event, track BC!=0",
1393 nptbins,ptmin,ptmax,200,0.,2.);
1394 fhZTUeChargedOtherBC->SetYTitle("z_{T}");
1395 fhZTUeChargedOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
1396
1397 outputContainer->Add(fhDeltaPhiChargedOtherBC) ;
1398 outputContainer->Add(fhDeltaPhiChargedPtA3GeVOtherBC) ;
1399 outputContainer->Add(fhXEChargedOtherBC) ;
1400 outputContainer->Add(fhXEUeChargedOtherBC) ;
1401 outputContainer->Add(fhZTChargedOtherBC) ;
1402 outputContainer->Add(fhZTUeChargedOtherBC) ;
1403 outputContainer->Add(fhPtTrigChargedOtherBC) ;
1404
2a9171b5 1405 fhDeltaPhiChargedBC0 = new TH2F
1406 ("hDeltaPhiChargedBC0","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, track BC==0",
1407 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1408 fhDeltaPhiChargedBC0->SetYTitle("#Delta #phi (rad)");
1409 fhDeltaPhiChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
1410
1411 fhDeltaPhiChargedPtA3GeVBC0 = new TH2F
1412 ("hDeltaPhiChargedPtA3GeVBC0","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, track BC==0",
1413 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1414 fhDeltaPhiChargedPtA3GeVBC0->SetYTitle("#Delta #phi (rad)");
1415 fhDeltaPhiChargedPtA3GeVBC0->SetXTitle("p_{T trigger} (GeV/c)");
1416
1417 fhPtTrigChargedBC0 =
1418 new TH2F("hPtTrigChargedBC0","trigger and charged tracks pt distribution, track BC==0",
1419 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
1420 fhPtTrigChargedBC0->SetYTitle("p_{T h^{#pm}} (GeV/c)");
1421 fhPtTrigChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
1422
1423 fhXEChargedBC0 =
1424 new TH2F("hXEChargedBC0","x_{E} for charged tracks, track BC==0",
1425 nptbins,ptmin,ptmax,200,0.,2.);
1426 fhXEChargedBC0->SetYTitle("x_{E}");
1427 fhXEChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
1428
1429 fhXEUeChargedBC0 =
1430 new TH2F("hXEUeChargedBC0","x_{E} for Underlying Event, track BC==0",
1431 nptbins,ptmin,ptmax,200,0.,2.);
1432 fhXEUeChargedBC0->SetYTitle("x_{E}");
1433 fhXEUeChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
1434
1435 fhZTChargedBC0 =
1436 new TH2F("hZTChargedBC0","z_{T} for charged tracks, track BC==0",
1437 nptbins,ptmin,ptmax,200,0.,2.);
1438 fhZTChargedBC0->SetYTitle("z_{T}");
1439 fhZTChargedBC0->SetXTitle("p_{T trigger}");
1440
1441 fhZTUeChargedBC0 =
1442 new TH2F("hZTUeChargedBC0","z_{T} for Underlying Event, track BC==0",
1443 nptbins,ptmin,ptmax,200,0.,2.);
1444 fhZTUeChargedBC0->SetYTitle("z_{T}");
1445 fhZTUeChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
1446
1447 outputContainer->Add(fhDeltaPhiChargedBC0) ;
1448 outputContainer->Add(fhDeltaPhiChargedPtA3GeVBC0) ;
1449 outputContainer->Add(fhXEChargedBC0) ;
1450 outputContainer->Add(fhXEUeChargedBC0) ;
1451 outputContainer->Add(fhZTChargedBC0) ;
1452 outputContainer->Add(fhZTUeChargedBC0) ;
1453 outputContainer->Add(fhPtTrigChargedBC0) ;
1454
cc944149 1455 fhPtLeadingVtxBC0 = new TH1F("hPtLeadingVtxBC0","p_{T} distribution of leading particles", nptbins,ptmin,ptmax);
1456 fhPtLeadingVtxBC0->SetXTitle("p_{T}^{trig} (GeV/c)");
1457
1458 fhDeltaPhiChargedVtxBC0 = new TH2F
1459 ("hDeltaPhiChargedVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, track BC==0",
1460 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1461 fhDeltaPhiChargedVtxBC0->SetYTitle("#Delta #phi (rad)");
1462 fhDeltaPhiChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
1463
1464 fhDeltaPhiChargedPtA3GeVVtxBC0 = new TH2F
1465 ("hDeltaPhiChargedPtA3GeVVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, track BC==0",
1466 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
1467 fhDeltaPhiChargedPtA3GeVVtxBC0->SetYTitle("#Delta #phi (rad)");
1468 fhDeltaPhiChargedPtA3GeVVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
1469
1470 fhPtTrigChargedVtxBC0 =
1471 new TH2F("hPtTrigChargedVtxBC0","trigger and charged tracks pt distribution, track BC==0",
1472 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
1473 fhPtTrigChargedVtxBC0->SetYTitle("p_{T h^{#pm}} (GeV/c)");
1474 fhPtTrigChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
1475
1476 fhXEChargedVtxBC0 =
1477 new TH2F("hXEChargedVtxBC0","x_{E} for charged tracks, track BC==0",
1478 nptbins,ptmin,ptmax,200,0.,2.);
1479 fhXEChargedVtxBC0->SetYTitle("x_{E}");
1480 fhXEChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
1481
1482 fhXEUeChargedVtxBC0 =
1483 new TH2F("hXEUeChargedVtxBC0","x_{E} for Underlying Event, track BC==0",
1484 nptbins,ptmin,ptmax,200,0.,2.);
1485 fhXEUeChargedVtxBC0->SetYTitle("x_{E}");
1486 fhXEUeChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
1487
1488 fhZTChargedVtxBC0 =
1489 new TH2F("hZTChargedVtxBC0","z_{T} for charged tracks, track BC==0",
1490 nptbins,ptmin,ptmax,200,0.,2.);
1491 fhZTChargedVtxBC0->SetYTitle("z_{T}");
1492 fhZTChargedVtxBC0->SetXTitle("p_{T trigger}");
1493
1494 fhZTUeChargedVtxBC0 =
1495 new TH2F("hZTUeChargedVtxBC0","z_{T} for Underlying Event, track BC==0",
1496 nptbins,ptmin,ptmax,200,0.,2.);
1497 fhZTUeChargedVtxBC0->SetYTitle("z_{T}");
1498 fhZTUeChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
1499
1500 outputContainer->Add(fhPtLeadingVtxBC0);
1501 outputContainer->Add(fhDeltaPhiChargedVtxBC0) ;
1502 outputContainer->Add(fhDeltaPhiChargedPtA3GeVVtxBC0) ;
1503 outputContainer->Add(fhXEChargedVtxBC0) ;
1504 outputContainer->Add(fhXEUeChargedVtxBC0) ;
1505 outputContainer->Add(fhZTChargedVtxBC0) ;
1506 outputContainer->Add(fhZTUeChargedVtxBC0) ;
1507 outputContainer->Add(fhPtTrigChargedVtxBC0) ;
2a9171b5 1508
17af6e24 1509 for(Int_t i = 0 ; i < 7 ; i++)
1510 {
1511 fhPtLeadingPileUp[i] = new TH1F(Form("hPtLeadingPileUp%s",pileUpName[i].Data()),
1512 Form("p_{T} distribution of leading particles, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
1513 fhPtLeadingPileUp[i]->SetXTitle("p_{T}^{trig} (GeV/c)");
1514 outputContainer->Add(fhPtLeadingPileUp[i]);
1515
1516 fhDeltaPhiChargedPileUp[i] = new TH2F(Form("hDeltaPhiChargedPileUp%s",pileUpName[i].Data()),
1517 Form("#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, %s Pile-Up event",pileUpName[i].Data()),
1518 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1519 fhDeltaPhiChargedPileUp[i]->SetYTitle("#Delta #phi (rad)");
17af6e24 1520 fhDeltaPhiChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
1521 outputContainer->Add(fhDeltaPhiChargedPileUp[i]) ;
1522
1523 fhDeltaPhiChargedPtA3GeVPileUp[i] = new TH2F(Form("hDeltaPhiChargedPtA3GeVPileUp%s",pileUpName[i].Data()),
1524 Form("#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, %s Pile-Up event",pileUpName[i].Data()),
1525 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1526 fhDeltaPhiChargedPtA3GeVPileUp[i]->SetYTitle("#Delta #phi (rad)");
17af6e24 1527 fhDeltaPhiChargedPtA3GeVPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
1528 outputContainer->Add(fhDeltaPhiChargedPtA3GeVPileUp[i]) ;
1529
1530 fhDeltaEtaChargedPileUp[i] = new TH2F(Form("hDeltaEtaChargedPileUp%s",pileUpName[i].Data()),
1531 Form("#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}, %s Pile-Up event",pileUpName[i].Data()),
1532 nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
1533 fhDeltaEtaChargedPileUp[i]->SetYTitle("#Delta #eta");
1534 fhDeltaEtaChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
1535 outputContainer->Add(fhDeltaEtaChargedPileUp[i]) ;
1536
1537 fhDeltaEtaChargedPtA3GeVPileUp[i] = new TH2F(Form("hDeltaEtaChargedPtA3GeVPileUp%s",pileUpName[i].Data()),
1538 Form("#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, %s Pile-Up event",pileUpName[i].Data()),
1539 nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
1540 fhDeltaEtaChargedPtA3GeVPileUp[i]->SetYTitle("#Delta #eta");
1541 fhDeltaEtaChargedPtA3GeVPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
1542 outputContainer->Add(fhDeltaEtaChargedPtA3GeVPileUp[i]) ;
1543
1544 fhXEChargedPileUp[i] = new TH2F(Form("hXEChargedPileUp%s",pileUpName[i].Data()),
1545 Form("x_{E} for charged tracks, %s Pile-Up event",pileUpName[i].Data()),
1546 nptbins,ptmin,ptmax,200,0.,2.);
1547 fhXEChargedPileUp[i]->SetYTitle("x_{E}");
2bb7ac98 1548 fhXEChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
17af6e24 1549 outputContainer->Add(fhXEChargedPileUp[i]) ;
1550
1551 fhXEUeChargedPileUp[i] = new TH2F(Form("hXEUeChargedPileUp%s",pileUpName[i].Data()),
1552 Form("x_{E} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()),
1553 nptbins,ptmin,ptmax,200,0.,2.);
1554 fhXEUeChargedPileUp[i]->SetYTitle("x_{E}");
2bb7ac98 1555 fhXEUeChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
17af6e24 1556 outputContainer->Add(fhXEUeChargedPileUp[i]) ;
1557
1558 fhZTChargedPileUp[i] = new TH2F(Form("hZTChargedPileUp%s",pileUpName[i].Data()),
1559 Form("z_{T} for charged tracks, %s Pile-Up event",pileUpName[i].Data()),
1560 nptbins,ptmin,ptmax,200,0.,2.);
1561 fhZTChargedPileUp[i]->SetYTitle("z_{T}");
2bb7ac98 1562 fhZTChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
17af6e24 1563 outputContainer->Add(fhZTChargedPileUp[i]) ;
1564
1565 fhZTUeChargedPileUp[i] = new TH2F(Form("hZTUeChargedPileUp%s",pileUpName[i].Data()),
1566 Form("z_{T} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()),
1567 nptbins,ptmin,ptmax,200,0.,2.);
1568 fhZTUeChargedPileUp[i]->SetYTitle("z_{T}");
2bb7ac98 1569 fhZTUeChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
17af6e24 1570 outputContainer->Add(fhZTUeChargedPileUp[i]) ;
1571
1572 fhPtTrigChargedPileUp[i] = new TH2F(Form("hPtTrigChargedPileUp%s",pileUpName[i].Data()),
1573 Form("trigger and charged tracks pt distribution, %s Pile-Up event",pileUpName[i].Data()),
1574 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
1575 fhPtTrigChargedPileUp[i]->SetYTitle("p_{T h^{#pm}} (GeV/c)");
1576 fhPtTrigChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
1577 outputContainer->Add(fhPtTrigChargedPileUp[i]) ;
2bb7ac98 1578
17af6e24 1579 }
b1f720a7 1580 }
1581
547c2f01 1582 if(DoEventSelect())
1583 {
e09cf5ef 1584 Int_t nMultiBins = GetMultiBin();
1585 fhTrigDeltaPhiCharged = new TH2F*[nMultiBins] ;
1586 fhTrigDeltaEtaCharged = new TH2F*[nMultiBins] ;
3f150b4b 1587 fhTrigXECorr = new TH2F*[nMultiBins] ;
1588 fhTrigXEUeCorr = new TH2F*[nMultiBins] ;
1589 fhTrigZTCorr = new TH2F*[nMultiBins] ;
1590 fhTrigZTUeCorr = new TH2F*[nMultiBins] ;
1591
1592 for(Int_t im=0; im<nMultiBins; im++)
1593 {
e09cf5ef 1594 fhTrigDeltaPhiCharged[im] = new TH2F
62f2fe4d 1595 (Form("hTrigDeltaPhiCharged_%d",im),Form("hTrigDeltaPhiCharged_%d",im), nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 1596 fhTrigDeltaPhiCharged[im]->SetXTitle("p_{T trigger} (GeV/c)");
2bb7ac98 1597 fhTrigDeltaPhiCharged[im]->SetYTitle("#Delta #phi (rad)");
3f150b4b 1598
e09cf5ef 1599 fhTrigDeltaEtaCharged[im] = new TH2F
62f2fe4d 1600 (Form("hTrigDeltaEtaCharged_%d",im),Form("hTrigDeltaEtaCharged_%d",im), nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax);
e09cf5ef 1601 fhTrigDeltaEtaCharged[im]->SetXTitle("p_{T trigger} (GeV/c)");
1602 fhTrigDeltaEtaCharged[im]->SetYTitle("#Delta #eta");
3f150b4b 1603
1604 fhTrigXECorr[im] = new TH2F
1605 (Form("hTrigXEPtCorr_%d",im),Form("hTrigXEPtCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
1606 fhTrigXECorr[im]->SetYTitle("x_{E trigger h^{#pm}}");
2bb7ac98 1607 fhTrigXECorr[im]->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1608
1609 fhTrigXEUeCorr[im] = new TH2F
1610 (Form("hTrigXEPtUeCorr_%d",im),Form("hTrigXEPtUeCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
1611 fhTrigXEUeCorr[im]->SetYTitle("x_{E trigger h^{#pm}}");
2bb7ac98 1612 fhTrigXEUeCorr[im]->SetXTitle("p_{T trigger}(GeV/c)");
3f150b4b 1613
1614 fhTrigZTCorr[im] = new TH2F
1615 (Form("hTrigZTPtCorr_%d",im),Form("hTrigZTPtCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
1616 fhTrigZTCorr[im]->SetYTitle("z_{trigger h^{#pm}}");
2bb7ac98 1617 fhTrigZTCorr[im]->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1618
1619 fhTrigZTUeCorr[im] = new TH2F
1620 (Form("hTrigZTPtUeCorr_%d",im),Form("hTrigZTPtUeCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
1621 fhTrigZTUeCorr[im]->SetYTitle("z_{trigger h^{#pm}}");
2bb7ac98 1622 fhTrigZTUeCorr[im]->SetXTitle("p_{T trigger} (GeV/c)");
045396c8 1623
e09cf5ef 1624 outputContainer->Add(fhTrigDeltaPhiCharged[im]) ;
1625 outputContainer->Add(fhTrigDeltaEtaCharged[im]) ;
3f150b4b 1626 outputContainer->Add(fhTrigXECorr[im]);
1627 outputContainer->Add(fhTrigXEUeCorr[im]);
1628 outputContainer->Add(fhTrigZTCorr[im]);
1629 outputContainer->Add(fhTrigZTUeCorr[im]);
045396c8 1630 }
1631 }
1632
907b38cd 1633 if(fFillBradHisto)
1634 {
1635 fhAssocPtBkg = new TH2F("hAssocPtBkg", " Trigger p_{T} vs associated hadron p_{T} from background",
1636 nptbins, ptmin, ptmax,nptbins,ptmin,ptmax);
2bb7ac98 1637 fhAssocPtBkg->SetXTitle("p_{T trigger} (GeV/c)");
1638 fhAssocPtBkg->SetYTitle("p_{T associated} (GeV/c)");
907b38cd 1639 outputContainer->Add(fhAssocPtBkg) ;
1640
1641 fhDeltaPhiBrad = new TH2F("hDeltaPhiBrad","atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs p_{T trigger} ",
1642 nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0);
2bb7ac98 1643 fhDeltaPhiBrad->SetXTitle("p_{T trigger} (GeV/c)");
907b38cd 1644 fhDeltaPhiBrad->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi");
1645 outputContainer->Add(fhDeltaPhiBrad) ;
1646 }
7d306daf 1647
1648 fhDeltaPhiDeltaEtaAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1649 fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1650 fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz];
1651 fhDeltaPhiAssocPtBinDEta0 = new TH2F*[fNAssocPtBins*nz];
1652 fhXEAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1653 fhZTAssocPtBin = new TH2F*[fNAssocPtBins*nz];
3f150b4b 1654
907b38cd 1655 if(fFillBradHisto)
7d306daf 1656 fhDeltaPhiBradAssocPtBin = new TH2F*[fNAssocPtBins*nz];
907b38cd 1657
1658 if(fPi0Trigger || fDecayTrigger)
1659 {
7d306daf 1660 fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1661 fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz];
1662 fhXEAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1663 fhZTAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1664 fhXEDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1665 fhZTDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
1666 fhDeltaPhiDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
907b38cd 1667 }
050ad675 1668
907b38cd 1669 if(fHMPIDCorrelation)
1670 {
7d306daf 1671 fhDeltaPhiAssocPtBinHMPID = new TH2F*[fNAssocPtBins*nz];
1672 fhDeltaPhiAssocPtBinHMPIDAcc= new TH2F*[fNAssocPtBins*nz];
907b38cd 1673 }
1674
babcbc9d 1675 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
1676 {
7d306daf 1677 for(Int_t z = 0 ; z < nz ; z++)
907b38cd 1678 {
7d306daf 1679 Int_t bin = i*nz+z;
1680
1681 if(fCorrelVzBin)
1682 {
1683 sz = "_vz%d"+z;
1684 tz = ", v_{z} bin "+z;
1685 }
1686
1687 //printf("iAssoc %d, Vz %d, bin %d - sz %s, tz %s \n",i,z,bin,sz.Data(),tz.Data());
8cc41381 1688
7d306daf 1689 fhDeltaPhiDeltaEtaAssocPtBin[bin] = new TH2F(Form("hDeltaPhiDeltaEtaPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1690 Form("#Delta #phi vs #Delta #eta for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1691 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
2bb7ac98 1692 fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)");
8cc41381 1693 fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetYTitle("#Delta #eta");
1694
7d306daf 1695 fhDeltaPhiAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1696 Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
62f2fe4d 1697 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1698 fhDeltaPhiAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
1699 fhDeltaPhiAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
907b38cd 1700
7d306daf 1701 fhDeltaPhiAssocPtBinDEta08[bin] = new TH2F(Form("hDeltaPhiDeltaEta0.8PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1702 Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1703 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1704 fhDeltaPhiAssocPtBinDEta08[bin]->SetXTitle("p_{T trigger} (GeV/c)");
1705 fhDeltaPhiAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 1706
7d306daf 1707 fhDeltaPhiAssocPtBinDEta0[bin] = new TH2F(Form("hDeltaPhiDeltaEta0PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
1708 Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0.", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1709 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1710 fhDeltaPhiAssocPtBinDEta0[bin]->SetXTitle("p_{T trigger} (GeV/c)");
1711 fhDeltaPhiAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)");
907b38cd 1712
7d306daf 1713 fhXEAssocPtBin[bin] = new TH2F(Form("hXEAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1714 Form("x_{E} vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
907b38cd 1715 nptbins, ptmin, ptmax,200, 0.0, 2.0);
2bb7ac98 1716 fhXEAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
8cc41381 1717 fhXEAssocPtBin[bin]->SetYTitle("x_{E}");
907b38cd 1718
7d306daf 1719 fhZTAssocPtBin[bin] = new TH2F(Form("hZTAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1720 Form("z_{T} vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1721 nptbins, ptmin, ptmax,200, 0.0, 2.0);
2bb7ac98 1722 fhZTAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
8cc41381 1723 fhZTAssocPtBin[bin]->SetYTitle("z_{T}");
907b38cd 1724
8cc41381 1725 outputContainer->Add(fhDeltaPhiDeltaEtaAssocPtBin[bin]) ;
1726 outputContainer->Add(fhDeltaPhiAssocPtBin[bin]) ;
1727 outputContainer->Add(fhDeltaPhiAssocPtBinDEta08[bin]) ;
1728 outputContainer->Add(fhDeltaPhiAssocPtBinDEta0[bin]) ;
1729 outputContainer->Add(fhXEAssocPtBin[bin]);
1730 outputContainer->Add(fhZTAssocPtBin[bin]);
1731
1732 if(fPi0Trigger || fDecayTrigger)
1733 {
7d306daf 1734 fhDeltaPhiDecayChargedAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtDecayChargedAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1735 Form("#Delta #phi vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1736 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1737 fhDeltaPhiDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
1738 fhDeltaPhiDecayChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 1739
7d306daf 1740 fhXEDecayChargedAssocPtBin[bin] = new TH2F(Form("hXEDecayChargedAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1741 Form("x_{E} vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1742 nptbins, ptmin, ptmax,200, 0.0, 2.0);
2bb7ac98 1743 fhXEDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
8cc41381 1744 fhXEDecayChargedAssocPtBin[bin]->SetYTitle("x_{E}");
1745
7d306daf 1746 fhZTDecayChargedAssocPtBin[bin] = new TH2F(Form("hZTDecayChargedAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1747 Form("z_{T} vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1748 nptbins, ptmin, ptmax,200, 0.0, 2.0);
2bb7ac98 1749 fhZTDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
8cc41381 1750 fhZTDecayChargedAssocPtBin[bin]->SetYTitle("z_{T}");
1751
1752 outputContainer->Add(fhDeltaPhiDecayChargedAssocPtBin[bin]) ;
1753 outputContainer->Add(fhXEDecayChargedAssocPtBin[bin]);
1754 outputContainer->Add(fhZTDecayChargedAssocPtBin[bin]);
1755
1756 }
907b38cd 1757
8cc41381 1758 if(fFillBradHisto)
1759 {
7d306daf 1760 fhDeltaPhiBradAssocPtBin[bin] = new TH2F(Form("hDeltaPhiBradPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1761 Form("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1762 nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0);
2bb7ac98 1763 fhDeltaPhiBradAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
8cc41381 1764 fhDeltaPhiBradAssocPtBin[bin]->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi");
1765 outputContainer->Add(fhDeltaPhiBradAssocPtBin[bin]) ;
1766 }
907b38cd 1767
8cc41381 1768 if(fHMPIDCorrelation)
1769 {
7d306daf 1770 fhDeltaPhiAssocPtBinHMPID[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPID", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1771 Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, with track having HMPID signal", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1772 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1773 fhDeltaPhiAssocPtBinHMPID[bin]->SetXTitle("p_{T trigger} (GeV/c)" );
1774 fhDeltaPhiAssocPtBinHMPID[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 1775
7d306daf 1776 fhDeltaPhiAssocPtBinHMPIDAcc[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPIDAcc", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
1777 Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, with track within 5<phi<20 deg", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 1778 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1779 fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetXTitle("p_{T trigger} (GeV/c)");
1780 fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 1781
7d306daf 1782 outputContainer->Add(fhDeltaPhiAssocPtBinHMPID[bin]) ;
1783 outputContainer->Add(fhDeltaPhiAssocPtBinHMPIDAcc[bin]) ;
8cc41381 1784
1785 }
1786 }
e09cf5ef 1787 }
045396c8 1788
907b38cd 1789 if(fPi0Trigger || fDecayTrigger)
547c2f01 1790 {
907b38cd 1791 if(fPi0Trigger)
1792 {
1793 fhPtPi0DecayRatio = new TH2F
764ab1f4 1794 ("hPtPi0DecayRatio","p_{T} of #pi^{0} and the ratio of pt for two decay",
907b38cd 1795 nptbins,ptmin,ptmax, 100,0.,2.);
1796 fhPtPi0DecayRatio->SetXTitle("p_{T}^{#pi^{0}} (GeV/c)");
1797 fhPtPi0DecayRatio->SetYTitle("p_{T}^{Decay}/p_{T}^{#pi^{0}}");
050ad675 1798 outputContainer->Add(fhPtPi0DecayRatio) ;
907b38cd 1799 }
e09cf5ef 1800
1801 fhDeltaPhiDecayCharged = new TH2F
babcbc9d 1802 ("hDeltaPhiDecayCharged","#phi_{Decay} - #phi_{h^{#pm}} vs p_{T Decay}",
62f2fe4d 1803 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1804 fhDeltaPhiDecayCharged->SetYTitle("#Delta #phi (rad)");
e09cf5ef 1805 fhDeltaPhiDecayCharged->SetXTitle("p_{T Decay} (GeV/c)");
1806
3f150b4b 1807 fhXEDecayCharged =
1808 new TH2F("hXEDecayCharged","x_{E} Decay",
1809 nptbins,ptmin,ptmax,200,0.,2.);
1810 fhXEDecayCharged->SetYTitle("x_{E}");
2bb7ac98 1811 fhXEDecayCharged->SetXTitle("p_{T decay} (GeV/c)");
3f150b4b 1812
1813 fhZTDecayCharged =
1814 new TH2F("hZTDecayCharged","z_{trigger h^{#pm}} = p_{T h^{#pm}} / p_{T Decay}",
e09cf5ef 1815 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1816 fhZTDecayCharged->SetYTitle("z_{decay h^{#pm}}");
2bb7ac98 1817 fhZTDecayCharged->SetXTitle("p_{T decay} (GeV/c)");
e09cf5ef 1818
e09cf5ef 1819 outputContainer->Add(fhDeltaPhiDecayCharged) ;
3f150b4b 1820 outputContainer->Add(fhXEDecayCharged) ;
1821 outputContainer->Add(fhZTDecayCharged) ;
e09cf5ef 1822 }
1823
547c2f01 1824 if(fMakeSeveralUE)
1825 {
e09cf5ef 1826 fhDeltaPhiUeLeftCharged = new TH2F
babcbc9d 1827 ("hDeltaPhiUeLeftChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left side range of trigger particles",
62f2fe4d 1828 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1829 fhDeltaPhiUeLeftCharged->SetYTitle("#Delta #phi (rad)");
e09cf5ef 1830 fhDeltaPhiUeLeftCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1831 outputContainer->Add(fhDeltaPhiUeLeftCharged) ;
1832
1833 fhDeltaPhiUeRightCharged = new TH2F
babcbc9d 1834 ("hDeltaPhiUeRightChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right side range of trigger particles",
62f2fe4d 1835 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1836 fhDeltaPhiUeRightCharged->SetYTitle("#Delta #phi (rad)");
e09cf5ef 1837 fhDeltaPhiUeRightCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1838 outputContainer->Add(fhDeltaPhiUeRightCharged) ;
1839
8cc41381 1840 fhDeltaPhiUeLeftUpCharged = new TH2F
1841 ("hDeltaPhiUeLeftUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left Up side range of trigger particles",
1842 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1843 fhDeltaPhiUeLeftUpCharged->SetYTitle("#Delta #phi (rad)");
8cc41381 1844 fhDeltaPhiUeLeftUpCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1845 outputContainer->Add(fhDeltaPhiUeLeftUpCharged) ;
1846
1847 fhDeltaPhiUeRightUpCharged = new TH2F
1848 ("hDeltaPhiUeRightUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right Up side range of trigger particles",
1849 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1850 fhDeltaPhiUeRightUpCharged->SetYTitle("#Delta #phi (rad)");
8cc41381 1851 fhDeltaPhiUeRightUpCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1852 outputContainer->Add(fhDeltaPhiUeRightUpCharged) ;
1853
1854 fhDeltaPhiUeLeftDownCharged = new TH2F
1855 ("hDeltaPhiUeLeftDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left Down side range of trigger particles",
1856 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1857 fhDeltaPhiUeLeftDownCharged->SetYTitle("#Delta #phi (rad)");
8cc41381 1858 fhDeltaPhiUeLeftDownCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1859 outputContainer->Add(fhDeltaPhiUeLeftDownCharged) ;
1860
1861 fhDeltaPhiUeRightDownCharged = new TH2F
1862 ("hDeltaPhiUeRightDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right Down side range of trigger particles",
1863 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1864 fhDeltaPhiUeRightDownCharged->SetYTitle("#Delta #phi (rad)");
8cc41381 1865 fhDeltaPhiUeRightDownCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1866 outputContainer->Add(fhDeltaPhiUeRightDownCharged) ;
1867
3f150b4b 1868 fhXEUeLeftCharged =
1869 new TH2F("hXEUeChargedLeft","x_{E} with UE left side of trigger",
e09cf5ef 1870 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1871 fhXEUeLeftCharged->SetYTitle("x_{E Ueh^{#pm}}");
2bb7ac98 1872 fhXEUeLeftCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1873 outputContainer->Add(fhXEUeLeftCharged) ;
e09cf5ef 1874
3f150b4b 1875 fhXEUeRightCharged =
1876 new TH2F("hXEUeChargedRight","x_{E h^{#pm}} with UE right side of trigger",
e09cf5ef 1877 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1878 fhXEUeRightCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
2bb7ac98 1879 fhXEUeRightCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1880 outputContainer->Add(fhXEUeRightCharged) ;
1881
8cc41381 1882 fhXEUeLeftUpCharged =
1883 new TH2F("hXEUeChargedLeftUp","x_{E} with UE left Up side of trigger",
1884 nptbins,ptmin,ptmax,200,0.,2.);
1885 fhXEUeLeftUpCharged->SetYTitle("x_{E Ueh^{#pm}}");
2bb7ac98 1886 fhXEUeLeftUpCharged->SetXTitle("p_{T trigger} (GeV/c)");
8cc41381 1887 outputContainer->Add(fhXEUeLeftUpCharged) ;
1888
1889 fhXEUeRightUpCharged =
1890 new TH2F("hXEUeChargedRightUp","x_{E h^{#pm}} with UE right Up side of trigger",
1891 nptbins,ptmin,ptmax,200,0.,2.);
1892 fhXEUeRightUpCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
2bb7ac98 1893 fhXEUeRightUpCharged->SetXTitle("p_{T trigger} (GeV/c)");
8cc41381 1894 outputContainer->Add(fhXEUeRightUpCharged) ;
1895
1896 fhXEUeLeftDownCharged =
1897 new TH2F("hXEUeChargedLeftDown","x_{E} with UE left Down side of trigger",
1898 nptbins,ptmin,ptmax,200,0.,2.);
1899 fhXEUeLeftDownCharged->SetYTitle("x_{E Ueh^{#pm}}");
2bb7ac98 1900 fhXEUeLeftDownCharged->SetXTitle("p_{T trigger} (GeV/c)");
8cc41381 1901 outputContainer->Add(fhXEUeLeftDownCharged) ;
1902
1903 fhXEUeRightDownCharged =
1904 new TH2F("hXEUeChargedRightDown","x_{E h^{#pm}} with UE right Down side of trigger",
1905 nptbins,ptmin,ptmax,200,0.,2.);
1906 fhXEUeRightDownCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
2bb7ac98 1907 fhXEUeRightDownCharged->SetXTitle("p_{T trigger} (GeV/c)");
8cc41381 1908 outputContainer->Add(fhXEUeRightDownCharged) ;
1909
3f150b4b 1910 fhPtHbpXEUeLeftCharged =
1911 new TH2F("hHbpXEUeChargedLeft","#xi = ln(1/x_{E}) with charged UE left side of trigger",
1912 nptbins,ptmin,ptmax,200,0.,10.);
1913 fhPtHbpXEUeLeftCharged->SetYTitle("ln(1/x_{E})");
2bb7ac98 1914 fhPtHbpXEUeLeftCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1915 outputContainer->Add(fhPtHbpXEUeLeftCharged) ;
e09cf5ef 1916
3f150b4b 1917 fhPtHbpXEUeRightCharged =
1918 new TH2F("hHbpXEUeChargedRight","#xi = ln(1/x_{E}) with charged UE right side of trigger",
e09cf5ef 1919 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1920 fhPtHbpXEUeRightCharged->SetYTitle("ln(1/x_{E})");
2bb7ac98 1921 fhPtHbpXEUeRightCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1922 outputContainer->Add(fhPtHbpXEUeRightCharged) ;
1923
1924 fhZTUeLeftCharged =
1925 new TH2F("hZTUeChargedLeft","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger} with UE left side of trigger",
1926 nptbins,ptmin,ptmax,200,0.,2.);
1927 fhZTUeLeftCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
2bb7ac98 1928 fhZTUeLeftCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1929 outputContainer->Add(fhZTUeLeftCharged) ;
1930
1931 fhZTUeRightCharged =
1932 new TH2F("hZTUeChargedRight","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger} with UE right side of trigger",
1933 nptbins,ptmin,ptmax,200,0.,2.);
1934 fhZTUeRightCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
2bb7ac98 1935 fhZTUeRightCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1936 outputContainer->Add(fhZTUeRightCharged) ;
e09cf5ef 1937
3f150b4b 1938 fhPtHbpZTUeLeftCharged =
1939 new TH2F("hHbpZTUeChargedLeft","#xi = ln(1/z_{T}) with charged UE left side of trigger",
e09cf5ef 1940 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1941 fhPtHbpZTUeLeftCharged->SetYTitle("ln(1/z_{T})");
2bb7ac98 1942 fhPtHbpZTUeLeftCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1943 outputContainer->Add(fhPtHbpZTUeLeftCharged) ;
1944
1945 fhPtHbpZTUeRightCharged =
1946 new TH2F("hHbpZTUeChargedRight","#xi = ln(1/z_{T}) with charged UE right side of trigger",
1947 nptbins,ptmin,ptmax,200,0.,10.);
1948 fhPtHbpZTUeRightCharged->SetYTitle("ln(1/z_{T})");
2bb7ac98 1949 fhPtHbpZTUeRightCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 1950 outputContainer->Add(fhPtHbpZTUeRightCharged) ;
e09cf5ef 1951
8cc41381 1952 }
e09cf5ef 1953 } //Correlation with charged hadrons
050ad675 1954
e09cf5ef 1955 //Correlation with neutral hadrons
547c2f01 1956 if(fNeutralCorr)
1957 {
e09cf5ef 1958 fhDeltaPhiDeltaEtaNeutral = new TH2F
babcbc9d 1959 ("hDeltaPhiDeltaEtaNeutral","#phi_{trigger} - #phi_{h^{0}} vs #eta_{trigger} - #eta_{h^{0}}",
62f2fe4d 1960 ndeltaphibins ,deltaphimin,deltaphimax, ndeltaetabins ,deltaetamin,deltaetamax);
2bb7ac98 1961 fhDeltaPhiDeltaEtaNeutral->SetXTitle("#Delta #phi (rad)");
e09cf5ef 1962 fhDeltaPhiDeltaEtaNeutral->SetYTitle("#Delta #eta");
1963
1964 fhPhiNeutral = new TH2F
babcbc9d 1965 ("hPhiNeutral","#phi_{#pi^{0}} vs p_{T #pi^{0}}",
e09cf5ef 1966 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
1967 fhPhiNeutral->SetYTitle("#phi_{#pi^{0}} (rad)");
1968 fhPhiNeutral->SetXTitle("p_{T #pi^{0}} (GeV/c)");
1969
1970 fhEtaNeutral = new TH2F
babcbc9d 1971 ("hEtaNeutral","#eta_{#pi^{0}} vs p_{T #pi^{0}}",
e09cf5ef 1972 nptbins,ptmin,ptmax,netabins,etamin,etamax);
1973 fhEtaNeutral->SetYTitle("#eta_{#pi^{0}} (rad)");
1974 fhEtaNeutral->SetXTitle("p_{T #pi^{0}} (GeV/c)");
1975
1976 fhDeltaPhiNeutral = new TH2F
babcbc9d 1977 ("hDeltaPhiNeutral","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T trigger}",
e09cf5ef 1978 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
2bb7ac98 1979 fhDeltaPhiNeutral->SetYTitle("#Delta #phi (rad)");
e09cf5ef 1980 fhDeltaPhiNeutral->SetXTitle("p_{T trigger} (GeV/c)");
1981
1982 fhDeltaPhiNeutralPt = new TH2F
babcbc9d 1983 ("hDeltaPhiNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T #pi^{0}}}",
62f2fe4d 1984 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1985 fhDeltaPhiNeutralPt->SetYTitle("#Delta #phi (rad)");
e09cf5ef 1986 fhDeltaPhiNeutralPt->SetXTitle("p_{T h^{0}} (GeV/c)");
1987
1988 fhDeltaPhiUeNeutralPt = new TH2F
babcbc9d 1989 ("hDeltaPhiUeNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T #pi^{0}}}",
62f2fe4d 1990 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 1991 fhDeltaPhiUeNeutralPt->SetYTitle("#Delta #phi (rad)");
e09cf5ef 1992 fhDeltaPhiUeNeutralPt->SetXTitle("p_{T h^{0}} (GeV/c)");
1993
1994 fhDeltaEtaNeutral = new TH2F
babcbc9d 1995 ("hDeltaEtaNeutral","#eta_{trigger} - #eta_{#pi^{0}} vs p_{T trigger}",
62f2fe4d 1996 nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax);
e09cf5ef 1997 fhDeltaEtaNeutral->SetYTitle("#Delta #eta");
1998 fhDeltaEtaNeutral->SetXTitle("p_{T trigger} (GeV/c)");
1999
3f150b4b 2000 fhXENeutral =
2001 new TH2F("hXENeutral","x_{E} for #pi^{0} associated",
e09cf5ef 2002 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 2003 fhXENeutral->SetYTitle("x_{E}");
2bb7ac98 2004 fhXENeutral->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 2005
3f150b4b 2006 fhXEUeNeutral =
2007 new TH2F("hXEUeNeutral","x_{E} for #pi^{0} associated",
e09cf5ef 2008 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 2009 fhXEUeNeutral->SetYTitle("x_{E}");
2bb7ac98 2010 fhXEUeNeutral->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 2011
3f150b4b 2012 fhPtHbpXENeutral =
2013 new TH2F("hHbpXENeutral","#xi = ln(1/x_{E})for #pi^{0} associated",
e09cf5ef 2014 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 2015 fhPtHbpXENeutral->SetYTitle("ln(1/x_{E})");
2bb7ac98 2016 fhPtHbpXENeutral->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 2017
3f150b4b 2018 fhPtHbpXEUeNeutral =
2019 new TH2F("hHbpXEUeNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated",
e09cf5ef 2020 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 2021 fhPtHbpXEUeNeutral->SetYTitle("ln(1/x_{E})");
2bb7ac98 2022 fhPtHbpXEUeNeutral->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 2023
2024 fhZTNeutral =
2025 new TH2F("hZTNeutral","z_{trigger #pi} = p_{T #pi^{0}} / p_{T trigger} for #pi^{0} associated",
2026 nptbins,ptmin,ptmax,200,0.,2.);
2027 fhZTNeutral->SetYTitle("z_{trigger #pi^{0}}");
2bb7ac98 2028 fhZTNeutral->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 2029
3f150b4b 2030 fhZTUeNeutral =
2031 new TH2F("hZTUeNeutral","z_{trigger #pi} = p_{T #pi^{0}} / p_{T trigger} for #pi^{0} associated",
2032 nptbins,ptmin,ptmax,200,0.,2.);
2033 fhZTUeNeutral->SetYTitle("z_{trigger #pi^{0}}");
2bb7ac98 2034 fhZTUeNeutral->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 2035
2036 fhPtHbpZTNeutral =
2037 new TH2F("hHbpZTNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated",
2038 nptbins,ptmin,ptmax,200,0.,10.);
2039 fhPtHbpZTNeutral->SetYTitle("ln(1/z_{T})");
2040 fhPtHbpZTNeutral->SetXTitle("p_{T trigger}");
2041
2042 fhPtHbpZTUeNeutral =
2043 new TH2F("hHbpZTUeNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated",
2044 nptbins,ptmin,ptmax,200,0.,10.);
2045 fhPtHbpXEUeNeutral->SetYTitle("ln(1/z_{T})");
2bb7ac98 2046 fhPtHbpXEUeNeutral->SetXTitle("p_{T trigger} (GeV/c)");
e09cf5ef 2047
2048 outputContainer->Add(fhDeltaPhiDeltaEtaNeutral);
2049 outputContainer->Add(fhPhiNeutral) ;
2050 outputContainer->Add(fhEtaNeutral) ;
2051 outputContainer->Add(fhDeltaPhiNeutral) ;
2052 outputContainer->Add(fhDeltaPhiNeutralPt) ;
2053 outputContainer->Add(fhDeltaPhiUeNeutralPt) ;
2054 outputContainer->Add(fhDeltaEtaNeutral) ;
3f150b4b 2055 outputContainer->Add(fhXENeutral) ;
2056 outputContainer->Add(fhXEUeNeutral) ;
2057 outputContainer->Add(fhPtHbpXENeutral) ;
2058 outputContainer->Add(fhPtHbpXEUeNeutral) ;
2059 outputContainer->Add(fhZTNeutral) ;
2060 outputContainer->Add(fhZTUeNeutral) ;
2061 outputContainer->Add(fhPtHbpZTNeutral) ;
2062 outputContainer->Add(fhPtHbpZTUeNeutral) ;
e09cf5ef 2063
907b38cd 2064 if(fPi0Trigger || fDecayTrigger)
babcbc9d 2065 {
e09cf5ef 2066 fhDeltaPhiDecayNeutral = new TH2F
babcbc9d 2067 ("hDeltaPhiDecayNeutral","#phi_{Decay} - #phi_{h^{0}} vs p_{T Decay}",
62f2fe4d 2068 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2069 fhDeltaPhiDecayNeutral->SetYTitle("#Delta #phi (rad)");
e09cf5ef 2070 fhDeltaPhiDecayNeutral->SetXTitle("p_{T Decay} (GeV/c)");
2071
3f150b4b 2072 fhXEDecayNeutral =
2073 new TH2F("hXEDecayNeutral","x_{E} for decay trigger",
2074 nptbins,ptmin,ptmax,200,0.,2.);
2075 fhXEDecayNeutral->SetYTitle("x_{E}");
2076 fhXEDecayNeutral->SetXTitle("p_{T decay}");
2077
2078 fhZTDecayNeutral =
2079 new TH2F("hZTDecayNeutral","z_{trigger h^{0}} = p_{T h^{0}} / p_{T Decay}",
e09cf5ef 2080 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 2081 fhZTDecayNeutral->SetYTitle("z_{h^{0}}");
2082 fhZTDecayNeutral->SetXTitle("p_{T decay}");
e09cf5ef 2083
2084 outputContainer->Add(fhDeltaPhiDecayNeutral) ;
3f150b4b 2085 outputContainer->Add(fhXEDecayNeutral) ;
2086 outputContainer->Add(fhZTDecayNeutral) ;
2087
e09cf5ef 2088 }
2089
547c2f01 2090 if(fMakeSeveralUE)
2091 {
e09cf5ef 2092 fhDeltaPhiUeLeftNeutral = new TH2F
babcbc9d 2093 ("hDeltaPhiUeLeftNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs p_{T h^{0}} with neutral UE left side range of trigger particles",
62f2fe4d 2094 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2095 fhDeltaPhiUeLeftNeutral->SetYTitle("#Delta #phi (rad)");
e09cf5ef 2096 fhDeltaPhiUeLeftNeutral->SetXTitle("p_{T h^{0}} (GeV/c)");
2097 outputContainer->Add(fhDeltaPhiUeLeftNeutral) ;
2098
2099 fhDeltaPhiUeRightNeutral = new TH2F
babcbc9d 2100 ("hDeltaPhiUeRightNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs p_{T Ueh^{0}} with neutral UE right side range of trigger particles",
62f2fe4d 2101 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2102 fhDeltaPhiUeRightNeutral->SetYTitle("#Delta #phi (rad)");
e09cf5ef 2103 fhDeltaPhiUeRightNeutral->SetXTitle("p_{T h^{0}} (GeV/c)");
2104 outputContainer->Add(fhDeltaPhiUeRightNeutral) ;
2105
3f150b4b 2106 fhXEUeLeftNeutral =
2107 new TH2F("hXEUeNeutralLeft","x_{E} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE left side of trigger",
2108 nptbins,ptmin,ptmax,140,0.,2.);
2109 fhXEUeLeftNeutral->SetYTitle("z_{trigger Ueh^{0}}");
2bb7ac98 2110 fhXEUeLeftNeutral->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 2111 outputContainer->Add(fhXEUeLeftNeutral) ;
2112
2113 fhXEUeRightNeutral =
2114 new TH2F("hXEUeNeutralRight","x_{E} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE right side of trigger",
2115 nptbins,ptmin,ptmax,200,0.,2.);
2116 fhXEUeRightNeutral->SetYTitle("z_{trigger Ueh^{0}}");
2bb7ac98 2117 fhXEUeRightNeutral->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 2118 outputContainer->Add(fhXEUeRightNeutral) ;
2119
2120 fhPtHbpXEUeLeftNeutral =
2121 new TH2F("hHbpXEUeNeutralLeft","#xi = ln(1/x_{E}) with neutral UE left side of trigger",
2122 nptbins,ptmin,ptmax,200,0.,10.);
2123 fhPtHbpXEUeLeftNeutral->SetYTitle("ln(1/x_{E})");
2bb7ac98 2124 fhPtHbpXEUeLeftNeutral->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 2125 outputContainer->Add(fhPtHbpXEUeLeftNeutral) ;
2126
2127 fhPtHbpXEUeRightNeutral =
2128 new TH2F("hHbpXEUeNeutralRight","#xi = ln(1/x_{E}) with neutral UE right side of trigger",
2129 nptbins,ptmin,ptmax,200,0.,10.);
2130 fhPtHbpXEUeRightNeutral->SetYTitle("ln(1/x_{E})");
2bb7ac98 2131 fhPtHbpXEUeRightNeutral->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 2132 outputContainer->Add(fhPtHbpXEUeRightNeutral) ;
2133
2134 fhZTUeLeftNeutral =
2135 new TH2F("hZTUeNeutralLeft","z_{trigger h^{0}} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE left side of trigger",
e09cf5ef 2136 nptbins,ptmin,ptmax,140,0.,2.);
3f150b4b 2137 fhZTUeLeftNeutral->SetYTitle("z_{trigger Ueh^{0}}");
2bb7ac98 2138 fhZTUeLeftNeutral->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 2139 outputContainer->Add(fhZTUeLeftNeutral) ;
e09cf5ef 2140
3f150b4b 2141 fhZTUeRightNeutral =
2142 new TH2F("hZTUeNeutralRight","z_{trigger h^{0}} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE right side of trigger",
e09cf5ef 2143 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 2144 fhZTUeRightNeutral->SetYTitle("z_{trigger Ueh^{0}}");
2bb7ac98 2145 fhZTUeRightNeutral->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 2146 outputContainer->Add(fhZTUeRightNeutral) ;
e09cf5ef 2147
3f150b4b 2148 fhPtHbpZTUeLeftNeutral =
2149 new TH2F("hHbpZTUeNeutralLeft","#xi = ln(1/z_{T}) with neutral UE left side of trigger",
e09cf5ef 2150 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 2151 fhPtHbpZTUeLeftNeutral->SetYTitle("ln(1/z_{T})");
2152 fhPtHbpZTUeLeftNeutral->SetXTitle("p_{T trigger}");
2153 outputContainer->Add(fhPtHbpZTUeLeftNeutral) ;
e09cf5ef 2154
3f150b4b 2155 fhPtHbpZTUeRightNeutral =
2156 new TH2F("hHbpZTUeNeutralRight","#xi = ln(1/z_{T}) with neutral UE right side of trigger",
e09cf5ef 2157 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 2158 fhPtHbpZTUeRightNeutral->SetYTitle("ln(1/z_{T})");
2159 fhPtHbpZTUeRightNeutral->SetXTitle("p_{T trigger}");
2160 outputContainer->Add(fhPtHbpZTUeRightNeutral) ;
e09cf5ef 2161
2162 }
fe871b21 2163
2164 }//Correlation with neutral hadrons
2165
2166 //if data is MC, fill more histograms
babcbc9d 2167 if(IsDataMC())
2168 {
2169 fh2phiLeadingParticle=new TH2F("h2phiLeadingParticle","#phi resolustion for trigger particles",nptbins,ptmin,ptmax,100,-1,1);
fe871b21 2170 fh2phiLeadingParticle->GetXaxis()->SetTitle("p_{T gen Leading} (GeV/c)");
2171 fh2phiLeadingParticle->GetYaxis()->SetTitle("(#phi_{rec}-#phi_{gen})/#phi_{gen}");
9623bf34 2172
764ab1f4 2173 fhMCPtLeading = new TH1F ("hMCPtLeading","MC : p_{T} distribution of leading particles", nptbins,ptmin,ptmax);
9623bf34 2174 fhMCPtLeading->SetXTitle("p_{T}^{trig} (GeV/c)");
08f220c8 2175
2176 fhMCPhiLeading = new TH2F ("hMCPhiLeading","MC : #phi distribution of leading Particles",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
2177 fhMCPhiLeading->SetYTitle("#phi (rad)");
2178
2179 fhMCEtaLeading = new TH2F ("hMCEtaLeading","MC : #eta distribution of leading",nptbins,ptmin,ptmax, netabins,etamin,etamax);
2180 fhMCEtaLeading->SetYTitle("#eta ");
2181
e09cf5ef 2182
fe871b21 2183 fhMCEtaCharged = new TH2F
babcbc9d 2184 ("hMCEtaCharged","MC #eta_{h^{#pm}} vs p_{T #pm}",
fe871b21 2185 nptbins,ptmin,ptmax,netabins,etamin,etamax);
2186 fhMCEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)");
2187 fhMCEtaCharged->SetXTitle("p_{T #pm} (GeV/c)");
2188
2189 fhMCPhiCharged = new TH2F
babcbc9d 2190 ("hMCPhiCharged","#MC phi_{h^{#pm}} vs p_{T #pm}",
fe871b21 2191 200,ptmin,ptmax,nphibins,phimin,phimax);
2192 fhMCPhiCharged->SetYTitle("MC #phi_{h^{#pm}} (rad)");
2193 fhMCPhiCharged->SetXTitle("p_{T #pm} (GeV/c)");
2194
2195 fhMCDeltaPhiDeltaEtaCharged = new TH2F
babcbc9d 2196 ("hMCDeltaPhiDeltaEtaCharged","#MC phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",
fe871b21 2197 140,-2.,5.,200,-2,2);
2bb7ac98 2198 fhMCDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
fe871b21 2199 fhMCDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
2200
2201 fhMCDeltaEtaCharged = new TH2F
babcbc9d 2202 ("hMCDeltaEtaCharged","MC #eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger} and p_{T assoc}",
fe871b21 2203 nptbins,ptmin,ptmax,200,-2,2);
2204 fhMCDeltaEtaCharged->SetYTitle("#Delta #eta");
2205 fhMCDeltaEtaCharged->SetXTitle("p_{T trigger} (GeV/c)");
2206
2207 fhMCDeltaPhiCharged = new TH2F
babcbc9d 2208 ("hMCDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",
62f2fe4d 2209 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2210 fhMCDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
fe871b21 2211 fhMCDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)");
2212
2213 fhMCDeltaPhiChargedPt = new TH2F
babcbc9d 2214 ("hMCDeltaPhiChargedPt","MC #phi_{trigger} - #phi_{#h^{#pm}} vs p_{T h^{#pm}}",
62f2fe4d 2215 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2216 fhMCDeltaPhiChargedPt->SetYTitle("#Delta #phi (rad)");
fe871b21 2217 fhMCDeltaPhiChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
2218
3f150b4b 2219 fhMCPtXECharged =
2220 new TH2F("hMCPtXECharged","x_{E}",
fe871b21 2221 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 2222 fhMCPtXECharged->SetYTitle("x_{E}");
2bb7ac98 2223 fhMCPtXECharged->SetXTitle("p_{T trigger} (GeV/c)");
9623bf34 2224
2225 fhMCPtXEUeCharged =
2226 new TH2F("hMCPtXEUeCharged","x_{E}",
2227 nptbins,ptmin,ptmax,200,0.,2.);
2228 fhMCPtXEUeCharged->SetYTitle("x_{E}");
2bb7ac98 2229 fhMCPtXEUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
fe871b21 2230
3f150b4b 2231 fhMCPtHbpXECharged =
2232 new TH2F("hMCHbpXECharged","MC #xi = ln(1/x_{E}) with charged hadrons",
fe871b21 2233 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 2234 fhMCPtHbpXECharged->SetYTitle("ln(1/x_{E})");
2235 fhMCPtHbpXECharged->SetXTitle("p_{T trigger}");
9623bf34 2236
2237 fhMCPtHbpXEUeCharged =
2238 new TH2F("hMCPtHbpXEUeCharged","#xi = ln(1/x_{E}) with charged hadrons,Underlying Event",
2239 nptbins,ptmin,ptmax,200,0.,10.);
2240 fhMCPtHbpXEUeCharged->SetYTitle("ln(1/x_{E})");
2bb7ac98 2241 fhMCPtHbpXEUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
9623bf34 2242
2243 fhMCUePart =
2244 new TH1F("hMCUePart","MC UE particles distribution vs pt trig",
2245 nptbins,ptmin,ptmax);
2246 fhMCUePart->SetYTitle("dNch");
2bb7ac98 2247 fhMCUePart->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 2248
2249 fhMCPtZTCharged =
2250 new TH2F("hMCPtZTCharged","z_{T}",
2251 nptbins,ptmin,ptmax,200,0.,2.);
2252 fhMCPtZTCharged->SetYTitle("z_{T}");
2bb7ac98 2253 fhMCPtZTCharged->SetXTitle("p_{T trigger} (GeV/c)");
3f150b4b 2254
2255 fhMCPtHbpZTCharged =
2256 new TH2F("hMCHbpZTCharged","MC #xi = ln(1/z_{T}) with charged hadrons",
2257 nptbins,ptmin,ptmax,200,0.,10.);
2258 fhMCPtHbpZTCharged->SetYTitle("ln(1/z_{T})");
2bb7ac98 2259 fhMCPtHbpZTCharged->SetXTitle("p_{T trigger} (GeV/c)");
fe871b21 2260
2261 fhMCPtTrigPout =
babcbc9d 2262 new TH2F("hMCPtTrigPout","AOD MC Pout with triggers",
fe871b21 2263 nptbins,ptmin,ptmax,2*nptbins,-ptmax,ptmax);
2264 fhMCPtTrigPout->SetYTitle("p_{out} (GeV/c)");
2265 fhMCPtTrigPout->SetXTitle("p_{T trigger} (GeV/c)");
2266
2267 fhMCPtAssocDeltaPhi =
babcbc9d 2268 new TH2F("hMCPtAssocDeltaPhi","AOD MC delta phi with associated charged hadrons",
62f2fe4d 2269 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2270 fhMCPtAssocDeltaPhi->SetYTitle("#Delta #phi (rad)");
fe871b21 2271 fhMCPtAssocDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)");
2272
2273 outputContainer->Add(fh2phiLeadingParticle);
9623bf34 2274 outputContainer->Add(fhMCPtLeading);
08f220c8 2275 outputContainer->Add(fhMCPhiLeading);
2276 outputContainer->Add(fhMCEtaLeading);
fe871b21 2277 outputContainer->Add(fhMCDeltaPhiDeltaEtaCharged);
2278 outputContainer->Add(fhMCPhiCharged) ;
2279 outputContainer->Add(fhMCEtaCharged) ;
2280 outputContainer->Add(fhMCDeltaEtaCharged) ;
2281 outputContainer->Add(fhMCDeltaPhiCharged) ;
2282
2283 outputContainer->Add(fhMCDeltaPhiChargedPt) ;
3f150b4b 2284 outputContainer->Add(fhMCPtXECharged) ;
9623bf34 2285 outputContainer->Add(fhMCPtXEUeCharged) ;
3f150b4b 2286 outputContainer->Add(fhMCPtZTCharged) ;
2287 outputContainer->Add(fhMCPtHbpXECharged) ;
9623bf34 2288 outputContainer->Add(fhMCPtHbpXEUeCharged);
2289 outputContainer->Add(fhMCUePart);
3f150b4b 2290 outputContainer->Add(fhMCPtHbpZTCharged) ;
fe871b21 2291 outputContainer->Add(fhMCPtTrigPout) ;
2292 outputContainer->Add(fhMCPtAssocDeltaPhi) ;
2293 } //for MC histogram
2294
2e876d85 2295 if(DoOwnMix())
029dea5a 2296 {
2297 //create event containers
029dea5a 2298
283f989c 2299 if(!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForTracksExists()))
2e876d85 2300 {
d07ffd54 2301 Int_t nvz = GetNZvertBin();
2302 Int_t nrp = GetNRPBin();
2303 Int_t nce = GetNCentrBin();
283f989c 2304
d07ffd54 2305 fListMixTrackEvents= new TList*[nvz*nrp*nce] ;
2306
2307 for( Int_t ice = 0 ; ice < nce ; ice++ )
2308 {
2309 for( Int_t ivz = 0 ; ivz < nvz ; ivz++ )
2310 {
2311 for( Int_t irp = 0 ; irp < nrp ; irp++ )
2312 {
2313 Int_t bin = GetEventMixBin(ice,ivz,irp); //ic*nvz*nrp+iz*nrp+irp;
2314
2315 //printf("GetCreateOutputObjects - Bins : cent %d, vz %d, RP %d, event %d/%d\n",
2316 // ic,iz, irp, bin);
2317
2318 fListMixTrackEvents[bin] = new TList() ;
2319 fListMixTrackEvents[bin]->SetOwner(kFALSE);
2320 }
2321 }
2322 }
2323 }
d0b625bc 2324
764ab1f4 2325 fhPtLeadingMixed = new TH1F ("hPtLeadingMixed","p_{T} distribution of leading particles, used for mixing", nptbins,ptmin,ptmax);
d0b625bc 2326 fhPtLeadingMixed->SetXTitle("p_{T}^{trig} (GeV/c)");
ca17b39f 2327
7d306daf 2328 if(fCorrelVzBin)
2329 {
764ab1f4 2330 fhPtLeadingMixedVzBin = new TH2F ("hPtLeadingMixedVzBin","p_{T} distribution of leading particles, used for mixing", nptbins,ptmin,ptmax,GetNZvertBin(),0,GetNZvertBin());
7d306daf 2331 fhPtLeadingMixedVzBin->SetXTitle("p_{T}^{trig} (GeV/c)");
2332 fhPtLeadingMixedVzBin->SetYTitle("v_{z} bin");
2333 outputContainer->Add(fhPtLeadingMixedVzBin);
2334 }
2335
764ab1f4 2336 fhPtLeadingMixedBin = new TH2F ("hPtLeadingMixedBin","p_{T} distribution of leading particles vs mixing bin", nptbins,ptmin,ptmax,nMixBins,0,nMixBins);
d0b625bc 2337 fhPtLeadingMixedBin->SetXTitle("p_{T}^{trig} (GeV/c)");
2338 fhPtLeadingMixedBin->SetYTitle("Bin");
d07ffd54 2339
d0b625bc 2340 fhPhiLeadingMixed = new TH2F ("hPhiLeadingMixed","#phi distribution of leading Particles, used for mixing",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
2341 fhPhiLeadingMixed->SetYTitle("#phi (rad)");
2342
2343 fhEtaLeadingMixed = new TH2F ("hEtaLeadingMixed","#eta distribution of leading, used for mixing",nptbins,ptmin,ptmax, netabins,etamin,etamax);
2344 fhEtaLeadingMixed->SetYTitle("#eta ");
2345
2346 outputContainer->Add(fhPtLeadingMixed);
2347 outputContainer->Add(fhPtLeadingMixedBin);
2348 outputContainer->Add(fhPhiLeadingMixed);
2349 outputContainer->Add(fhEtaLeadingMixed);
2350
2bb7ac98 2351 // Fill the cluster pool only in isolation analysis or if requested
2352 if( ( OnlyIsolated() || fFillNeutralEventMixPool) &&
2353 (!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForCaloExists())))
d07ffd54 2354 {
7ed3a248 2355 Int_t nvz = GetNZvertBin();
2356 Int_t nrp = GetNRPBin();
2357 Int_t nce = GetNCentrBin();
2358
d07ffd54 2359 fListMixCaloEvents= new TList*[nvz*nrp*nce] ;
7ed3a248 2360
2361 for( Int_t ice = 0 ; ice < nce ; ice++ )
2e876d85 2362 {
7ed3a248 2363 for( Int_t ivz = 0 ; ivz < nvz ; ivz++ )
2e876d85 2364 {
7ed3a248 2365 for( Int_t irp = 0 ; irp < nrp ; irp++ )
283f989c 2366 {
7ed3a248 2367 Int_t bin = GetEventMixBin(ice,ivz,irp); //ic*nvz*nrp+iz*nrp+irp;
2368
da3c40f7 2369 //printf("GetCreateOutputObjects - Bins : cent %d, vz %d, RP %d, event %d/%d\n",
7ed3a248 2370 // ic,iz, irp, bin);
2371
d07ffd54 2372 fListMixCaloEvents[bin] = new TList() ;
2373 fListMixCaloEvents[bin]->SetOwner(kFALSE);
283f989c 2374 }
2e876d85 2375 }
283f989c 2376 }
2377 }
2378
2379 //Init the list in the reader if not done previously
d07ffd54 2380 if(fUseMixStoredInReader)
283f989c 2381 {
d07ffd54 2382 if( !GetReader()->ListWithMixedEventsForTracksExists() )
2383 GetReader()->SetListWithMixedEventsForTracks(fListMixTrackEvents);
2384
2385 if( !GetReader()->ListWithMixedEventsForCaloExists() )
2386 GetReader()->SetListWithMixedEventsForCalo (fListMixCaloEvents );
283f989c 2387 }
029dea5a 2388
2e876d85 2389 fhEventBin=new TH1I("hEventBin","Number of real events per bin(cen,vz,rp)",
2390 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
2391 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
2392 fhEventBin->SetXTitle("bin");
2393 outputContainer->Add(fhEventBin) ;
283f989c 2394
2e876d85 2395 fhEventMixBin=new TH1I("hEventMixBin","Number of events per bin(cen,vz,rp)",
2396 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
2397 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
2398 fhEventMixBin->SetXTitle("bin");
2399 outputContainer->Add(fhEventMixBin) ;
283f989c 2400
2e876d85 2401 fhNtracksMB=new TH1F("hNtracksMBEvent","Number of tracks w/ event trigger kMB",2000,0,2000);
2402 outputContainer->Add(fhNtracksMB);
029dea5a 2403
2bb7ac98 2404 if(fFillNeutralEventMixPool || OnlyIsolated())
2405 {
2bb7ac98 2406 fhNclustersMB=new TH1F("hNclustersMBEvent","Number of clusters w/ event trigger kMB",2000,0,2000);
2407 outputContainer->Add(fhNclustersMB);
2408 }
2409
029dea5a 2410 fhMixDeltaPhiCharged = new TH2F
2411 ("hMixDeltaPhiCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",
62f2fe4d 2412 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2413 fhMixDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
029dea5a 2414 fhMixDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)");
2415 outputContainer->Add(fhMixDeltaPhiCharged);
283f989c 2416
029dea5a 2417 fhMixDeltaPhiDeltaEtaCharged = new TH2F
2418 ("hMixDeltaPhiDeltaEtaCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",
62f2fe4d 2419 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
2bb7ac98 2420 fhMixDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
029dea5a 2421 fhMixDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
2422 outputContainer->Add(fhMixDeltaPhiDeltaEtaCharged);
283f989c 2423
08f220c8 2424 fhMixXECharged =
2425 new TH2F("hMixXECharged","Mixed event : x_{E} for charged tracks",
2426 nptbins,ptmin,ptmax,200,0.,2.);
2427 fhMixXECharged->SetYTitle("x_{E}");
2bb7ac98 2428 fhMixXECharged->SetXTitle("p_{T trigger} (GeV/c)");
08f220c8 2429 outputContainer->Add(fhMixXECharged);
18838011 2430
2431 fhMixXEUeCharged =
2432 new TH2F("hMixXEUeCharged","Mixed event : x_{E} for charged tracks in Ue region",
2433 nptbins,ptmin,ptmax,200,0.,2.);
2434 fhMixXEUeCharged->SetYTitle("x_{E}");
2435 fhMixXEUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
2436 outputContainer->Add(fhMixXEUeCharged);
08f220c8 2437
18838011 2438 fhMixHbpXECharged =
08f220c8 2439 new TH2F("hMixHbpXECharged","mixed event : #xi = ln(1/x_{E}) with charged hadrons",
2440 nptbins,ptmin,ptmax,200,0.,10.);
2441 fhMixHbpXECharged->SetYTitle("ln(1/x_{E})");
2bb7ac98 2442 fhMixHbpXECharged->SetXTitle("p_{T trigger} (GeV/c)");
08f220c8 2443 outputContainer->Add(fhMixHbpXECharged);
2444
7d306daf 2445 fhMixDeltaPhiChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
2446 fhMixDeltaPhiChargedAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz];
2447 fhMixDeltaPhiChargedAssocPtBinDEta0 = new TH2F*[fNAssocPtBins*nz];
2448 fhMixDeltaPhiDeltaEtaChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
283f989c 2449
029dea5a 2450 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
8cc41381 2451 {
7d306daf 2452 for(Int_t z = 0 ; z < nz ; z++)
8cc41381 2453 {
7d306daf 2454 Int_t bin = i*nz+z;
8cc41381 2455
7d306daf 2456 if(fCorrelVzBin)
2457 {
2458 sz = "_vz%d"+z;
2459 tz = ", v_{z} bin "+z;
2460 }
2461
2462 //printf("MIX : iAssoc %d, Vz %d, bin %d - sz %s, tz %s \n",i,z,bin,sz.Data(),tz.Data());
2463
2464 fhMixDeltaPhiChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
2465 Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 2466 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2467 fhMixDeltaPhiChargedAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
2468 fhMixDeltaPhiChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 2469
7d306daf 2470 fhMixDeltaPhiChargedAssocPtBinDEta08[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0.8ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
2471 Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 2472 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2473 fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetXTitle("p_{T trigger} (GeV/c)");
2474 fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 2475
7d306daf 2476 fhMixDeltaPhiChargedAssocPtBinDEta0[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
2477 Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 2478 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
2bb7ac98 2479 fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetXTitle("p_{T trigger} (GeV/c)");
2480 fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)");
8cc41381 2481
7d306daf 2482 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiDeltaEtaChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
2483 Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
8cc41381 2484 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
2bb7ac98 2485 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)");
8cc41381 2486 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetYTitle("#Delta #eta");
2487
2488 outputContainer->Add(fhMixDeltaPhiChargedAssocPtBin[bin]);
2489 outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta08[bin]);
2490 outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta0[bin]);
2491 outputContainer->Add(fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]);
2492 }
050ad675 2493 }
029dea5a 2494 }
7d306daf 2495
e09cf5ef 2496 return outputContainer;
2497
2498}
2499
907b38cd 2500//_________________________________________________________________________________________________
2501Bool_t AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum(const AliAODPWG4Particle* trigger,
2502 TLorentzVector & mom1,
2503 TLorentzVector & mom2)
2504{
2505 // Get the momentum of the pi0/eta assigned decay photons
2506 // In case of pi0/eta trigger, we may want to check their decay correlation,
2507 // get their decay children
2508
2509 Int_t indexPhoton1 = trigger->GetCaloLabel(0);
2510 Int_t indexPhoton2 = trigger->GetCaloLabel(1);
2511 Float_t ptTrig = trigger->Pt();
2512
2513 if(indexPhoton1!=-1 || indexPhoton2!=-1) return kFALSE;
2514
2515 if(GetDebug() > 1)
2516 printf("AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum() - indexPhoton1 = %d, indexPhoton2 = %d \n", indexPhoton1, indexPhoton2);
2517
2518 TObjArray * clusters = 0x0 ;
2519 if(trigger->GetDetector()=="EMCAL") clusters = GetEMCALClusters() ;
2520 else clusters = GetPHOSClusters() ;
2521
2522 for(Int_t iclus = 0; iclus < clusters->GetEntriesFast(); iclus++)
2523 {
2524 AliVCluster * photon = (AliVCluster*) (clusters->At(iclus));
2525 if(photon->GetID()==indexPhoton1)
2526 {
2527 photon->GetMomentum(mom1,GetVertex(0)) ;
2528 if(ptTrig) fhPtPi0DecayRatio->Fill(ptTrig, mom1.Pt()/ptTrig);
2529 }
2530 if(photon->GetID()==indexPhoton2)
2531 {
2532 photon->GetMomentum(mom1,GetVertex(0)) ;
2533 if(ptTrig > 0) fhPtPi0DecayRatio->Fill(ptTrig, mom2.Pt()/ptTrig);
2534 }
2535
2536 if(GetDebug() > 1)printf("AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum() - Photon1 = %f, Photon2 = %f \n", mom1.Pt(), mom2.Pt());
2537
2538 } //cluster loop
2539
2540 return kTRUE;
2541
2542}
2543
b1f720a7 2544//_____________________________________________________________
22ad7981 2545Int_t AliAnaParticleHadronCorrelation::GetMCTagHistogramIndex(Int_t mcTag)
b1f720a7 2546{
2547 // Index of MC histograms depending on MC origin
2548
2549 if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPrompt) ||
2550 GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCFragmentation)) return 0;
2551 else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0)) return 1;
2552 else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0Decay)) return 2;
2553 else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay)) return 3;
2554 else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCOtherDecay)) return 4;
2555 else if(!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron)) return 5;
2556 else return 6;
2557
2558}
2559
05d0d05d 2560//____________________________________________________
e09cf5ef 2561void AliAnaParticleHadronCorrelation::InitParameters()
2562{
2563
2564 //Initialize the parameters of the analysis.
e4c0a0eb 2565 SetInputAODName("Particle");
e09cf5ef 2566 SetAODObjArrayName("Hadrons");
2567 AddToHistogramsName("AnaHadronCorr_");
045396c8 2568
e09cf5ef 2569 SetPtCutRange(0.,300);
045396c8 2570 fDeltaPhiMinCut = 1.5 ;
2571 fDeltaPhiMaxCut = 4.5 ;
2572 fSelectIsolated = kFALSE;
2573 fMakeSeveralUE = kFALSE;
2574 fUeDeltaPhiMinCut = 1. ;
2575 fUeDeltaPhiMaxCut = 1.5 ;
907b38cd 2576
045396c8 2577 fNeutralCorr = kFALSE ;
2578 fPi0Trigger = kFALSE ;
907b38cd 2579 fDecayTrigger = kFALSE ;
2580 fHMPIDCorrelation = kFALSE ;
045396c8 2581
3f150b4b 2582 fMakeAbsoluteLeading = kTRUE;
2583 fMakeNearSideLeading = kFALSE;
2584
050ad675 2585 fNAssocPtBins = 9 ;
2586 fAssocPtBinLimit[0] = 0.2 ;
f85f4afb 2587 fAssocPtBinLimit[1] = 0.5 ;
2588 fAssocPtBinLimit[2] = 1.0 ;
2589 fAssocPtBinLimit[3] = 2.0 ;
2590 fAssocPtBinLimit[4] = 3.0 ;
2591 fAssocPtBinLimit[5] = 4.0 ;
2592 fAssocPtBinLimit[6] = 5.0 ;
2593 fAssocPtBinLimit[7] = 6.0 ;
2594 fAssocPtBinLimit[8] = 7.0 ;
2595 fAssocPtBinLimit[9] = 8.0 ;
2596 fAssocPtBinLimit[10] = 9.0 ;
2597 fAssocPtBinLimit[11] = 10.0 ;
2598 fAssocPtBinLimit[12] = 12.0 ;
2599 fAssocPtBinLimit[13] = 14.0 ;
2600 fAssocPtBinLimit[14] = 16.0 ;
2601 fAssocPtBinLimit[15] = 20.0 ;
2602 fAssocPtBinLimit[16] = 30.0 ;
2603 fAssocPtBinLimit[17] = 40.0 ;
2604 fAssocPtBinLimit[18] = 50.0 ;
2605 fAssocPtBinLimit[19] = 200.0 ;
2606
045396c8 2607
283f989c 2608 fUseMixStoredInReader = kTRUE;
2609
e4c0a0eb 2610 fM02MinCut = -1 ;
2611 fM02MaxCut = -1 ;
2612
e09cf5ef 2613}
2614
05d0d05d 2615//__________________________________________________________
e09cf5ef 2616void AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD()
2617{
2618 //Particle-Hadron Correlation Analysis, fill AODs
2619
547c2f01 2620 if(!GetInputAODBranch())
2621 {
e09cf5ef 2622 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - No input particles in AOD with name branch < %s >, STOP \n",GetInputAODName().Data());
2623 abort();
2624 }
2625
547c2f01 2626 if(strcmp(GetInputAODBranch()->GetClass()->GetName(), "AliAODPWG4ParticleCorrelation"))
2627 {
e09cf5ef 2628 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - Wrong type of AOD object, change AOD class name in input AOD: It should be <AliAODPWG4ParticleCorrelation> and not <%s> \n",GetInputAODBranch()->GetClass()->GetName());
2629 abort();
2630 }
2631
283f989c 2632 if(GetDebug() > 1)
2633 {
e09cf5ef 2634 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - Begin hadron correlation analysis, fill AODs \n");
2635 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast());
66e64043 2636 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In CTS aod entries %d\n", GetCTSTracks() ->GetEntriesFast());
e09cf5ef 2637 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetEMCALClusters()->GetEntriesFast());
66e64043 2638 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In PHOS aod entries %d\n", GetPHOSClusters() ->GetEntriesFast());
e09cf5ef 2639 }
2640
045396c8 2641 //Get the vertex and check it is not too large in z
2642 Double_t v[3] = {0,0,0}; //vertex ;
2643 GetReader()->GetVertex(v);
2644 if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ;
31864468 2645
045396c8 2646 //Loop on stored AOD particles, find leading trigger
66e64043 2647 Double_t ptTrig = fMinTriggerPt ;
045396c8 2648 fLeadingTriggerIndex = -1 ;
2649 Int_t naod = GetInputAODBranch()->GetEntriesFast() ;
04f7a616 2650 for(Int_t iaod = 0; iaod < naod ; iaod++)
2651 {
e09cf5ef 2652 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
045396c8 2653
04f7a616 2654 // Vertex cut in case of mixing
2655 Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0));
2656 if(check == 0) continue;
2657 if(check == -1) return;
2658
045396c8 2659 // find the leading particles with highest momentum
547c2f01 2660 if (particle->Pt() > ptTrig)
2661 {
045396c8 2662 ptTrig = particle->Pt() ;
2663 fLeadingTriggerIndex = iaod ;
2664 }
2665 }// finish search of leading trigger particle
e09cf5ef 2666
66e64043 2667
e09cf5ef 2668 //Do correlation with leading particle
547c2f01 2669 if(fLeadingTriggerIndex >= 0)
2670 {
e09cf5ef 2671
045396c8 2672 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(fLeadingTriggerIndex));
2673
2674 //check if the particle is isolated or if we want to take the isolation into account
2675 if(OnlyIsolated() && !particle->IsIsolated()) return;
2676
e09cf5ef 2677 //Make correlation with charged hadrons
045396c8 2678 Bool_t okcharged = kTRUE;
2679 Bool_t okneutral = kTRUE;
e09cf5ef 2680 if(GetReader()->IsCTSSwitchedOn() )
045396c8 2681 okcharged = MakeChargedCorrelation(particle, GetCTSTracks(),kFALSE);
e09cf5ef 2682
2683 TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); //For the future, foresee more possible pi0 lists
2684 if(fNeutralCorr && pi0list && pi0list->GetEntriesFast() > 0)
045396c8 2685 okneutral = MakeNeutralCorrelation(particle, pi0list,kFALSE);
e09cf5ef 2686
2687 }//Correlate leading
2688
2689 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - End fill AODs \n");
2690
2691}
2692
05d0d05d 2693//_________________________________________________________________
e09cf5ef 2694void AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms()
2695{
2696 //Particle-Hadron Correlation Analysis, fill histograms
2697
3f150b4b 2698 if(!GetInputAODBranch())
2699 {
e09cf5ef 2700 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - No input particles in AOD with name branch < %s >, STOP \n",GetInputAODName().Data());
2701 abort();
2702 }
2703
3f150b4b 2704 if(GetDebug() > 1)
2705 {
e09cf5ef 2706 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Begin hadron correlation analysis, fill histograms \n");
2707 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast());
2708 }
babcbc9d 2709
e09cf5ef 2710 //Get the vertex and check it is not too large in z
2711 Double_t v[3] = {0,0,0}; //vertex ;
2712 GetReader()->GetVertex(v);
2713 if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ;
2714
c8710850 2715 Float_t cen = GetEventCentrality();
2716 Float_t ep = GetEventPlaneAngle();
2717
e09cf5ef 2718 //Loop on stored AOD particles, find leading
66e64043 2719 Double_t ptTrig = fMinTriggerPt;
04f7a616 2720 if(fLeadingTriggerIndex < 0)
2721 {
2722 //Search leading if not done before
045396c8 2723 Int_t naod = GetInputAODBranch()->GetEntriesFast() ;
547c2f01 2724 for(Int_t iaod = 0; iaod < naod ; iaod++)
2725 { //loop on input trigger AOD file
045396c8 2726 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
04f7a616 2727
2728 // Vertex cut in case of mixing
2729 Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0));
2730 if(check == 0) continue;
2731 if(check == -1) return;
9623bf34 2732
045396c8 2733 //check if the particle is isolated or if we want to take the isolation into account
2734 if(OnlyIsolated() && !particle->IsIsolated()) continue;
e09cf5ef 2735
045396c8 2736 //find the leading particles with highest momentum
547c2f01 2737 if (particle->Pt() > ptTrig)
2738 {
045396c8 2739 ptTrig = particle->Pt() ;
2740 fLeadingTriggerIndex = iaod ;
e09cf5ef 2741 }
547c2f01 2742
2743 }// Finish search of leading trigger particle
2744 }// Search leading if not done before
045396c8 2745
547c2f01 2746 if(fLeadingTriggerIndex >= 0 )
2747 { //using trigger particle to do correlations
2748
045396c8 2749 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(fLeadingTriggerIndex));
06d3bad7 2750
e4c0a0eb 2751 // check if it was a calorimeter cluster and if the SS cut was requested, if so, apply it
2752 Int_t clID1 = particle->GetCaloLabel(0) ;
2753 Int_t clID2 = particle->GetCaloLabel(1) ; // for photon clusters should not be set.
2754 //printf("Leading for for %s: id1 %d, id2 %d, min %f, max %f, det %s\n",
2755 // GetInputAODName().Data(),clID1,clID2,fM02MinCut,fM02MaxCut,(particle->GetDetector()).Data());
2756
2757 if(clID1 > 0 && clID2 < 0 && fM02MaxCut > 0 && fM02MinCut > 0)
2758 {
2759 Int_t iclus = -1;
2760 TObjArray* clusters = 0x0;
2761 if (particle->GetDetector() == "EMCAL") clusters = GetEMCALClusters();
2762 else if(particle->GetDetector() == "PHOS" ) clusters = GetPHOSClusters();
2763
2764 if(clusters)
2765 {
2766 AliVCluster *cluster = FindCluster(clusters,clID1,iclus);
2767 Float_t m02 = cluster->GetM02();
2768 //printf("\t Check m02 = %2.2f\n",m02);
2769 if(m02 > fM02MaxCut || m02 < fM02MinCut)
2770 {
2771 //printf("\t \t Not accepted\n");
2772 return;
2773 }
2774 }
2775 }
2776
7d306daf 2777 // Check if the particle is isolated or if we want to take the isolation into account
2778 if(OnlyIsolated() && !particle->IsIsolated()) return;
2779
2780 Float_t pt = particle->Pt();
2781 fhPtInput->Fill(pt);
2782
547c2f01 2783 // Check if trigger is in fiducial region
2784 if(IsFiducialCutOn())
2785 {
2786 Bool_t in = GetFiducialCut()->IsInFiducialCut(*particle->Momentum(),particle->GetDetector()) ;
2787 if(! in ) return ;
9623bf34 2788 }
547c2f01 2789
7d306daf 2790 fhPtFidCut->Fill(pt);
2791
547c2f01 2792 // Make correlation with charged hadrons
045396c8 2793 Bool_t okcharged = kTRUE;
2794 Bool_t okneutral = kTRUE;
547c2f01 2795 if(GetReader()->IsCTSSwitchedOn() )
2796 {
045396c8 2797 okcharged = MakeChargedCorrelation(particle, GetCTSTracks(),kTRUE);
547c2f01 2798 if(IsDataMC())
2799 {
045396c8 2800 MakeMCChargedCorrelation(particle);
2801 }
a5f1e836 2802 }
2803
e09cf5ef 2804 TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); //For the future, foresee more possible pi0 lists
547c2f01 2805 if(fNeutralCorr && pi0list)
2806 {
a5f1e836 2807 if(pi0list->GetEntriesFast() > 0)
2808 okneutral = MakeNeutralCorrelation(particle, pi0list,kTRUE);
2809 }
e09cf5ef 2810
045396c8 2811 // Fill leading particle histogram if correlation went well and
2812 // no problem was found, like not absolute leading, or bad vertex in mixing.
547c2f01 2813 if(okcharged && okneutral)
2814 {
7d306daf 2815 fhPtLeading->Fill(pt);
d0b625bc 2816 fhPtLeadingBin->Fill(pt,GetEventMixBin());
7d306daf 2817 if(fCorrelVzBin) fhPtLeadingVzBin->Fill(pt,GetEventVzBin());
17af6e24 2818
2819 if(fFillPileUpHistograms)
2820 {
cc944149 2821 Int_t vtxBC = GetReader()->GetVertexBC();
2822 if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtLeadingVtxBC0->Fill(pt);
2823
17af6e24 2824 if(GetReader()->IsPileUpFromSPD()) fhPtLeadingPileUp[0]->Fill(pt);
2825 if(GetReader()->IsPileUpFromEMCal()) fhPtLeadingPileUp[1]->Fill(pt);
2826 if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtLeadingPileUp[2]->Fill(pt);
2827 if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtLeadingPileUp[3]->Fill(pt);
2828 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtLeadingPileUp[4]->Fill(pt);
2829 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtLeadingPileUp[5]->Fill(pt);
2830 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtLeadingPileUp[6]->Fill(pt);
2831 }
2832
045396c8 2833 Float_t phi = particle->Phi();
2834 if(phi<0)phi+=TMath::TwoPi();
68cd2624 2835 fhPhiLeading->Fill(pt, phi);
2836
2837 fhEtaLeading->Fill(pt, particle->Eta());
283f989c 2838 //printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Leading particle : pt %f, eta %f, phi %f\n",particle->Pt(),particle->Eta(),phi);
68cd2624 2839
764ab1f4 2840 if(IsDataMC())
2841 {
b1f720a7 2842 Int_t mcIndex = GetMCTagHistogramIndex(particle->GetTag());
2843 fhPtLeadingMC[mcIndex]->Fill(pt);
764ab1f4 2844 }
c8710850 2845
68cd2624 2846 fhPtLeadingCentrality ->Fill(pt,cen);
2847 fhPtLeadingEventPlane ->Fill(pt,ep);
2848 fhLeadingEventPlaneCentrality->Fill(cen,ep);
2849
045396c8 2850 }//ok charged && neutral
e09cf5ef 2851 }//Aod branch loop
2852
045396c8 2853 //Reinit for next event
2854 fLeadingTriggerIndex = -1;
e09cf5ef 2855
045396c8 2856 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - End fill histograms \n");
e09cf5ef 2857}
2858
c5693f62 2859//___________________________________________________________________________________________________________
045396c8 2860Bool_t AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle,
22ad7981 2861 const TObjArray* pl, Bool_t bFillHisto)
e09cf5ef 2862{
2863 // Charged Hadron Correlation Analysis
283f989c 2864 if(GetDebug() > 1)
2865 printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Make trigger particle - charged hadron correlation \n");
907b38cd 2866
2867 Float_t phiTrig = aodParticle->Phi();
2868 Float_t etaTrig = aodParticle->Eta();
2869 Float_t ptTrig = aodParticle->Pt();
2870 Bool_t decay = aodParticle->IsTagged();
b1f720a7 2871 Int_t mcTag = aodParticle->GetTag();
fedea415 2872 Double_t bz = GetReader()->GetInputEvent()->GetMagneticField();
2873
907b38cd 2874 Float_t pt = -100. ;
2875 Float_t zT = -100. ;
2876 Float_t xE = -100. ;
2877 Float_t hbpXE = -100. ;
2878 Float_t hbpZT = -100. ;
2879 Float_t phi = -100. ;
2880 Float_t eta = -100. ;
2881 Float_t pout = -100. ;
2882 Float_t deltaPhi = -100. ;
e09cf5ef 2883
907b38cd 2884 TVector3 p3;
2885 TLorentzVector photonMom ;
2886 TObjArray * reftracks = 0x0;
2887 Int_t nrefs = 0;
2888 Int_t nTracks = GetCTSTracks()->GetEntriesFast() ;
2889
2890 // Mixed event settings
2891 Int_t evtIndex11 = -1 ; // cluster trigger or pi0 trigger
045396c8 2892 Int_t evtIndex12 = -1 ; // pi0 trigger
2893 Int_t evtIndex13 = -1 ; // charged trigger
045396c8 2894
2895 Double_t v[3] = {0,0,0}; //vertex ;
e09cf5ef 2896 GetReader()->GetVertex(v);
e09cf5ef 2897
04f7a616 2898 if (GetMixedEvent())
2899 {
e09cf5ef 2900 evtIndex11 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(0)) ;
2901 evtIndex12 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(1)) ;
2902 evtIndex13 = GetMixedEvent()->EventIndex(aodParticle->GetTrackLabel(0)) ;
2903 }
2904
907b38cd 2905 // In case of pi0/eta trigger, we may want to check their decay correlation,
2906 // get their decay children
2907 TLorentzVector decayMom1;
2908 TLorentzVector decayMom2;
2909 Bool_t decayFound = kFALSE;
2910 if(fPi0Trigger && bFillHisto) decayFound = GetDecayPhotonMomentum(aodParticle,decayMom1, decayMom2);
2911
2912 //-----------------------------------------------------------------------
e09cf5ef 2913 //Track loop, select tracks with good pt, phi and fill AODs or histograms
907b38cd 2914 //-----------------------------------------------------------------------
2915
547c2f01 2916 for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ )
2917 {
e09cf5ef 2918 AliVTrack * track = (AliVTrack *) (pl->At(ipr)) ;
045396c8 2919
e09cf5ef 2920 Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
2921 p3.SetXYZ(mom[0],mom[1],mom[2]);
2922 pt = p3.Pt();
e09cf5ef 2923 eta = p3.Eta();
2924 phi = p3.Phi() ;
2925 if(phi < 0) phi+=TMath::TwoPi();
045396c8 2926
e09cf5ef 2927 //Select only hadrons in pt range
66e64043 2928 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
2929
e09cf5ef 2930 //remove trigger itself for correlation when use charged triggers
2931 if( track->GetID() == aodParticle->GetTrackLabel(0) || track->GetID() == aodParticle->GetTrackLabel(1) ||
66e64043 2932 track->GetID() == aodParticle->GetTrackLabel(2) || track->GetID() == aodParticle->GetTrackLabel(3) )
045396c8 2933 continue ;
2934
045396c8 2935 //jump out this event if near side associated particle pt larger than trigger
3f150b4b 2936 if (fMakeNearSideLeading)
547c2f01 2937 {
3f150b4b 2938 if(pt > ptTrig && TMath::Abs(phi-phiTrig) < TMath::PiOver2()) return kFALSE;
2939 }
2940 //jump out this event if there is any other particle with pt larger than trigger
2941 else if(fMakeAbsoluteLeading)
2942 {
2943 if(pt > ptTrig) return kFALSE;
045396c8 2944 }
2945
2946 //Only for mixed event
2947 Int_t evtIndex2 = 0 ;
04f7a616 2948 if (GetMixedEvent())
2949 {
045396c8 2950 evtIndex2 = GetMixedEvent()->EventIndex(track->GetID()) ;
2951 if (evtIndex11 == evtIndex2 || evtIndex12 == evtIndex2 || evtIndex13 == evtIndex2 ) // photon and track from different events
2952 continue ;
2953 //vertex cut
2954 if (TMath::Abs(GetVertex(evtIndex2)[2]) > GetZvertexCut())
2955 return kFALSE;
2956 }
2957
045396c8 2958 // Fill Histograms
3f150b4b 2959 if(bFillHisto)
907b38cd 2960 {
66e64043 2961
283f989c 2962 if(GetDebug() > 2 )
2963 printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Selected charge for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta);
907b38cd 2964
2965 // Set the pt associated bin for the defined bins
2966 Int_t assocBin = -1;
2967 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
547c2f01 2968 {
907b38cd 2969 if(pt > fAssocPtBinLimit[i] && pt < fAssocPtBinLimit[i+1]) assocBin= i;
2970 }
66e64043 2971
8cc41381 2972 // Assign to the histogram array a bin corresponding to a combination of pTa and vz bins
7d306daf 2973 Int_t nz = 1;
2974 Int_t vz = 0;
2975
2976 if(fCorrelVzBin)
2977 {
2978 nz = GetNZvertBin();
2979 vz = GetEventVzBin();
2980 }
2981
2982 Int_t bin = assocBin*nz+vz;
2983
8cc41381 2984 //printf("assoc Bin = %d, vZ bin = %d, bin = %d \n", assocBin,GetEventVzBin(),bin);
2985
fedea415 2986 ULong_t status = track->GetStatus();
2987 Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
2988 //Double32_t tof = track->GetTOFsignal()*1e-3;
2989 Int_t trackBC = track->GetTOFBunchCrossing(bz);
2990
2a9171b5 2991 Int_t outTOF = -1;
2992 if (okTOF && trackBC!=0) outTOF = 1;
2993 else if(okTOF && trackBC==0) outTOF = 0;
fedea415 2994
907b38cd 2995 // Azimuthal Angle
2996 // calculate deltaPhi for later, shift when needed
8cc41381 2997 FillChargedAngularCorrelationHistograms(pt, ptTrig, bin, phi, phiTrig, deltaPhi,
fedea415 2998 eta, etaTrig, decay, track->GetHMPIDsignal(),outTOF,nTracks,mcTag);
05d0d05d 2999
907b38cd 3000 // Imbalance zT/xE/pOut
3001 zT = pt/ptTrig ;
f16872ec 3002 if(zT > 0 ) hbpZT = TMath::Log(1./zT);
907b38cd 3003 else hbpZT =-100;
e09cf5ef 3004
907b38cd 3005 xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
3006 //if(xE <0.)xE =-xE;
f16872ec 3007 if(xE > 0 ) hbpXE = TMath::Log(1./xE);
907b38cd 3008 else hbpXE =-100;
3009
3010 pout = pt*TMath::Sin(deltaPhi) ;
66e64043 3011
907b38cd 3012 //delta phi cut for momentum imbalance correlation
18838011 3013 if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
547c2f01 3014 {
3f150b4b 3015
b1f720a7 3016 FillChargedMomentumImbalanceHistograms(ptTrig, pt, xE, hbpXE, zT, hbpZT, pout,
fedea415 3017 nTracks, track->Charge(), bin, decay,outTOF,mcTag);
3f150b4b 3018
18838011 3019 }
3020
fedea415 3021 if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
547c2f01 3022 { //UE study
3f150b4b 3023
fedea415 3024 FillChargedUnderlyingEventHistograms(ptTrig, pt, deltaPhi, nTracks,outTOF);
9623bf34 3025
d0b625bc 3026 fhUePart->Fill(ptTrig);
3f150b4b 3027
907b38cd 3028 }
e09cf5ef 3029
907b38cd 3030 if(fPi0Trigger && decayFound)
3031 FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2, kTRUE) ;
e09cf5ef 3032
3033 //several UE calculation
8cc41381 3034 if(fMakeSeveralUE) FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,deltaPhi);
907b38cd 3035
e09cf5ef 3036 } //Fill histogram
547c2f01 3037 else
3038 {
e09cf5ef 3039 nrefs++;
547c2f01 3040 if(nrefs==1)
3041 {
e09cf5ef 3042 reftracks = new TObjArray(0);
045396c8 3043 TString trackname = Form("%s+Tracks", GetAODObjArrayName().Data());
3044 reftracks->SetName(trackname.Data());
029dea5a 3045 reftracks->SetOwner(kFALSE);
e09cf5ef 3046 }
029dea5a 3047
e09cf5ef 3048 reftracks->Add(track);
029dea5a 3049
e09cf5ef 3050 }//aod particle loop
3051 }// track loop
3052
3053 //Fill AOD with reference tracks, if not filling histograms
547c2f01 3054 if(!bFillHisto && reftracks)
3055 {
e09cf5ef 3056 aodParticle->AddObjArray(reftracks);
3057 }
283f989c 3058
029dea5a 3059 //Own mixed event, add event and remove previous or fill the mixed histograms
2e876d85 3060 if(DoOwnMix() && bFillHisto)
029dea5a 3061 {
3062 MakeChargedMixCorrelation(aodParticle);
3063 }
3064
045396c8 3065 return kTRUE;
e09cf5ef 3066
3067}
3068
029dea5a 3069
7ed3a248 3070//_________________________________________________________________________________________________________
3071void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4ParticleCorrelation *aodParticle)
029dea5a 3072{
2e876d85 3073 // Mix current trigger with tracks in another MB event
029dea5a 3074
2e876d85 3075 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Make trigger particle - charged hadron mixed event correlation \n");
029dea5a 3076
3077 if(GetMixedEvent()) return; // This is not the mixed event from general mixing frame
3078
029dea5a 3079 // Get the event with similar caracteristics
2e876d85 3080 //printf("MakeChargedMixCorrelation for %s\n",GetInputAODName().Data());
3081
3082 AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
c52aeef5 3083
2e876d85 3084 AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
c52aeef5 3085
3086 if(!inputHandler) return;
3087
2e876d85 3088 if(!(inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask())) return;
7ed3a248 3089
029dea5a 3090 // Get the pool, check if it exits
2e876d85 3091 Int_t eventBin = GetEventMixBin();
3092
3093 fhEventBin->Fill(eventBin);
029dea5a 3094
2e876d85 3095 //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
3096 if(eventBin < 0) return;
029dea5a 3097
d07ffd54 3098 TList * pool = 0;
3099 TList * poolCalo = 0;
3100 if(fUseMixStoredInReader)
3101 {
3102 pool = GetReader()->GetListWithMixedEventsForTracks(eventBin);
2bb7ac98 3103 if(OnlyIsolated() || fFillNeutralEventMixPool) poolCalo = GetReader()->GetListWithMixedEventsForCalo (eventBin);
d07ffd54 3104 }
3105 else
3106 {
3107 pool = fListMixTrackEvents[eventBin];
2bb7ac98 3108 if(OnlyIsolated() || fFillNeutralEventMixPool) poolCalo = fListMixCaloEvents [eventBin];
d07ffd54 3109 }
3110
2e876d85 3111 if(!pool) return ;
029dea5a 3112
2bb7ac98 3113 if((OnlyIsolated() || fFillNeutralEventMixPool ) && !poolCalo &&
d07ffd54 3114 (GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::AliIsolationCut::kOnlyCharged))
3115 printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Careful, cluster pool not available\n");
3116
029dea5a 3117 Double_t ptTrig = aodParticle->Pt();
3118 Double_t etaTrig = aodParticle->Eta();
3119 Double_t phiTrig = aodParticle->Phi();
3120 if(phiTrig < 0.) phiTrig+=TMath::TwoPi();
3121
2e876d85 3122 if(GetDebug() > 1)
283f989c 3123 printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Pool bin %d size %d, leading trigger pt=%f, phi=%f, eta=%f\n",
3124 eventBin,pool->GetSize(), ptTrig,phiTrig,etaTrig);
029dea5a 3125
3126 Double_t ptAssoc = -999.;
2e876d85 3127 Double_t phiAssoc = -999.;
029dea5a 3128 Double_t etaAssoc = -999.;
3129 Double_t deltaPhi = -999.;
3130 Double_t deltaEta = -999.;
08f220c8 3131 Double_t xE = -999.;
3132 Double_t hbpXE = -999.;
3133
2e876d85 3134 //Start from first event in pool except if in this same event the pool was filled
283f989c 3135 Int_t ev0 = 0;
3136 if(GetReader()->GetLastTracksMixedEvent() == GetEventNumber()) ev0 = 1;
7ed3a248 3137
283f989c 3138 for(Int_t ev=ev0; ev < pool->GetSize(); ev++)
029dea5a 3139 {
3140 TObjArray* bgTracks = static_cast<TObjArray*>(pool->At(ev));
2bb7ac98 3141 TObjArray* bgCalo = 0;
3142
7ed3a248 3143 // Check if the particle is isolated in the mixed event, it not, do not fill the histograms
2bb7ac98 3144 if(OnlyIsolated() || fFillNeutralEventMixPool)
7ed3a248 3145 {
d07ffd54 3146 if(pool->GetSize()!=poolCalo->GetSize())
3147 printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Different size of calo and track pools\n");
3148
2bb7ac98 3149 bgCalo = static_cast<TObjArray*>(poolCalo->At(ev));
d07ffd54 3150
3151 if(!bgCalo)
3152 printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Event %d in calo pool not available?\n",ev);
3153
2bb7ac98 3154 if(OnlyIsolated() && bgCalo)
3155 {
3156 Int_t n=0; Int_t nfrac = 0; Bool_t isolated = kFALSE; Float_t coneptsum = 0;
3157 GetIsolationCut()->MakeIsolationCut(bgTracks,bgCalo,
3158 GetReader(), GetCaloPID(),
3159 kFALSE, aodParticle, "",
3160 n,nfrac,coneptsum, isolated);
3161
3162 //printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Isolated? %d - cone %f, ptthres %f",
3163 // isolated,GetIsolationCut()->GetConeSize(),GetIsolationCut()->GetPtThreshold());
3164 //if(bgTracks)printf(" - n track %d", bgTracks->GetEntriesFast());
3165 //printf("\n");
3166
3167 if(!isolated) continue ;
3168 }
7ed3a248 3169 }
3170
2e876d85 3171 fhEventMixBin->Fill(eventBin);
029dea5a 3172
2e876d85 3173 Int_t nTracks=bgTracks->GetEntriesFast();
3174 //printf("\t Read Pool event %d, nTracks %d\n",ev,nTracks);
3175
d0b625bc 3176 //Check if it is leading if mixed event
3177 if(fMakeNearSideLeading || fMakeAbsoluteLeading)
3178 {
3179 Bool_t leading = kTRUE;
3180 for(Int_t jlead = 0;jlead <nTracks; jlead++ )
3181 {
3182 AliAODPWG4Particle *track = (AliAODPWG4Particle*) bgTracks->At(jlead) ;
3183
3184 ptAssoc = track->Pt();
3185 phiAssoc = track->Phi() ;
3186
3187 if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
d0b625bc 3188 if (fMakeNearSideLeading)
3189 {
3190 if(ptAssoc > ptTrig && TMath::Abs(phiAssoc-phiTrig) < TMath::PiOver2())
3191 {
3192 leading = kFALSE;
3193 break;
3194 }
3195 }
3196 //jump out this event if there is any other particle with pt larger than trigger
3197 else if(fMakeAbsoluteLeading)
3198 {
3199 if(ptAssoc > ptTrig)
3200 {
3201 leading = kFALSE;
d0b625bc 3202 break;
3203 }
3204 }
3205 }
2bb7ac98 3206
3207 if(fFillNeutralEventMixPool && bgCalo)
3208 {
3209 Int_t nClusters=bgCalo->GetEntriesFast();
3210 TLorentzVector mom ;
3211 for(Int_t jlead = 0;jlead <nClusters; jlead++ )
3212 {
3213 AliVCluster *cluster = (AliVCluster*) bgCalo->At(jlead) ;
3214
3215 Double_t vertex[]={0,0,0}; // assume 0 vertex
3216 cluster->GetMomentum(mom,vertex) ;
3217
3218 ptAssoc = mom.Pt();
3219 phiAssoc = mom.Phi() ;
3220
3221 if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
3222 if (fMakeNearSideLeading)
3223 {
3224 if(ptAssoc > ptTrig && TMath::Abs(phiAssoc-phiTrig) < TMath::PiOver2())
3225 {
3226 leading = kFALSE;
3227 break;
3228 }
3229 }
3230 //jump out this event if there is any other particle with pt larger than trigger
3231 else if(fMakeAbsoluteLeading)
3232 {
3233 if(ptAssoc > ptTrig)
3234 {
3235 leading = kFALSE;
3236 break;
3237 }
3238 }
3239 }
3240 }
3241
d0b625bc 3242 if(!leading) continue; // not leading, check the next event in pool
2bb7ac98 3243
d0b625bc 3244 }
3245
7d306daf 3246 fhPtLeadingMixed ->Fill(ptTrig);
ca17b39f 3247 fhPhiLeadingMixed ->Fill(ptTrig, phiTrig);
3248 fhEtaLeadingMixed ->Fill(ptTrig, etaTrig);
d0b625bc 3249 fhPtLeadingMixedBin->Fill(ptTrig,eventBin);
7d306daf 3250 if(fCorrelVzBin)fhPtLeadingMixedVzBin->Fill(ptTrig, GetEventVzBin());
d0b625bc 3251
029dea5a 3252 for(Int_t j1 = 0;j1 <nTracks; j1++ )
3253 {
3254 AliAODPWG4Particle *track = (AliAODPWG4Particle*) bgTracks->At(j1) ;
3255
3256 if(!track) continue;
3257
3258 ptAssoc = track->Pt();
3259 etaAssoc = track->Eta();
3260 phiAssoc = track->Phi() ;
3261 if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
2e876d85 3262
029dea5a 3263 if(IsFiducialCutOn())
3264 {
3265 Bool_t in = GetFiducialCut()->IsInFiducialCut(*aodParticle->Momentum(),"CTS") ;
3266 if(!in) continue ;
3267 }
3268
3269 deltaPhi = phiTrig-phiAssoc;
3270 if(deltaPhi < -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
3271 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
3272 deltaEta = etaTrig-etaAssoc;
3273
3274 if(GetDebug()>0)
3275 printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation(): deltaPhi= %f, deltaEta=%f\n",deltaPhi, deltaEta);
3276
3277 // Set the pt associated bin for the defined bins
3278 Int_t assocBin = -1;
3279 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
3280 {
3281 if(ptAssoc > fAssocPtBinLimit[i] && ptAssoc < fAssocPtBinLimit[i+1]) assocBin= i;
3282 }
3283
8cc41381 3284 // Assign to the histogram array a bin corresponding to a combination of pTa and vz bins
7d306daf 3285 Int_t nz = 1;
3286 Int_t vz = 0;
3287
3288 if(fCorrelVzBin)
3289 {
3290 nz = GetNZvertBin();
3291 vz = GetEventVzBin();
3292 }
3293
3294 Int_t bin = assocBin*nz+vz;
8cc41381 3295
029dea5a 3296 fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi);
3297 fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta);
3298
08f220c8 3299 fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi);
3300 fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta);
3301
3302 xE =-ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
3303 //if(xE <0.)xE =-xE;
3304 if(xE > 0 ) hbpXE = TMath::Log(1./xE);
3305 else hbpXE =-100;
3306
18838011 3307 if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
08f220c8 3308 {
7d306daf 3309 fhMixXECharged->Fill(ptTrig,xE);
3310 fhMixHbpXECharged->Fill(ptTrig,hbpXE);
08f220c8 3311 }
18838011 3312
3313 if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
3314 {
3315 //Underlying event region
3316 Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
3317 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
3318
3319 if(uexE < 0.) uexE = -uexE;
3320
3321 fhMixXEUeCharged->Fill(ptTrig,uexE);
3322 }
3323
8cc41381 3324 if(bin < 0) continue ; // this pt bin was not considered
029dea5a 3325
2013f378 3326 if(TMath::Abs(deltaEta) > 0.8)
8cc41381 3327 fhMixDeltaPhiChargedAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi);
03a96401 3328 if(TMath::Abs(deltaEta) < 0.01)
8cc41381 3329 fhMixDeltaPhiChargedAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi);
2013f378 3330
8cc41381 3331 fhMixDeltaPhiChargedAssocPtBin [bin]->Fill(ptTrig, deltaPhi);
3332 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->Fill(deltaPhi, deltaEta);
029dea5a 3333
3334 } // track loop
3335 } // mixed event loop
3336}
3337
3338
05d0d05d 3339//________________________________________________________________________________________________________________
045396c8 3340Bool_t AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4ParticleCorrelation * const aodParticle,
22ad7981 3341 const TObjArray* pi0list, Bool_t bFillHisto)
e09cf5ef 3342{
3343 // Neutral Pion Correlation Analysis
907b38cd 3344 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Make trigger particle - pi0 correlation, %d pi0's \n",
3345 pi0list->GetEntriesFast());
e09cf5ef 3346
3347 Int_t evtIndex11 = 0 ;
3348 Int_t evtIndex12 = 0 ;
04f7a616 3349 if (GetMixedEvent())
3350 {
e09cf5ef 3351 evtIndex11 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(0)) ;
3352 evtIndex12 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(1)) ;
3353 }
3354
907b38cd 3355 Float_t pt = -100. ;
3356 Float_t zT = -100. ;
3357 Float_t phi = -100. ;
3358 Float_t eta = -100. ;
3359 Float_t xE = -100. ;
3360 Float_t hbpXE= -100. ;
3361 Float_t hbpZT= -100. ;
3362
3363 Float_t ptTrig = aodParticle->Pt();
3364 Float_t phiTrig = aodParticle->Phi();
3365 Float_t etaTrig = aodParticle->Eta();
3366 Float_t deltaPhi= -100. ;
3f150b4b 3367
045396c8 3368 TLorentzVector photonMom ;
3369
907b38cd 3370 // In case of pi0/eta trigger, we may want to check their decay correlation,
3371 // get their decay children
3372 TLorentzVector decayMom1;
3373 TLorentzVector decayMom2;
3374 Bool_t decayFound = kFALSE;
3375 if(fPi0Trigger && bFillHisto) decayFound = GetDecayPhotonMomentum(aodParticle,decayMom1, decayMom2);
e09cf5ef 3376
907b38cd 3377 TObjArray * refpi0 = 0x0;
3378 Int_t nrefs = 0;
e09cf5ef 3379
3380 //Loop on stored AOD pi0
547c2f01 3381
e09cf5ef 3382 Int_t naod = pi0list->GetEntriesFast();
045396c8 3383 if(GetDebug() > 0)
3384 printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillHistograms() - aod branch entries %d\n", naod);
547c2f01 3385
3386 for(Int_t iaod = 0; iaod < naod ; iaod++)
3387 {
e09cf5ef 3388 AliAODPWG4Particle* pi0 = (AliAODPWG4Particle*) (pi0list->At(iaod));
3389
3390 Int_t evtIndex2 = 0 ;
3391 Int_t evtIndex3 = 0 ;
04f7a616 3392 if (GetMixedEvent())
3393 {
e09cf5ef 3394 evtIndex2 = GetMixedEvent()->EventIndexForCaloCluster(pi0->GetCaloLabel(0)) ;
3395 evtIndex3 = GetMixedEvent()->EventIndexForCaloCluster(pi0->GetCaloLabel(1)) ;
3396
045396c8 3397 if (evtIndex11 == evtIndex2 || evtIndex12 == evtIndex2 ||
3398 evtIndex11 == evtIndex3 || evtIndex12 == evtIndex3) // trigger and pi0 are not from different events
e09cf5ef 3399 continue ;
3400 }
907b38cd 3401
e09cf5ef 3402 pt = pi0->Pt();
907b38cd 3403
66e64043 3404 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
3405
907b38cd 3406 //jump out this event if near side associated particle pt larger than trigger
3407 if (fMakeNearSideLeading)
3408 {
3409 if(pt > ptTrig && TMath::Abs(phi-phiTrig) < TMath::PiOver2()) return kFALSE;
3410 }
3411 //jump out this event if there is any other particle with pt larger than trigger
3412 else if(fMakeAbsoluteLeading)
3413 {
3414 if(pt > ptTrig) return kFALSE;
3415 }
e09cf5ef 3416
547c2f01 3417 if(bFillHisto)
3418 {
e09cf5ef 3419 phi = pi0->Phi() ;
3420 eta = pi0->Eta() ;
907b38cd 3421
3422 FillNeutralAngularCorrelationHistograms(pt, ptTrig, phi, phiTrig, deltaPhi, eta, etaTrig);
3423
3f150b4b 3424 zT = pt/ptTrig ;
3425 xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
3426
66e64043 3427 //if(xE <0.)xE =-xE;
e09cf5ef 3428
3f150b4b 3429 hbpXE = -100;
3430 hbpZT = -100;
907b38cd 3431
f16872ec 3432 if(xE > 0 ) hbpXE = TMath::Log(1./xE);
3433 if(zT > 0 ) hbpZT = TMath::Log(1./zT);
e09cf5ef 3434
907b38cd 3435 if(fPi0Trigger && decayFound)
3436 FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2,kFALSE) ;
e09cf5ef 3437
3438 //delta phi cut for correlation
547c2f01 3439 if( (deltaPhi > fDeltaPhiMinCut) && ( deltaPhi < fDeltaPhiMaxCut) )
3440 {
045396c8 3441 fhDeltaPhiNeutralPt->Fill(pt,deltaPhi);
3f150b4b 3442 fhXENeutral ->Fill(ptTrig,xE);
3443 fhPtHbpXENeutral ->Fill(ptTrig,hbpXE);
e09cf5ef 3444 }
907b38cd 3445 else if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
547c2f01 3446 {
045396c8 3447 fhDeltaPhiUeNeutralPt->Fill(pt,deltaPhi);
3f150b4b 3448 fhXEUeNeutral ->Fill(ptTrig,xE);
3449 fhPtHbpXEUeNeutral ->Fill(ptTrig,hbpXE);
e09cf5ef 3450 }
907b38cd 3451
e09cf5ef 3452 //several UE calculation
8cc41381 3453 if(fMakeSeveralUE) FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,deltaPhi);
907b38cd 3454
e09cf5ef 3455 }
547c2f01 3456 else
3457 {
e09cf5ef 3458 nrefs++;
547c2f01 3459 if(nrefs==1)
3460 {
e09cf5ef 3461 refpi0 = new TObjArray(0);
3462 refpi0->SetName(GetAODObjArrayName()+"Pi0s");
3463 refpi0->SetOwner(kFALSE);
3464 }
3465 refpi0->Add(pi0);
3466 }//put references in trigger AOD
045396c8 3467
3468 if(GetDebug() > 2 )
3469 printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Selected neutral for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta);
3470
3471 }//loop
3472
3473 return kTRUE;
3474}
3475
05d0d05d 3476//_________________________________________________________________________________________________________
045396c8 3477void AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle)
3478{
3479 // Charged Hadron Correlation Analysis with MC information
a426f453 3480
045396c8 3481 if(GetDebug()>1)
3482 printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation() - Make trigger particle - charged hadron correlation in AOD MC level\n");
3483
3484 AliStack * stack = 0x0 ;
3485 TParticle * primary = 0x0 ;
3486 TClonesArray * mcparticles0 = 0x0 ;
3487 TClonesArray * mcparticles = 0x0 ;
3488 AliAODMCParticle * aodprimary = 0x0 ;
3489
3490 Double_t eprim = 0 ;
3491 Double_t ptprim = 0 ;
3492 Double_t phiprim = 0 ;
3493 Double_t etaprim = 0 ;
045396c8 3494 Int_t nTracks = 0 ;
3495 Int_t iParticle = 0 ;
3496 Double_t charge = 0.;
a9023d3b 3497
547c2f01 3498 if(GetReader()->ReadStack())
3499 {
045396c8 3500 nTracks = GetMCStack()->GetNtrack() ;
3501 }
547c2f01 3502 else
3503 {
3504 nTracks = GetReader()->GetAODMCParticles()->GetEntriesFast() ;
3505 }
045396c8 3506 //Int_t trackIndex[nTracks];
3507
3508 Int_t label= aodParticle->GetLabel();
a426f453 3509 if(label < 0)
3510 {
3511 if(GetDebug() > 0) printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** bad label ***: label %d \n", label);
045396c8 3512 return;
3513 }
3514
547c2f01 3515 if(GetReader()->ReadStack())
3516 {
045396c8 3517 stack = GetMCStack() ;
2e876d85 3518 if(!stack)
3519 {
045396c8 3520 printf(" AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation- Stack not available, is the MC handler called? STOP\n");
3521 abort();
3522 }
3523
3524 nTracks=stack->GetNprimary();
547c2f01 3525 if(label >= stack->GetNtrack())
3526 {
045396c8 3527 if(GetDebug() > 2) printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** large label ***: label %d, n tracks %d \n", label, stack->GetNtrack());
3528 return ;
3529 }
547c2f01 3530
045396c8 3531 primary = stack->Particle(label);
547c2f01 3532 if(!primary)
3533 {
045396c8 3534 printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** no primary ***: label %d \n", label);
3535 return;
3536 }
3537
547c2f01 3538 if(primary)
3539 {
2747966a 3540 eprim = primary->Energy();
3541 ptprim = primary->Pt();
3542 phiprim = primary->Phi();
3543 etaprim = primary->Eta();
2747966a 3544
3545 if(ptprim < 0.01 || eprim < 0.01) return ;
a9023d3b 3546
547c2f01 3547 for (iParticle = 0 ; iParticle < nTracks ; iParticle++)
3548 {
045396c8 3549 TParticle * particle = stack->Particle(iParticle);
3550 TLorentzVector momentum;
3f150b4b 3551
045396c8 3552 //keep only final state particles
3553 if(particle->GetStatusCode()!=1) continue ;
3f150b4b 3554
3555 Int_t pdg = particle->GetPdgCode();
3556
045396c8 3557 charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
3f150b4b 3558
08f220c8 3559 particle->Momentum(momentum);
045396c8 3560
3561 //---------- Charged particles ----------------------
547c2f01 3562 if(charge != 0)
3563 {
045396c8 3564 //Particles in CTS acceptance
3565 Bool_t inCTS = GetFiducialCut()->IsInFiducialCut(momentum,"CTS");
3f150b4b 3566
045396c8 3567 if(TMath::Abs(pdg) == 11 && stack->Particle(particle->GetFirstMother())->GetPdgCode()==22) continue ;
3f150b4b 3568
66e64043 3569 if(inCTS)
045396c8 3570 {
907b38cd 3571 if( label!=iParticle) // avoid trigger particle
3572 {
3573 if(!FillChargedMCCorrelationHistograms(particle->Pt(),particle->Phi(),particle->Eta(),ptprim,phiprim,etaprim)) return;
3574 }
3575 }// in CTS acceptance
3576 }// charged
045396c8 3577 } //track loop
3578 } //when the leading particles could trace back to MC
3579 } //ESD MC
a9023d3b 3580
547c2f01 3581 else if(GetReader()->ReadAODMCParticles())
3582 {
045396c8 3583 //Get the list of MC particles
2644ead9 3584 mcparticles0 = GetReader()->GetAODMCParticles();
045396c8 3585 if(!mcparticles0) return;
a9023d3b 3586
547c2f01 3587 if(label >=mcparticles0->GetEntriesFast())
3588 {
045396c8 3589 if(GetDebug() > 2)
3590 printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** large label ***: label %d, n tracks %d \n", label,mcparticles0->GetEntriesFast());
3591 return;
3592 }
a9023d3b 3593
045396c8 3594 //Get the particle
3595 aodprimary = (AliAODMCParticle*) mcparticles0->At(label);
547c2f01 3596 if(!aodprimary)
3597 {
045396c8 3598 printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** no AOD primary ***: label %d \n", label);
3599 return;
3600 }
a9023d3b 3601
547c2f01 3602 if(aodprimary)
3603 {
2747966a 3604 ptprim = aodprimary->Pt();
3605 phiprim = aodprimary->Phi();
3606 etaprim = aodprimary->Eta();
9623bf34 3607 eprim = aodprimary->E();
a9023d3b 3608
9623bf34 3609 Bool_t lead = kFALSE;
2747966a 3610
3611 if(ptprim < 0.01 || eprim < 0.01) return ;
a9023d3b 3612
045396c8 3613 mcparticles= GetReader()->GetAODMCParticles();
a9023d3b 3614 for (iParticle = 0; iParticle < nTracks; iParticle++)
547c2f01 3615 {
a9023d3b 3616 AliAODMCParticle *part = (AliAODMCParticle*) mcparticles->At(iParticle);
3617
045396c8 3618 if (!part->IsPhysicalPrimary()) continue;
a9023d3b 3619
045396c8 3620 Int_t pdg = part->GetPdgCode();
3621 charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
a9023d3b 3622 TLorentzVector momentum(part->Px(),part->Py(),part->Pz(),part->E());
3623
547c2f01 3624 if(charge != 0)
3625 {
3626 if(part->Pt()> GetReader()->GetCTSPtMin())
3627 {
045396c8 3628 //Particles in CTS acceptance
3629 Bool_t inCTS = GetFiducialCut()->IsInFiducialCut(momentum,"CTS");
3630 Int_t indexmother=part->GetMother();
a9023d3b 3631
045396c8 3632 if(indexmother>-1)
3633 {
3634 Int_t mPdg = ((AliAODMCParticle*) mcparticles->At(indexmother)) ->GetPdgCode();
3635 if(TMath::Abs(pdg) == 11 && mPdg == 22) continue;
3636 }
547c2f01 3637
66e64043 3638 if(inCTS)
045396c8 3639 {
907b38cd 3640 if( label!=iParticle) // avoid trigger particle
3641 {
3642 if(!FillChargedMCCorrelationHistograms(part->Pt(),part->Phi(),part->Eta(),ptprim,phiprim,etaprim)) return;
a9023d3b 3643 else lead = kTRUE;
907b38cd 3644 }
3645 } // in acceptance
3646 } // min pt cut
045396c8 3647 } //only charged particles
08f220c8 3648 } //MC particle loop
3649 if (lead)
a9023d3b 3650 {
3651 fhMCPtLeading->Fill(ptprim);
3652 fhMCPhiLeading->Fill(ptprim,phiprim);
3653 fhMCEtaLeading->Fill(ptprim,etaprim);
3654 }
045396c8 3655 } //when the leading particles could trace back to MC
3656 }// AOD MC
e09cf5ef 3657}
045396c8 3658
05d0d05d 3659//_____________________________________________________________________
3660void AliAnaParticleHadronCorrelation::Print(const Option_t * opt) const
3661{
3662
3663 //Print some relevant parameters set for the analysis
3664 if(! opt)
3665 return;
3666
3667 printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
745913ae 3668 AliAnaCaloTrackCorrBaseClass::Print(" ");
66e64043 3669 printf("Pt trigger > %3.2f\n", fMinTriggerPt) ;
3670 printf("Pt associated hadron < %3.2f\n", fMaxAssocPt) ;
3671 printf("Pt associated hadron > %3.2f\n", fMinAssocPt) ;
3672 printf("Phi trigger particle-Hadron < %3.2f\n", fDeltaPhiMaxCut) ;
3673 printf("Phi trigger particle-Hadron > %3.2f\n", fDeltaPhiMinCut) ;
3674 printf("Phi trigger particle-UeHadron < %3.2f\n", fUeDeltaPhiMaxCut) ;
3675 printf("Phi trigger particle-UeHadron > %3.2f\n", fUeDeltaPhiMinCut) ;
3676 printf("Isolated Trigger? %d\n" , fSelectIsolated) ;
3677 printf("Several UE? %d\n" , fMakeSeveralUE) ;
3678 printf("Name of AOD Pi0 Branch %s \n", fPi0AODBranchName.Data());
05d0d05d 3679 printf("Do Decay-hadron correlation ? %d\n", fPi0Trigger) ;
3f150b4b 3680 printf("Select absolute leading for cluster triggers ? %d or Near Side %d\n",
3681 fMakeAbsoluteLeading, fMakeNearSideLeading) ;
05d0d05d 3682 printf("Trigger pt bins %d\n", fNAssocPtBins) ;
3683 for (Int_t ibin = 0; ibin<fNAssocPtBins; ibin++) {
3684 printf("\t bin %d = [%2.1f,%2.1f]\n", ibin, fAssocPtBinLimit[ibin], fAssocPtBinLimit[ibin+1]) ;
3685 }
3686
3687}
3688
3689//____________________________________________________________
3690void AliAnaParticleHadronCorrelation::SetNAssocPtBins(Int_t n)
045396c8 3691{
3692 // Set number of bins
e09cf5ef 3693
05d0d05d 3694 fNAssocPtBins = n ;
3695
3696
f85f4afb 3697 if(n < 20 && n > 0)
045396c8 3698 {
05d0d05d 3699 fNAssocPtBins = n ;
045396c8 3700 }
3701 else
3702 {
f85f4afb 3703 printf("n = larger than 19 or too small, set to 19 \n");
3704 fNAssocPtBins = 19;
045396c8 3705 }
3706}
e09cf5ef 3707
05d0d05d 3708//______________________________________________________________________________
3709void AliAnaParticleHadronCorrelation::SetAssocPtBinLimit(Int_t ibin, Float_t pt)
045396c8 3710{
3711 // Set the list of limits for the trigger pt bins
3712
05d0d05d 3713 if(ibin <= fNAssocPtBins || ibin >= 0)
045396c8 3714 {
05d0d05d 3715 fAssocPtBinLimit[ibin] = pt ;
045396c8 3716 }
2e876d85 3717 else
3718 {
05d0d05d 3719 printf("AliAnaParticleHadronCorrelation::SetAssocPtBinLimit() - bin number too large %d > %d or small, nothing done\n", ibin, fNAssocPtBins) ;
045396c8 3720 }
3721}
3722