]> 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
in case of multiple analysis accessing a similar pool with tracks, create it once...
[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(),
283f989c 73 fListMixEvents(), fUseMixStoredInReader(0),
05d0d05d 74 //Histograms
75 fhPtLeading(0), fhPhiLeading(0),
76 fhEtaLeading(0), fhDeltaPhiDeltaEtaCharged(0),
77 fhPhiCharged(0), fhEtaCharged(0),
78 fhDeltaPhiCharged(0), fhDeltaEtaCharged(0),
79 fhDeltaPhiChargedPt(0), fhDeltaPhiUeChargedPt(0),
3f150b4b 80 fhXECharged(0), fhXEUeCharged(0),
81 fhXEPosCharged(0), fhXENegCharged(0),
82 fhPtHbpXECharged(0), fhPtHbpXEUeCharged(0),
83 fhZTCharged(0), fhZTUeCharged(0),
84 fhZTPosCharged(0), fhZTNegCharged(0),
85 fhPtHbpZTCharged(0), fhPtHbpZTUeCharged(0),
05d0d05d 86 fhDeltaPhiUeLeftCharged(0), fhDeltaPhiUeRightCharged(0),
3f150b4b 87 fhXEUeLeftCharged(0), fhXEUeRightCharged(0),
88 fhPtHbpXEUeLeftCharged(0), fhPtHbpXEUeRightCharged(0),
89 fhZTUeLeftCharged(0), fhZTUeRightCharged(0),
90 fhPtHbpZTUeLeftCharged(0), fhPtHbpZTUeRightCharged(0),
05d0d05d 91 fhPtTrigPout(0), fhPtTrigCharged(0),
92 fhTrigDeltaPhiCharged(0x0), fhTrigDeltaEtaCharged(0x0),
3f150b4b 93 fhTrigXECorr(0x0), fhTrigXEUeCorr(0x0),
94 fhTrigZTCorr(0x0), fhTrigZTUeCorr(0x0),
907b38cd 95 fhAssocPtBkg(0),
96 fhDeltaPhiAssocPtBin(0), fhDeltaPhiAssocPtBinHMPID(0), fhDeltaPhiAssocPtBinHMPIDAcc(0),
66e64043 97 fhDeltaPhiBradAssocPtBin(0), fhDeltaPhiBrad(0),
907b38cd 98 fhXEAssocPtBin(0), fhZTAssocPtBin(0),
e09cf5ef 99 fhDeltaPhiDeltaEtaNeutral(0),
05d0d05d 100 fhPhiNeutral(0), fhEtaNeutral(0),
101 fhDeltaPhiNeutral(0), fhDeltaEtaNeutral(0),
102 fhDeltaPhiNeutralPt(0), fhDeltaPhiUeNeutralPt(0),
3f150b4b 103 fhXENeutral(0), fhXEUeNeutral(0),
104 fhPtHbpXENeutral(0), fhPtHbpXEUeNeutral(0),
105 fhZTNeutral(0), fhZTUeNeutral(0),
106 fhPtHbpZTNeutral(0), fhPtHbpZTUeNeutral(0),
05d0d05d 107 fhDeltaPhiUeLeftNeutral(0), fhDeltaPhiUeRightNeutral(0),
3f150b4b 108 fhXEUeLeftNeutral(0), fhXEUeRightNeutral(0),
109 fhPtHbpXEUeLeftNeutral(0), fhPtHbpXEUeRightNeutral(0),
110 fhZTUeLeftNeutral(0), fhZTUeRightNeutral(0),
111 fhPtHbpZTUeLeftNeutral(0), fhPtHbpZTUeRightNeutral(0),
e09cf5ef 112 fhPtPi0DecayRatio(0),
3f150b4b 113 fhDeltaPhiDecayCharged(0), fhXEDecayCharged(0), fhZTDecayCharged(0),
114 fhDeltaPhiDecayNeutral(0), fhXEDecayNeutral(0), fhZTDecayNeutral(0),
907b38cd 115 fhDeltaPhiDecayChargedAssocPtBin(0),
116 fhXEDecayChargedAssocPtBin(0), fhZTDecayChargedAssocPtBin(0),
045396c8 117 fh2phiLeadingParticle(0x0),
05d0d05d 118 fhMCEtaCharged(0), fhMCPhiCharged(0),
119 fhMCDeltaEtaCharged(0), fhMCDeltaPhiCharged(0x0),
120 fhMCDeltaPhiDeltaEtaCharged(0), fhMCDeltaPhiChargedPt(0),
3f150b4b 121 fhMCPtXECharged(0), fhMCPtHbpXECharged(0),
122 fhMCPtZTCharged(0), fhMCPtHbpZTCharged(0),
029dea5a 123 fhMCPtTrigPout(0), fhMCPtAssocDeltaPhi(0),
124 //Mixing
125 fhNEventsTrigger(0),
126 fhNtracksAll(0), fhNtracksTrigger(0),
2e876d85 127 fhNtracksMB(0),
029dea5a 128 fhMixDeltaPhiCharged(0), fhMixDeltaPhiDeltaEtaCharged(0),
2e876d85 129 fhMixDeltaPhiChargedAssocPtBin(),fhMixDeltaPhiDeltaEtaChargedAssocPtBin(0),
130 fhEventBin(0), fhEventMixBin(0)
029dea5a 131{
e09cf5ef 132 //Default Ctor
029dea5a 133
e09cf5ef 134 //Initialize parameters
135 InitParameters();
136}
137
029dea5a 138//_________________________________________________________________
139AliAnaParticleHadronCorrelation::~AliAnaParticleHadronCorrelation()
140{
141 // Remove event containers
142
2e876d85 143 if(DoOwnMix() && fListMixEvents)
029dea5a 144 {
145 for(Int_t iz=0; iz < GetNZvertBin(); iz++)
146 {
147 for(Int_t ic=0; ic < GetNCentrBin(); ic++)
148 {
2e876d85 149 for(Int_t irp=0; irp<GetNRPBin(); irp++)
150 {
151 Int_t bin = GetEventMixBin(ic, iz, irp);
152 fListMixEvents[bin]->Delete() ;
153 delete fListMixEvents[bin] ;
154 }
029dea5a 155 }
156 }
157
158 delete[] fListMixEvents;
159
160 }
161}
162
907b38cd 163//______________________________________________________________________________________________________________________________________________________
164void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(const Float_t ptAssoc, const Float_t ptTrig, const Int_t assocBin,
165 const Float_t phiAssoc, const Float_t phiTrig, Float_t & deltaPhi,
166 const Float_t etaAssoc, const Float_t etaTrig,
167 const Bool_t decay, const Float_t hmpidSignal, const Int_t nTracks)
168{
169 // Fill angular correlation related histograms
170
171 Float_t deltaEta = etaTrig-etaAssoc;
172 deltaPhi = phiTrig-phiAssoc;
173 Float_t deltaPhiOrg = deltaPhi;
174
175 if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
176 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
177
178 fhEtaCharged ->Fill(ptAssoc,etaAssoc);
179 fhPhiCharged ->Fill(ptAssoc,phiAssoc);
180 fhDeltaEtaCharged->Fill(ptTrig ,deltaEta);
181 fhDeltaPhiCharged->Fill(ptTrig ,deltaPhi);
182
183 if(ptAssoc > 2 ) fhDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta);
184
185 if(fDecayTrigger && decay) fhDeltaPhiDecayCharged ->Fill(ptTrig , deltaPhi);
186
187 Double_t dphiBrad = -100;
188 if(fFillBradHisto)
189 {
190 dphiBrad = atan2(sin(deltaPhiOrg), cos(deltaPhiOrg))/TMath::Pi();//-1 to 1
191 if(TMath::Abs(dphiBrad)>0.325 && TMath::Abs(dphiBrad)<0.475) //Hardcoded values, BAD, FIXME
192 {
193 fhAssocPtBkg->Fill(ptTrig, ptAssoc);
194 }
195
196 if(dphiBrad<-1./3) dphiBrad += 2;
197 fhDeltaPhiBrad->Fill(ptTrig, dphiBrad);
198 }
199
200 // Fill histograms in bins of associated particle pT
201 if(assocBin>=0)
202 {
203 fhDeltaPhiAssocPtBin[assocBin]->Fill(ptTrig, deltaPhi);
204 if (fFillBradHisto) fhDeltaPhiBradAssocPtBin [assocBin]->Fill(ptTrig, dphiBrad);
205 if(fDecayTrigger && decay) fhDeltaPhiDecayChargedAssocPtBin[assocBin]->Fill(ptTrig, deltaPhi);
206
207 if(fHMPIDCorrelation)
208 {
209 if( hmpidSignal > 0 )
210 {
211 //printf("Track pt %f with HMPID signal %f \n",pt,hmpidSignal);
212 fhDeltaPhiAssocPtBinHMPID[assocBin]->Fill(ptTrig, deltaPhi);
213 }
214
215 if(phiAssoc > 5*TMath::DegToRad() && phiAssoc < 20*TMath::DegToRad())
216 {
217 //printf("Track pt %f in HMPID acceptance phi %f \n ",pt,phi*TMath::RadToDeg() );
218 fhDeltaPhiAssocPtBinHMPIDAcc[assocBin]->Fill(ptTrig, deltaPhi);
219 }
220 }
221 }
222
223 //fill different multiplicity histogram
224 if(DoEventSelect())
225 {
226 for(Int_t im = 0; im<GetMultiBin(); im++)
227 {
228 if(nTracks < ( GetMaxMulti() - GetMinMulti() )/GetMultiBin()*(im+1))
229 {
230 fhTrigDeltaPhiCharged[im]->Fill(ptTrig,deltaPhi);
231 fhTrigDeltaEtaCharged[im]->Fill(ptTrig,deltaEta);
232 }
233 }
234 }
235}
236
237//____________________________________________________________________________________________________________________________________________________
238Bool_t AliAnaParticleHadronCorrelation::FillChargedMCCorrelationHistograms(const Float_t mcAssocPt, Float_t mcAssocPhi, const Float_t mcAssocEta,
239 const Float_t mcTrigPt, const Float_t mcTrigPhi, const Float_t mcTrigEta)
240{
241 // Fill MC histograms independently of AOD or ESD
242
243 //Select only hadrons in pt range
244 if(mcAssocPt < fMinAssocPt || mcAssocPt > fMaxAssocPt) return kTRUE ; // exclude but continue
245
246 if(mcAssocPhi < 0) mcAssocPhi+=TMath::TwoPi();
247
248 //remove trigger itself for correlation when use charged triggers
249 if(TMath::Abs(mcAssocPt -mcTrigPt ) < 1e-6 &&
250 TMath::Abs(mcAssocPhi-mcTrigPhi) < 1e-6 &&
251 TMath::Abs(mcAssocEta-mcTrigEta) < 1e-6) return kTRUE ; // exclude but continue
252
253 // Absolute leading?
254 if( fMakeAbsoluteLeading && mcAssocPt > mcTrigPt ) return kFALSE; // jump event
255
256 //jump out this event if near side associated partile pt larger than trigger
257 if( fMakeNearSideLeading && mcAssocPt > mcTrigPt &&
258 TMath::Abs(mcAssocPhi-mcTrigPhi)<TMath::PiOver2() ) return kFALSE; // jump event
259
260 Float_t mcdeltaPhi= mcTrigPhi-mcAssocPhi;
261 if(mcdeltaPhi <= -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi();
262 if(mcdeltaPhi > 3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi();
263
264 Float_t mcxE =-mcAssocPt/mcTrigPt*TMath::Cos(mcdeltaPhi);// -(mcAssocPx*pxprim+mcAssocPy*pyprim)/(mcTrigPt*mcTrigPt);
265 Float_t mchbpXE =-100 ;
2e876d85 266 if(mcxE > 0 ) mchbpXE = TMath::Log10(1./mcxE);
907b38cd 267
268 Float_t mczT = mcAssocPt/mcTrigPt ;
269 Float_t mchbpZT =-100 ;
2e876d85 270 if(mczT > 0 ) mchbpZT = TMath::Log10(1./mczT);
907b38cd 271
272 //Selection within angular range
273 if( mcdeltaPhi< -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi();
274 if( mcdeltaPhi>3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi();
275
276 Double_t mcpout = mcAssocPt*TMath::Sin(mcdeltaPhi) ;
277
278 if(GetDebug() > 0 )
279 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",
280 mcAssocPt,mcAssocPhi, mcTrigPhi,fDeltaPhiMinCut, mcdeltaPhi, fDeltaPhiMaxCut, GetMinPt());
281
282 // Fill Histograms
283 fhMCEtaCharged ->Fill(mcAssocPt, mcAssocEta);
284 fhMCPhiCharged ->Fill(mcAssocPt, mcAssocPhi);
285 fhMCDeltaEtaCharged->Fill(mcTrigPt, mcTrigEta-mcAssocEta);
286 fhMCDeltaPhiCharged->Fill(mcTrigPt, mcdeltaPhi);
287 fhMCPtAssocDeltaPhi->Fill(mcAssocPt, mcdeltaPhi);
288
289 fhMCDeltaPhiDeltaEtaCharged->Fill(mcdeltaPhi,mcTrigEta-mcAssocEta);
290
291 //delta phi cut for correlation
292 if( (mcdeltaPhi > fDeltaPhiMinCut) && (mcdeltaPhi < fDeltaPhiMaxCut) )
293 {
294 fhMCDeltaPhiChargedPt->Fill(mcAssocPt,mcdeltaPhi);
295 fhMCPtXECharged ->Fill(mcTrigPt,mcxE);
296 fhMCPtHbpXECharged ->Fill(mcTrigPt,mchbpXE);
297 fhMCPtZTCharged ->Fill(mcTrigPt,mczT);
298 fhMCPtHbpZTCharged ->Fill(mcTrigPt,mchbpZT);
299 fhMCPtTrigPout ->Fill(mcTrigPt, mcpout) ;
300 }
301
302 return kTRUE;
303}
304
305//___________________________________________________________________________________________________________________
306void AliAnaParticleHadronCorrelation::FillChargedMomentumImbalanceHistograms(const Float_t ptTrig, const Float_t ptAssoc,
307 const Float_t xE, const Float_t hbpXE,
308 const Float_t zT, const Float_t hbpZT,
309 const Float_t pout, const Float_t deltaPhi,
310 const Int_t nTracks, const Int_t charge,
311 const Int_t assocBin, const Bool_t decay )
312
313{
314 // Fill mostly momentum imbalance related histograms
315
316 fhDeltaPhiChargedPt ->Fill(ptAssoc, deltaPhi);
317 fhXECharged ->Fill(ptTrig , xE);
318 fhPtHbpXECharged ->Fill(ptTrig , hbpXE);
319 fhZTCharged ->Fill(ptTrig , zT);
320 fhPtHbpZTCharged ->Fill(ptTrig , hbpZT);
321 fhPtTrigPout ->Fill(ptTrig , pout) ;
322 fhPtTrigCharged ->Fill(ptTrig , ptAssoc) ;
323
324 if(fDecayTrigger && decay)
325 {
326 fhXEDecayCharged->Fill(ptTrig,xE);
327 fhZTDecayCharged->Fill(ptTrig,zT);
328 } // photon decay pi0/eta trigger
329
330 if(assocBin >= 0 )//away side
331 {
332 fhXEAssocPtBin[assocBin]->Fill(ptTrig, xE) ;
333 fhZTAssocPtBin[assocBin]->Fill(ptTrig, zT) ;
334
335 if(fDecayTrigger && decay)
336 {
337 fhXEDecayChargedAssocPtBin[assocBin]->Fill(ptTrig, xE);
338 fhZTDecayChargedAssocPtBin[assocBin]->Fill(ptTrig, zT);
339 }
340 }
341
342 if(charge > 0)
343 {
344 fhXEPosCharged->Fill(ptTrig,xE) ;
345 fhZTPosCharged->Fill(ptTrig,zT) ;
346 }
347 else
348 {
349 fhXENegCharged->Fill(ptTrig,xE) ;
350 fhZTNegCharged->Fill(ptTrig,zT) ;
351 }
352
353 //fill different multiplicity histogram
354 if(DoEventSelect())
355 {
356 for(Int_t im=0; im<GetMultiBin(); im++)
357 {
358 if(nTracks < ( GetMaxMulti() - GetMinMulti() )/GetMultiBin()*(im+1))
359 {
360 fhTrigXECorr[im]->Fill(ptTrig,xE);
361 fhTrigZTCorr[im]->Fill(ptTrig,zT);
362 }
363 }
364 } //multiplicity events selection
365}
366
367//_______________________________________________________________________________________________________________________
368void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventHistograms(const Float_t ptTrig, const Float_t ptAssoc,
369 const Float_t deltaPhi, const Int_t nTracks)
370{
371 // Fill underlying event histograms
372
373 fhDeltaPhiUeChargedPt->Fill(ptAssoc,deltaPhi);
374
375 Double_t randomphi = gRandom->Uniform(TMath::Pi()/2,3*TMath::Pi()/2);
376 Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
377 Double_t uezT = ptAssoc/ptTrig;
378
379 if(uexE < 0.) uexE = -uexE;
380
381 fhXEUeCharged->Fill(ptTrig,uexE);
2e876d85 382 if(uexE > 0) fhPtHbpXEUeCharged->Fill(ptTrig,TMath::Log10(1/uexE));
907b38cd 383
384 fhZTUeCharged->Fill(ptTrig,uezT);
2e876d85 385 if(uexE > 0) fhPtHbpZTUeCharged->Fill(ptTrig,TMath::Log10(1/uezT));
907b38cd 386
387 if(DoEventSelect())
388 {
389 for(Int_t im=0; im<GetMultiBin(); im++)
390 {
391 if(nTracks < ( GetMaxMulti() - GetMinMulti() )/GetMultiBin()*(im+1))
392 {
393 fhTrigXEUeCorr[im]->Fill(ptTrig,uexE); // xE? CHECK
394 fhTrigZTUeCorr[im]->Fill(ptTrig,uezT); // zT? CHECK
395 }
396 }
397 } //multiplicity events selection
398}
399
400//___________________________________________________________________________________________________________________________
401void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventSidesHistograms(const Float_t ptTrig, const Float_t ptAssoc,
402 const Float_t xE, const Float_t hbpXE,
403 const Float_t zT, const Float_t hbpZT,
404 const Float_t deltaPhi)
405{
406 // Fill underlying event histograms to the left and right of trigger
407
408 if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-fUeDeltaPhiMaxCut))
409 {
410 fhDeltaPhiUeLeftCharged->Fill(ptAssoc, deltaPhi);
411 fhXEUeLeftCharged ->Fill(ptTrig , xE);
412 fhPtHbpXEUeLeftCharged ->Fill(ptTrig , hbpXE);
413 fhZTUeLeftCharged ->Fill(ptTrig , zT);
414 fhPtHbpZTUeLeftCharged ->Fill(ptTrig , hbpZT);
415 }
416
417 if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut))
418 {
419 fhDeltaPhiUeRightCharged->Fill(ptAssoc, deltaPhi);
420 fhXEUeRightCharged ->Fill(ptTrig , xE);
421 fhPtHbpXEUeRightCharged ->Fill(ptTrig , hbpXE);
422 fhZTUeRightCharged ->Fill(ptTrig , zT);
423 fhPtHbpZTUeRightCharged ->Fill(ptTrig , hbpZT);
424 }
425}
426
427//______________________________________________________________________________________________________________________________
428void AliAnaParticleHadronCorrelation::FillDecayPhotonCorrelationHistograms(const Float_t ptAssoc, const Float_t phiAssoc,
429 const TLorentzVector mom1, const TLorentzVector mom2,
430 const Bool_t bChargedOrNeutral)
431{
432 // Do correlation with decay photons of triggered pi0 or eta
433
434 // Calculate the correlation parameters
435 Float_t ptDecay1 = mom1.Pt();
436 Float_t ptDecay2 = mom2.Pt();
437
438 Float_t zTDecay1 = -100, zTDecay2 = -100;
439 if(ptDecay1) zTDecay1 = ptAssoc/ptDecay1 ;
440 if(ptDecay2) zTDecay2 = ptAssoc/ptDecay2 ;
441
442 Float_t deltaPhiDecay1 = mom1.Phi()-phiAssoc;
443 if(deltaPhiDecay1< -TMath::PiOver2()) deltaPhiDecay1+=TMath::TwoPi();
444 if(deltaPhiDecay1>3*TMath::PiOver2()) deltaPhiDecay1-=TMath::TwoPi();
445
446 Float_t deltaPhiDecay2 = mom2.Phi()-phiAssoc;
447 if(deltaPhiDecay2< -TMath::PiOver2()) deltaPhiDecay2+=TMath::TwoPi();
448 if(deltaPhiDecay2>3*TMath::PiOver2()) deltaPhiDecay2-=TMath::TwoPi();
449
450 Float_t xEDecay1 =-zTDecay1*TMath::Cos(deltaPhiDecay1); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
451 Float_t xEDecay2 =-zTDecay2*TMath::Cos(deltaPhiDecay2); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
452
453 if(bChargedOrNeutral) // correlate with charges
454 {
455 fhDeltaPhiDecayCharged->Fill(ptDecay1, deltaPhiDecay1);
456 fhDeltaPhiDecayCharged->Fill(ptDecay2, deltaPhiDecay2);
457
2e876d85 458 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::FillDecayPhotonHistograms( Charged corr) - deltaPhoton1 = %f, deltaPhoton2 = %f \n", deltaPhiDecay1, deltaPhiDecay2);
907b38cd 459
460 if( (deltaPhiDecay1 > fDeltaPhiMinCut) && ( deltaPhiDecay1 < fDeltaPhiMaxCut) )
461 {
462 fhZTDecayCharged->Fill(ptDecay1,zTDecay1);
463 fhXEDecayCharged->Fill(ptDecay1,xEDecay1);
464 }
465 if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) )
466 {
467 fhZTDecayCharged->Fill(ptDecay2,zTDecay2);
468 fhXEDecayCharged->Fill(ptDecay2,xEDecay2);
469 }
470 }
471 else // correlate with neutrals
472 {
473 fhDeltaPhiDecayCharged->Fill(ptDecay1, deltaPhiDecay1);
474 fhDeltaPhiDecayCharged->Fill(ptDecay2, deltaPhiDecay2);
475
2e876d85 476 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::FillDecayPhotonHistograms(Neutral corr) - deltaPhoton1 = %f, deltaPhoton2 = %f \n", deltaPhiDecay1, deltaPhiDecay2);
907b38cd 477
478 if( (deltaPhiDecay1 > fDeltaPhiMinCut) && ( deltaPhiDecay1 < fDeltaPhiMaxCut) )
479 {
480 fhZTDecayCharged->Fill(ptDecay1,zTDecay1);
481 fhXEDecayCharged->Fill(ptDecay1,xEDecay1);
482 }
483 if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) )
484 {
485 fhZTDecayCharged->Fill(ptDecay2,zTDecay2);
486 fhXEDecayCharged->Fill(ptDecay2,xEDecay2);
487 }
488 }
489}
490
491//______________________________________________________________________________________________________________________________________________________
492void AliAnaParticleHadronCorrelation::FillNeutralAngularCorrelationHistograms(const Float_t ptAssoc, const Float_t ptTrig,
493 const Float_t phiAssoc, const Float_t phiTrig, Float_t & deltaPhi,
494 const Float_t etaAssoc, const Float_t etaTrig)
495{
496 // Fill angular correlation related histograms
497
498 Float_t deltaEta = etaTrig-etaAssoc;
499 deltaPhi = phiTrig-phiAssoc;
500
501 if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
502 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
503
504 fhEtaNeutral ->Fill(ptAssoc,etaAssoc);
505 fhPhiNeutral ->Fill(ptAssoc,phiAssoc);
506 fhDeltaEtaNeutral->Fill(ptTrig ,deltaEta);
507 fhDeltaPhiNeutral->Fill(ptTrig ,deltaPhi);
508
509 if(ptAssoc > 2 ) fhDeltaPhiDeltaEtaNeutral->Fill(deltaPhi, deltaEta);
510
511}
512
513//_____________________________________________________________________________________________________________________________
514void AliAnaParticleHadronCorrelation::FillNeutralUnderlyingEventSidesHistograms(const Float_t ptTrig, const Float_t ptAssoc,
515 const Float_t xE, const Float_t hbpXE,
516 const Float_t zT, const Float_t hbpZT,
517 const Float_t deltaPhi)
518{
519 // Fill underlying event histograms to the left and right of trigger
520
521 if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-fUeDeltaPhiMaxCut))
522 {
523 fhDeltaPhiUeLeftNeutral->Fill(ptAssoc, deltaPhi);
524 fhXEUeLeftNeutral ->Fill(ptTrig , xE);
525 fhPtHbpXEUeLeftNeutral ->Fill(ptTrig , hbpXE);
526 fhZTUeLeftNeutral ->Fill(ptTrig , zT);
527 fhPtHbpZTUeLeftNeutral ->Fill(ptTrig , hbpZT);
528 }
529
530 if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut))
531 {
532 fhDeltaPhiUeRightNeutral->Fill(ptAssoc, deltaPhi);
533 fhXEUeRightNeutral ->Fill(ptTrig , xE);
534 fhPtHbpXEUeRightNeutral ->Fill(ptTrig , hbpXE);
535 fhZTUeRightNeutral ->Fill(ptTrig , zT);
536 fhPtHbpZTUeRightNeutral ->Fill(ptTrig , hbpZT);
537 }
538}
539
029dea5a 540//_____________________________________________________________
541void AliAnaParticleHadronCorrelation::FillChargedEventMixPool()
542{
543 // Mixed event init
544
2e876d85 545 //printf("FillChargedEventMixPool for %s\n",GetInputAODName().Data());
283f989c 546
029dea5a 547 Int_t nTracks = GetCTSTracks()->GetEntriesFast();
548
549 fhNtracksAll->Fill(nTracks);
550
551 AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
552 AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
553
c6b4facc 554 if(!inputHandler) return ;
555
029dea5a 556 if(inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask())
557 {
558 fhNtracksTrigger->Fill(nTracks);
559 }
560
2e876d85 561 if(inputHandler->IsEventSelected( ) & AliVEvent::kMB)
029dea5a 562 {
563
2e876d85 564 fhNtracksMB->Fill(nTracks);
283f989c 565
566 if(fUseMixStoredInReader && GetReader()->GetLastTracksMixedEvent() == GetEventNumber())
567 {
568 //printf("%s : Pool already filled for this event !!!\n",GetInputAODName().Data());
569 return ; // pool filled previously for another trigger
570 }
2e876d85 571 Int_t eventBin = GetEventMixBin();
2e876d85 572
573 //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
574 if(eventBin < 0) return;
029dea5a 575
283f989c 576 TObjArray * mixEventTracks = new TObjArray;
577
578 if(fUseMixStoredInReader)
579 {
580 fListMixEvents[eventBin] = GetReader()->GetListWithMixedEventsForTracks(eventBin);
581 }
582
2e876d85 583 if(!fListMixEvents[eventBin]) fListMixEvents[eventBin] = new TList();
029dea5a 584
283f989c 585 //printf("%s ***** Pool Event bin : %d - nTracks %d\n",GetInputAODName().Data(),eventBin, GetCTSTracks()->GetEntriesFast());
586
2e876d85 587 TList * pool = fListMixEvents[eventBin];
029dea5a 588
589 TVector3 p3;
590 for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
591 {
592 AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
593
594 Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
595 p3.SetXYZ(mom[0],mom[1],mom[2]);
596 Float_t pt = p3.Pt();
597
598 //Select only hadrons in pt range
599 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
600
601 AliAODPWG4Particle * mixedTrack = new AliAODPWG4Particle(mom[0],mom[1],mom[2],0);
602 mixedTrack->SetDetector("CTS");
603 mixedTrack->SetChargedBit(track->Charge()>0);
604
605 mixEventTracks->Add(mixedTrack);
606 }
607
283f989c 608 //Set the event number where the last event was added, to avoid double pool filling
609 GetReader()->SetLastTracksMixedEvent(GetEventNumber());
610
029dea5a 611 pool->AddFirst(mixEventTracks);
612 mixEventTracks = 0;
2e876d85 613 //printf("Pool size %d, max %d\n",pool->GetSize(), GetNMaxEvMix());
614
615 if(pool->GetSize() > GetNMaxEvMix())
029dea5a 616 {//Remove last event
617 TClonesArray * tmp = static_cast<TClonesArray*>(pool->Last()) ;
618 pool->RemoveLast() ;
619 delete tmp ;
620 }
283f989c 621
029dea5a 622 } // MB event
623
624}
625
05d0d05d 626//____________________________________________________________
627TObjString* AliAnaParticleHadronCorrelation::GetAnalysisCuts()
628{
629 //Save parameters used for analysis
630 TString parList ; //this will be list of parameters used for this analysis.
631 const Int_t buffersize = 560;
632 char onePar[buffersize] ;
633
634 snprintf(onePar,buffersize,"--- AliAnaPaticleHadronCorrelation ---\n") ;
635 parList+=onePar ;
66e64043 636 snprintf(onePar,buffersize," Pt Trigger > %3.2f ", fMinTriggerPt) ;
05d0d05d 637 parList+=onePar ;
66e64043 638 snprintf(onePar,buffersize," %3.2f < Pt associated < %3.2f ", fMinAssocPt, fMaxAssocPt) ;
05d0d05d 639 parList+=onePar ;
66e64043 640 snprintf(onePar,buffersize," %3.2f < Phi trigger particle-Hadron < %3.2f ", fDeltaPhiMinCut, fDeltaPhiMaxCut) ;
05d0d05d 641 parList+=onePar ;
66e64043 642 snprintf(onePar,buffersize," %3.2f < Phi trigger particle-UeHadron < %3.2f ", fUeDeltaPhiMinCut, fUeDeltaPhiMaxCut) ;
05d0d05d 643 parList+=onePar ;
66e64043 644 snprintf(onePar,buffersize,"Isolated Trigger? %d\n", fSelectIsolated) ;
05d0d05d 645 parList+=onePar ;
66e64043 646 snprintf(onePar,buffersize,"Several UE? %d\n", fMakeSeveralUE) ;
05d0d05d 647 parList+=onePar ;
66e64043 648 snprintf(onePar,buffersize,"Name of AOD Pi0 Branch %s ", fPi0AODBranchName.Data());
05d0d05d 649 parList+=onePar ;
907b38cd 650 snprintf(onePar,buffersize,"Do Decay-hadron correlation ? pi0 %d, decay %d", fPi0Trigger, fDecayTrigger) ;
05d0d05d 651 parList+=onePar ;
3f150b4b 652 snprintf(onePar,buffersize,"Select absolute leading for cluster triggers ? %d or Near Side Leading %d \n",
653 fMakeAbsoluteLeading, fMakeNearSideLeading) ;
05d0d05d 654 parList+=onePar ;
655 snprintf(onePar,buffersize,"Associated particle pt bins %d: ", fNAssocPtBins) ;
656 parList+=onePar ;
657 for (Int_t ibin = 0; ibin<fNAssocPtBins; ibin++) {
658 snprintf(onePar,buffersize,"bin %d = [%2.1f,%2.1f];", ibin, fAssocPtBinLimit[ibin], fAssocPtBinLimit[ibin+1]) ;
659 }
660 parList+=onePar ;
661
662 //Get parameters set in base class.
663 parList += GetBaseParametersList() ;
664
05d0d05d 665 //Get parameters set in FiducialCut class (not available yet)
666 //parlist += GetFidCut()->GetFidCutParametersList()
667
668 return new TObjString(parList) ;
669
670}
671
672//________________________________________________________________
e09cf5ef 673TList * AliAnaParticleHadronCorrelation::GetCreateOutputObjects()
674{
675
676 // Create histograms to be saved in output file and
677 // store them in fOutputContainer
029dea5a 678
e09cf5ef 679 TList * outputContainer = new TList() ;
680 outputContainer->SetName("CorrelationHistos") ;
681
62f2fe4d 682 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();
683 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();
684 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 685
e09cf5ef 686 fhPtLeading = new TH1F ("hPtLeading","p_T distribution of leading particles", nptbins,ptmin,ptmax);
687 fhPtLeading->SetXTitle("p_{T}^{trig} (GeV/c)");
688
689 fhPhiLeading = new TH2F ("hPhiLeading","#phi distribution of leading Particles",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
690 fhPhiLeading->SetYTitle("#phi (rad)");
691
692 fhEtaLeading = new TH2F ("hEtaLeading","#eta distribution of leading",nptbins,ptmin,ptmax, netabins,etamin,etamax);
693 fhEtaLeading->SetYTitle("#eta ");
045396c8 694
e09cf5ef 695 outputContainer->Add(fhPtLeading);
696 outputContainer->Add(fhPhiLeading);
697 outputContainer->Add(fhEtaLeading);
698
699 //Correlation with charged hadrons
547c2f01 700 if(GetReader()->IsCTSSwitchedOn())
701 {
e09cf5ef 702 fhDeltaPhiDeltaEtaCharged = new TH2F
62f2fe4d 703 ("hDeltaPhiDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}}",
704 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
e09cf5ef 705 fhDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi");
706 fhDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
707
708 fhPhiCharged = new TH2F
babcbc9d 709 ("hPhiCharged","#phi_{h^{#pm}} vs p_{T #pm}",
e09cf5ef 710 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
711 fhPhiCharged->SetYTitle("#phi_{h^{#pm}} (rad)");
712 fhPhiCharged->SetXTitle("p_{T #pm} (GeV/c)");
713
714 fhEtaCharged = new TH2F
babcbc9d 715 ("hEtaCharged","#eta_{h^{#pm}} vs p_{T #pm}",
e09cf5ef 716 nptbins,ptmin,ptmax,netabins,etamin,etamax);
717 fhEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)");
718 fhEtaCharged->SetXTitle("p_{T #pm} (GeV/c)");
719
720 fhDeltaPhiCharged = new TH2F
babcbc9d 721 ("hDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",
62f2fe4d 722 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 723 fhDeltaPhiCharged->SetYTitle("#Delta #phi");
724 fhDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)");
725
726 fhDeltaPhiChargedPt = new TH2F
babcbc9d 727 ("hDeltaPhiChargedPt","#phi_{trigger} - #phi_{#h^{#pm}} vs p_{T h^{#pm}}",
62f2fe4d 728 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 729 fhDeltaPhiChargedPt->SetYTitle("#Delta #phi");
730 fhDeltaPhiChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
731
732 fhDeltaPhiUeChargedPt = new TH2F
babcbc9d 733 ("hDeltaPhiUeChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}}",
62f2fe4d 734 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 735 fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi");
736 fhDeltaPhiUeChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
737
738 fhDeltaEtaCharged = new TH2F
babcbc9d 739 ("hDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}",
62f2fe4d 740 nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
e09cf5ef 741 fhDeltaEtaCharged->SetYTitle("#Delta #eta");
742 fhDeltaEtaCharged->SetXTitle("p_{T trigger} (GeV/c)");
743
3f150b4b 744 fhXECharged =
745 new TH2F("hXECharged","x_{E} for charged tracks",
e09cf5ef 746 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 747 fhXECharged->SetYTitle("x_{E}");
748 fhXECharged->SetXTitle("p_{T trigger}");
e09cf5ef 749
3f150b4b 750 fhXEUeCharged =
751 new TH2F("hXEUeCharged","x_{E} for Underlying Event",
e09cf5ef 752 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 753 fhXEUeCharged->SetYTitle("x_{E}");
754 fhXEUeCharged->SetXTitle("p_{T trigger}");
e09cf5ef 755
3f150b4b 756 fhXEPosCharged =
757 new TH2F("hXEPositiveCharged","x_{E} for positive charged tracks",
e09cf5ef 758 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 759 fhXEPosCharged->SetYTitle("x_{E}");
760 fhXEPosCharged->SetXTitle("p_{T trigger}");
e09cf5ef 761
3f150b4b 762 fhXENegCharged =
763 new TH2F("hXENegativeCharged","x_{E} for negative charged tracks",
e09cf5ef 764 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 765 fhXENegCharged->SetYTitle("x_{E}");
766 fhXENegCharged->SetXTitle("p_{T trigger}");
e09cf5ef 767
3f150b4b 768 fhPtHbpXECharged =
769 new TH2F("hHbpXECharged","#xi = ln(1/x_{E}) with charged hadrons",
e09cf5ef 770 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 771 fhPtHbpXECharged->SetYTitle("ln(1/x_{E})");
772 fhPtHbpXECharged->SetXTitle("p_{T trigger}");
e09cf5ef 773
3f150b4b 774 fhPtHbpXEUeCharged =
775 new TH2F("hHbpXEUeCharged","#xi = ln(1/x_{E}) with charged hadrons,Underlying Event",
e09cf5ef 776 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 777 fhPtHbpXEUeCharged->SetYTitle("ln(1/x_{E})");
778 fhPtHbpXEUeCharged->SetXTitle("p_{T trigger}");
779
780 fhZTCharged =
781 new TH2F("hZTCharged","z_{T} for charged tracks",
782 nptbins,ptmin,ptmax,200,0.,2.);
783 fhZTCharged->SetYTitle("z_{T}");
784 fhZTCharged->SetXTitle("p_{T trigger}");
785
786 fhZTUeCharged =
787 new TH2F("hZTUeCharged","z_{T} for Underlying Event",
788 nptbins,ptmin,ptmax,200,0.,2.);
789 fhZTUeCharged->SetYTitle("z_{T}");
790 fhZTUeCharged->SetXTitle("p_{T trigger}");
791
792 fhZTPosCharged =
793 new TH2F("hZTPositiveCharged","z_{T} for positive charged tracks",
794 nptbins,ptmin,ptmax,200,0.,2.);
795 fhZTPosCharged->SetYTitle("z_{T}");
796 fhZTPosCharged->SetXTitle("p_{T trigger}");
797
798 fhZTNegCharged =
799 new TH2F("hZTNegativeCharged","z_{T} for negative charged tracks",
800 nptbins,ptmin,ptmax,200,0.,2.);
801 fhZTNegCharged->SetYTitle("z_{T}");
802 fhZTNegCharged->SetXTitle("p_{T trigger}");
803
804 fhPtHbpZTCharged =
805 new TH2F("hHbpZTCharged","#xi = ln(1/z_{T}) with charged hadrons",
806 nptbins,ptmin,ptmax,200,0.,10.);
807 fhPtHbpZTCharged->SetYTitle("ln(1/z_{T})");
808 fhPtHbpZTCharged->SetXTitle("p_{T trigger}");
809
810 fhPtHbpZTUeCharged =
811 new TH2F("hHbpZTUeCharged","#xi = ln(1/z_{T}) with charged hadrons,Underlying Event",
812 nptbins,ptmin,ptmax,200,0.,10.);
813 fhPtHbpZTUeCharged->SetYTitle("ln(1/x_{E})");
814 fhPtHbpZTUeCharged->SetXTitle("p_{T trigger}");
e09cf5ef 815
816 fhPtTrigPout =
babcbc9d 817 new TH2F("hPtTrigPout","Pout with triggers",
e09cf5ef 818 nptbins,ptmin,ptmax,2*nptbins,-ptmax,ptmax);
819 fhPtTrigPout->SetYTitle("p_{out} (GeV/c)");
820 fhPtTrigPout->SetXTitle("p_{T trigger} (GeV/c)");
821
e09cf5ef 822 fhPtTrigCharged =
babcbc9d 823 new TH2F("hPtTrigCharged","trgger and charged tracks pt distribution",
e09cf5ef 824 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
825 fhPtTrigCharged->SetYTitle("p_{T h^{#pm}} (GeV/c)");
826 fhPtTrigCharged->SetXTitle("p_{T trigger} (GeV/c)");
827
828 outputContainer->Add(fhDeltaPhiDeltaEtaCharged);
829 outputContainer->Add(fhPhiCharged) ;
830 outputContainer->Add(fhEtaCharged) ;
831 outputContainer->Add(fhDeltaPhiCharged) ;
832 outputContainer->Add(fhDeltaEtaCharged) ;
833 outputContainer->Add(fhDeltaPhiChargedPt) ;
834 outputContainer->Add(fhDeltaPhiUeChargedPt) ;
050ad675 835
3f150b4b 836 outputContainer->Add(fhXECharged) ;
837 outputContainer->Add(fhXEPosCharged) ;
838 outputContainer->Add(fhXENegCharged) ;
839 outputContainer->Add(fhXEUeCharged) ;
840 outputContainer->Add(fhPtHbpXECharged) ;
841 outputContainer->Add(fhPtHbpXEUeCharged) ;
050ad675 842
3f150b4b 843 outputContainer->Add(fhZTCharged) ;
844 outputContainer->Add(fhZTPosCharged) ;
845 outputContainer->Add(fhZTNegCharged) ;
846 outputContainer->Add(fhZTUeCharged) ;
847 outputContainer->Add(fhPtHbpZTCharged) ;
848 outputContainer->Add(fhPtHbpZTUeCharged) ;
849
e09cf5ef 850 outputContainer->Add(fhPtTrigPout) ;
e09cf5ef 851 outputContainer->Add(fhPtTrigCharged) ;
852
547c2f01 853 if(DoEventSelect())
854 {
e09cf5ef 855 Int_t nMultiBins = GetMultiBin();
856 fhTrigDeltaPhiCharged = new TH2F*[nMultiBins] ;
857 fhTrigDeltaEtaCharged = new TH2F*[nMultiBins] ;
3f150b4b 858 fhTrigXECorr = new TH2F*[nMultiBins] ;
859 fhTrigXEUeCorr = new TH2F*[nMultiBins] ;
860 fhTrigZTCorr = new TH2F*[nMultiBins] ;
861 fhTrigZTUeCorr = new TH2F*[nMultiBins] ;
862
863 for(Int_t im=0; im<nMultiBins; im++)
864 {
e09cf5ef 865 fhTrigDeltaPhiCharged[im] = new TH2F
62f2fe4d 866 (Form("hTrigDeltaPhiCharged_%d",im),Form("hTrigDeltaPhiCharged_%d",im), nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 867 fhTrigDeltaPhiCharged[im]->SetXTitle("p_{T trigger} (GeV/c)");
868 fhTrigDeltaPhiCharged[im]->SetYTitle("#Delta #phi");
3f150b4b 869
e09cf5ef 870 fhTrigDeltaEtaCharged[im] = new TH2F
62f2fe4d 871 (Form("hTrigDeltaEtaCharged_%d",im),Form("hTrigDeltaEtaCharged_%d",im), nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax);
e09cf5ef 872 fhTrigDeltaEtaCharged[im]->SetXTitle("p_{T trigger} (GeV/c)");
873 fhTrigDeltaEtaCharged[im]->SetYTitle("#Delta #eta");
3f150b4b 874
875 fhTrigXECorr[im] = new TH2F
876 (Form("hTrigXEPtCorr_%d",im),Form("hTrigXEPtCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
877 fhTrigXECorr[im]->SetYTitle("x_{E trigger h^{#pm}}");
878 fhTrigXECorr[im]->SetXTitle("p_{T trigger}");
879
880 fhTrigXEUeCorr[im] = new TH2F
881 (Form("hTrigXEPtUeCorr_%d",im),Form("hTrigXEPtUeCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
882 fhTrigXEUeCorr[im]->SetYTitle("x_{E trigger h^{#pm}}");
883 fhTrigXEUeCorr[im]->SetXTitle("p_{T trigger}");
884
885 fhTrigZTCorr[im] = new TH2F
886 (Form("hTrigZTPtCorr_%d",im),Form("hTrigZTPtCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
887 fhTrigZTCorr[im]->SetYTitle("z_{trigger h^{#pm}}");
888 fhTrigZTCorr[im]->SetXTitle("p_{T trigger}");
889
890 fhTrigZTUeCorr[im] = new TH2F
891 (Form("hTrigZTPtUeCorr_%d",im),Form("hTrigZTPtUeCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
892 fhTrigZTUeCorr[im]->SetYTitle("z_{trigger h^{#pm}}");
893 fhTrigZTUeCorr[im]->SetXTitle("p_{T trigger}");
045396c8 894
e09cf5ef 895 outputContainer->Add(fhTrigDeltaPhiCharged[im]) ;
896 outputContainer->Add(fhTrigDeltaEtaCharged[im]) ;
3f150b4b 897 outputContainer->Add(fhTrigXECorr[im]);
898 outputContainer->Add(fhTrigXEUeCorr[im]);
899 outputContainer->Add(fhTrigZTCorr[im]);
900 outputContainer->Add(fhTrigZTUeCorr[im]);
045396c8 901 }
902 }
903
907b38cd 904 if(fFillBradHisto)
905 {
906 fhAssocPtBkg = new TH2F("hAssocPtBkg", " Trigger p_{T} vs associated hadron p_{T} from background",
907 nptbins, ptmin, ptmax,nptbins,ptmin,ptmax);
908 fhAssocPtBkg->SetXTitle("p_{T trigger}");
909 fhAssocPtBkg->SetYTitle("p_{T associated}");
910 outputContainer->Add(fhAssocPtBkg) ;
911
912 fhDeltaPhiBrad = new TH2F("hDeltaPhiBrad","atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs p_{T trigger} ",
913 nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0);
914 fhDeltaPhiBrad->SetXTitle("p_{T trigger}");
915 fhDeltaPhiBrad->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi");
916 outputContainer->Add(fhDeltaPhiBrad) ;
917 }
66e64043 918
05d0d05d 919 fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins] ;
05d0d05d 920 fhXEAssocPtBin = new TH2F*[fNAssocPtBins] ;
3f150b4b 921 fhZTAssocPtBin = new TH2F*[fNAssocPtBins] ;
922
907b38cd 923 if(fFillBradHisto)
924 fhDeltaPhiBradAssocPtBin = new TH2F*[fNAssocPtBins] ;
925
926 if(fPi0Trigger || fDecayTrigger)
927 {
928 fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins] ;
929 fhXEAssocPtBin = new TH2F*[fNAssocPtBins] ;
930 fhZTAssocPtBin = new TH2F*[fNAssocPtBins] ;
931 fhXEDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins] ;
932 fhZTDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins] ;
933 fhDeltaPhiDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins] ;
934 }
050ad675 935
907b38cd 936 if(fHMPIDCorrelation)
937 {
938 fhDeltaPhiAssocPtBinHMPID = new TH2F*[fNAssocPtBins] ;
939 fhDeltaPhiAssocPtBinHMPIDAcc= new TH2F*[fNAssocPtBins] ;
940 }
941
babcbc9d 942 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
943 {
944 fhDeltaPhiAssocPtBin[i] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
05d0d05d 945 Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
62f2fe4d 946 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
05d0d05d 947 fhDeltaPhiAssocPtBin[i]->SetXTitle("p_{T trigger}");
948 fhDeltaPhiAssocPtBin[i]->SetYTitle("#Delta #phi");
907b38cd 949
babcbc9d 950 fhXEAssocPtBin[i] = new TH2F(Form("hXEAssocPtBin%1.f_%1.f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
66e64043 951 Form("x_{E} vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
3f150b4b 952 nptbins, ptmin, ptmax,200, 0.0, 2.0);
05d0d05d 953 fhXEAssocPtBin[i]->SetXTitle("p_{T trigger}");
954 fhXEAssocPtBin[i]->SetYTitle("x_{E}");
955
3f150b4b 956 fhZTAssocPtBin[i] = new TH2F(Form("hZTAssocPtBin%1.f_%1.f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
957 Form("z_{T} vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
958 nptbins, ptmin, ptmax,200, 0.0, 2.0);
959 fhZTAssocPtBin[i]->SetXTitle("p_{T trigger}");
960 fhZTAssocPtBin[i]->SetYTitle("z_{T}");
961
05d0d05d 962 outputContainer->Add(fhDeltaPhiAssocPtBin[i]) ;
05d0d05d 963 outputContainer->Add(fhXEAssocPtBin[i]);
3f150b4b 964 outputContainer->Add(fhZTAssocPtBin[i]);
907b38cd 965
966 if(fPi0Trigger || fDecayTrigger)
967 {
968 fhDeltaPhiDecayChargedAssocPtBin[i] = new TH2F(Form("hDeltaPhiPtDecayChargedAssocPt%2.1f_%2.1f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
969 Form("#Delta #phi vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
62f2fe4d 970 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
907b38cd 971 fhDeltaPhiDecayChargedAssocPtBin[i]->SetXTitle("p_{T trigger}");
972 fhDeltaPhiDecayChargedAssocPtBin[i]->SetYTitle("#Delta #phi");
973
974 fhXEDecayChargedAssocPtBin[i] = new TH2F(Form("hXEDecayChargedAssocPtBin%1.f_%1.f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
975 Form("x_{E} vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
976 nptbins, ptmin, ptmax,200, 0.0, 2.0);
977 fhXEDecayChargedAssocPtBin[i]->SetXTitle("p_{T trigger}");
978 fhXEDecayChargedAssocPtBin[i]->SetYTitle("x_{E}");
979
980 fhZTDecayChargedAssocPtBin[i] = new TH2F(Form("hZTDecayChargedAssocPtBin%1.f_%1.f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
981 Form("z_{T} vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
982 nptbins, ptmin, ptmax,200, 0.0, 2.0);
983 fhZTDecayChargedAssocPtBin[i]->SetXTitle("p_{T trigger}");
984 fhZTDecayChargedAssocPtBin[i]->SetYTitle("z_{T}");
985
986 outputContainer->Add(fhDeltaPhiDecayChargedAssocPtBin[i]) ;
987 outputContainer->Add(fhXEDecayChargedAssocPtBin[i]);
988 outputContainer->Add(fhZTDecayChargedAssocPtBin[i]);
989
990 }
991
992 if(fFillBradHisto)
993 {
994 fhDeltaPhiBradAssocPtBin[i] = new TH2F(Form("hDeltaPhiBradPtAssocPt%2.1f_%2.1f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
995 Form("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
996 nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0);
997 fhDeltaPhiBradAssocPtBin[i]->SetXTitle("p_{T trigger}");
998 fhDeltaPhiBradAssocPtBin[i]->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi");
999 outputContainer->Add(fhDeltaPhiBradAssocPtBin[i]) ;
1000 }
1001
1002 if(fHMPIDCorrelation)
1003 {
1004 fhDeltaPhiAssocPtBinHMPID[i] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1fHMPID", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
1005 Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f], with track having HMPID signal", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
62f2fe4d 1006 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
907b38cd 1007 fhDeltaPhiAssocPtBinHMPID[i]->SetXTitle("p_{T trigger}");
1008 fhDeltaPhiAssocPtBinHMPID[i]->SetYTitle("#Delta #phi");
1009
1010 fhDeltaPhiAssocPtBinHMPIDAcc[i] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1fHMPIDAcc", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
1011 Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f], with track within 5<phi<20 deg", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
62f2fe4d 1012 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
907b38cd 1013 fhDeltaPhiAssocPtBinHMPIDAcc[i]->SetXTitle("p_{T trigger}");
1014 fhDeltaPhiAssocPtBinHMPIDAcc[i]->SetYTitle("#Delta #phi");
1015
1016 outputContainer->Add(fhDeltaPhiAssocPtBinHMPID[i]) ;
1017 outputContainer->Add(fhDeltaPhiAssocPtBinHMPIDAcc[i]) ;
1018
1019 }
e09cf5ef 1020 }
045396c8 1021
907b38cd 1022 if(fPi0Trigger || fDecayTrigger)
547c2f01 1023 {
907b38cd 1024 if(fPi0Trigger)
1025 {
1026 fhPtPi0DecayRatio = new TH2F
1027 ("hPtPi0DecayRatio","p_T of #pi^{0} and the ratio of pt for two decay",
1028 nptbins,ptmin,ptmax, 100,0.,2.);
1029 fhPtPi0DecayRatio->SetXTitle("p_{T}^{#pi^{0}} (GeV/c)");
1030 fhPtPi0DecayRatio->SetYTitle("p_{T}^{Decay}/p_{T}^{#pi^{0}}");
050ad675 1031 outputContainer->Add(fhPtPi0DecayRatio) ;
907b38cd 1032 }
e09cf5ef 1033
1034 fhDeltaPhiDecayCharged = new TH2F
babcbc9d 1035 ("hDeltaPhiDecayCharged","#phi_{Decay} - #phi_{h^{#pm}} vs p_{T Decay}",
62f2fe4d 1036 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 1037 fhDeltaPhiDecayCharged->SetYTitle("#Delta #phi");
1038 fhDeltaPhiDecayCharged->SetXTitle("p_{T Decay} (GeV/c)");
1039
3f150b4b 1040 fhXEDecayCharged =
1041 new TH2F("hXEDecayCharged","x_{E} Decay",
1042 nptbins,ptmin,ptmax,200,0.,2.);
1043 fhXEDecayCharged->SetYTitle("x_{E}");
1044 fhXEDecayCharged->SetXTitle("p_{T decay}");
1045
1046 fhZTDecayCharged =
1047 new TH2F("hZTDecayCharged","z_{trigger h^{#pm}} = p_{T h^{#pm}} / p_{T Decay}",
e09cf5ef 1048 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1049 fhZTDecayCharged->SetYTitle("z_{decay h^{#pm}}");
1050 fhZTDecayCharged->SetXTitle("p_{T decay}");
e09cf5ef 1051
e09cf5ef 1052 outputContainer->Add(fhDeltaPhiDecayCharged) ;
3f150b4b 1053 outputContainer->Add(fhXEDecayCharged) ;
1054 outputContainer->Add(fhZTDecayCharged) ;
e09cf5ef 1055 }
1056
547c2f01 1057 if(fMakeSeveralUE)
1058 {
e09cf5ef 1059 fhDeltaPhiUeLeftCharged = new TH2F
babcbc9d 1060 ("hDeltaPhiUeLeftChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left side range of trigger particles",
62f2fe4d 1061 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 1062 fhDeltaPhiUeLeftCharged->SetYTitle("#Delta #phi");
1063 fhDeltaPhiUeLeftCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1064 outputContainer->Add(fhDeltaPhiUeLeftCharged) ;
1065
1066 fhDeltaPhiUeRightCharged = new TH2F
babcbc9d 1067 ("hDeltaPhiUeRightChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right side range of trigger particles",
62f2fe4d 1068 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 1069 fhDeltaPhiUeRightCharged->SetYTitle("#Delta #phi");
1070 fhDeltaPhiUeRightCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1071 outputContainer->Add(fhDeltaPhiUeRightCharged) ;
1072
3f150b4b 1073 fhXEUeLeftCharged =
1074 new TH2F("hXEUeChargedLeft","x_{E} with UE left side of trigger",
e09cf5ef 1075 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1076 fhXEUeLeftCharged->SetYTitle("x_{E Ueh^{#pm}}");
1077 fhXEUeLeftCharged->SetXTitle("p_{T trigger}");
1078 outputContainer->Add(fhXEUeLeftCharged) ;
e09cf5ef 1079
3f150b4b 1080 fhXEUeRightCharged =
1081 new TH2F("hXEUeChargedRight","x_{E h^{#pm}} with UE right side of trigger",
e09cf5ef 1082 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1083 fhXEUeRightCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
1084 fhXEUeRightCharged->SetXTitle("p_{T trigger}");
1085 outputContainer->Add(fhXEUeRightCharged) ;
1086
1087 fhPtHbpXEUeLeftCharged =
1088 new TH2F("hHbpXEUeChargedLeft","#xi = ln(1/x_{E}) with charged UE left side of trigger",
1089 nptbins,ptmin,ptmax,200,0.,10.);
1090 fhPtHbpXEUeLeftCharged->SetYTitle("ln(1/x_{E})");
1091 fhPtHbpXEUeLeftCharged->SetXTitle("p_{T trigger}");
1092 outputContainer->Add(fhPtHbpXEUeLeftCharged) ;
e09cf5ef 1093
3f150b4b 1094 fhPtHbpXEUeRightCharged =
1095 new TH2F("hHbpXEUeChargedRight","#xi = ln(1/x_{E}) with charged UE right side of trigger",
e09cf5ef 1096 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1097 fhPtHbpXEUeRightCharged->SetYTitle("ln(1/x_{E})");
1098 fhPtHbpXEUeRightCharged->SetXTitle("p_{T trigger}");
1099 outputContainer->Add(fhPtHbpXEUeRightCharged) ;
1100
1101 fhZTUeLeftCharged =
1102 new TH2F("hZTUeChargedLeft","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger} with UE left side of trigger",
1103 nptbins,ptmin,ptmax,200,0.,2.);
1104 fhZTUeLeftCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
1105 fhZTUeLeftCharged->SetXTitle("p_{T trigger}");
1106 outputContainer->Add(fhZTUeLeftCharged) ;
1107
1108 fhZTUeRightCharged =
1109 new TH2F("hZTUeChargedRight","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger} with UE right side of trigger",
1110 nptbins,ptmin,ptmax,200,0.,2.);
1111 fhZTUeRightCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
1112 fhZTUeRightCharged->SetXTitle("p_{T trigger}");
1113 outputContainer->Add(fhZTUeRightCharged) ;
e09cf5ef 1114
3f150b4b 1115 fhPtHbpZTUeLeftCharged =
1116 new TH2F("hHbpZTUeChargedLeft","#xi = ln(1/z_{T}) with charged UE left side of trigger",
e09cf5ef 1117 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1118 fhPtHbpZTUeLeftCharged->SetYTitle("ln(1/z_{T})");
1119 fhPtHbpZTUeLeftCharged->SetXTitle("p_{T trigger}");
1120 outputContainer->Add(fhPtHbpZTUeLeftCharged) ;
1121
1122 fhPtHbpZTUeRightCharged =
1123 new TH2F("hHbpZTUeChargedRight","#xi = ln(1/z_{T}) with charged UE right side of trigger",
1124 nptbins,ptmin,ptmax,200,0.,10.);
1125 fhPtHbpZTUeRightCharged->SetYTitle("ln(1/z_{T})");
1126 fhPtHbpZTUeRightCharged->SetXTitle("p_{T trigger}");
1127 outputContainer->Add(fhPtHbpZTUeRightCharged) ;
e09cf5ef 1128
1129 }
1130 } //Correlation with charged hadrons
050ad675 1131
e09cf5ef 1132 //Correlation with neutral hadrons
547c2f01 1133 if(fNeutralCorr)
1134 {
e09cf5ef 1135 fhDeltaPhiDeltaEtaNeutral = new TH2F
babcbc9d 1136 ("hDeltaPhiDeltaEtaNeutral","#phi_{trigger} - #phi_{h^{0}} vs #eta_{trigger} - #eta_{h^{0}}",
62f2fe4d 1137 ndeltaphibins ,deltaphimin,deltaphimax, ndeltaetabins ,deltaetamin,deltaetamax);
e09cf5ef 1138 fhDeltaPhiDeltaEtaNeutral->SetXTitle("#Delta #phi");
1139 fhDeltaPhiDeltaEtaNeutral->SetYTitle("#Delta #eta");
1140
1141 fhPhiNeutral = new TH2F
babcbc9d 1142 ("hPhiNeutral","#phi_{#pi^{0}} vs p_{T #pi^{0}}",
e09cf5ef 1143 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
1144 fhPhiNeutral->SetYTitle("#phi_{#pi^{0}} (rad)");
1145 fhPhiNeutral->SetXTitle("p_{T #pi^{0}} (GeV/c)");
1146
1147 fhEtaNeutral = new TH2F
babcbc9d 1148 ("hEtaNeutral","#eta_{#pi^{0}} vs p_{T #pi^{0}}",
e09cf5ef 1149 nptbins,ptmin,ptmax,netabins,etamin,etamax);
1150 fhEtaNeutral->SetYTitle("#eta_{#pi^{0}} (rad)");
1151 fhEtaNeutral->SetXTitle("p_{T #pi^{0}} (GeV/c)");
1152
1153 fhDeltaPhiNeutral = new TH2F
babcbc9d 1154 ("hDeltaPhiNeutral","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T trigger}",
e09cf5ef 1155 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
1156 fhDeltaPhiNeutral->SetYTitle("#Delta #phi");
1157 fhDeltaPhiNeutral->SetXTitle("p_{T trigger} (GeV/c)");
1158
1159 fhDeltaPhiNeutralPt = new TH2F
babcbc9d 1160 ("hDeltaPhiNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T #pi^{0}}}",
62f2fe4d 1161 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 1162 fhDeltaPhiNeutralPt->SetYTitle("#Delta #phi");
1163 fhDeltaPhiNeutralPt->SetXTitle("p_{T h^{0}} (GeV/c)");
1164
1165 fhDeltaPhiUeNeutralPt = new TH2F
babcbc9d 1166 ("hDeltaPhiUeNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T #pi^{0}}}",
62f2fe4d 1167 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 1168 fhDeltaPhiUeNeutralPt->SetYTitle("#Delta #phi");
1169 fhDeltaPhiUeNeutralPt->SetXTitle("p_{T h^{0}} (GeV/c)");
1170
1171 fhDeltaEtaNeutral = new TH2F
babcbc9d 1172 ("hDeltaEtaNeutral","#eta_{trigger} - #eta_{#pi^{0}} vs p_{T trigger}",
62f2fe4d 1173 nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax);
e09cf5ef 1174 fhDeltaEtaNeutral->SetYTitle("#Delta #eta");
1175 fhDeltaEtaNeutral->SetXTitle("p_{T trigger} (GeV/c)");
1176
3f150b4b 1177 fhXENeutral =
1178 new TH2F("hXENeutral","x_{E} for #pi^{0} associated",
e09cf5ef 1179 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1180 fhXENeutral->SetYTitle("x_{E}");
1181 fhXENeutral->SetXTitle("p_{T trigger}");
e09cf5ef 1182
3f150b4b 1183 fhXEUeNeutral =
1184 new TH2F("hXEUeNeutral","x_{E} for #pi^{0} associated",
e09cf5ef 1185 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1186 fhXEUeNeutral->SetYTitle("x_{E}");
1187 fhXEUeNeutral->SetXTitle("p_{T trigger}");
e09cf5ef 1188
3f150b4b 1189 fhPtHbpXENeutral =
1190 new TH2F("hHbpXENeutral","#xi = ln(1/x_{E})for #pi^{0} associated",
e09cf5ef 1191 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1192 fhPtHbpXENeutral->SetYTitle("ln(1/x_{E})");
1193 fhPtHbpXENeutral->SetXTitle("p_{T trigger}");
e09cf5ef 1194
3f150b4b 1195 fhPtHbpXEUeNeutral =
1196 new TH2F("hHbpXEUeNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated",
e09cf5ef 1197 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1198 fhPtHbpXEUeNeutral->SetYTitle("ln(1/x_{E})");
1199 fhPtHbpXEUeNeutral->SetXTitle("p_{T trigger}");
1200
1201 fhZTNeutral =
1202 new TH2F("hZTNeutral","z_{trigger #pi} = p_{T #pi^{0}} / p_{T trigger} for #pi^{0} associated",
1203 nptbins,ptmin,ptmax,200,0.,2.);
1204 fhZTNeutral->SetYTitle("z_{trigger #pi^{0}}");
1205 fhZTNeutral->SetXTitle("p_{T trigger}");
e09cf5ef 1206
3f150b4b 1207 fhZTUeNeutral =
1208 new TH2F("hZTUeNeutral","z_{trigger #pi} = p_{T #pi^{0}} / p_{T trigger} for #pi^{0} associated",
1209 nptbins,ptmin,ptmax,200,0.,2.);
1210 fhZTUeNeutral->SetYTitle("z_{trigger #pi^{0}}");
1211 fhZTUeNeutral->SetXTitle("p_{T trigger}");
1212
1213 fhPtHbpZTNeutral =
1214 new TH2F("hHbpZTNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated",
1215 nptbins,ptmin,ptmax,200,0.,10.);
1216 fhPtHbpZTNeutral->SetYTitle("ln(1/z_{T})");
1217 fhPtHbpZTNeutral->SetXTitle("p_{T trigger}");
1218
1219 fhPtHbpZTUeNeutral =
1220 new TH2F("hHbpZTUeNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated",
1221 nptbins,ptmin,ptmax,200,0.,10.);
1222 fhPtHbpXEUeNeutral->SetYTitle("ln(1/z_{T})");
1223 fhPtHbpXEUeNeutral->SetXTitle("p_{T trigger}");
e09cf5ef 1224
1225 outputContainer->Add(fhDeltaPhiDeltaEtaNeutral);
1226 outputContainer->Add(fhPhiNeutral) ;
1227 outputContainer->Add(fhEtaNeutral) ;
1228 outputContainer->Add(fhDeltaPhiNeutral) ;
1229 outputContainer->Add(fhDeltaPhiNeutralPt) ;
1230 outputContainer->Add(fhDeltaPhiUeNeutralPt) ;
1231 outputContainer->Add(fhDeltaEtaNeutral) ;
3f150b4b 1232 outputContainer->Add(fhXENeutral) ;
1233 outputContainer->Add(fhXEUeNeutral) ;
1234 outputContainer->Add(fhPtHbpXENeutral) ;
1235 outputContainer->Add(fhPtHbpXEUeNeutral) ;
1236 outputContainer->Add(fhZTNeutral) ;
1237 outputContainer->Add(fhZTUeNeutral) ;
1238 outputContainer->Add(fhPtHbpZTNeutral) ;
1239 outputContainer->Add(fhPtHbpZTUeNeutral) ;
e09cf5ef 1240
907b38cd 1241 if(fPi0Trigger || fDecayTrigger)
babcbc9d 1242 {
e09cf5ef 1243 fhDeltaPhiDecayNeutral = new TH2F
babcbc9d 1244 ("hDeltaPhiDecayNeutral","#phi_{Decay} - #phi_{h^{0}} vs p_{T Decay}",
62f2fe4d 1245 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 1246 fhDeltaPhiDecayNeutral->SetYTitle("#Delta #phi");
1247 fhDeltaPhiDecayNeutral->SetXTitle("p_{T Decay} (GeV/c)");
1248
3f150b4b 1249 fhXEDecayNeutral =
1250 new TH2F("hXEDecayNeutral","x_{E} for decay trigger",
1251 nptbins,ptmin,ptmax,200,0.,2.);
1252 fhXEDecayNeutral->SetYTitle("x_{E}");
1253 fhXEDecayNeutral->SetXTitle("p_{T decay}");
1254
1255 fhZTDecayNeutral =
1256 new TH2F("hZTDecayNeutral","z_{trigger h^{0}} = p_{T h^{0}} / p_{T Decay}",
e09cf5ef 1257 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1258 fhZTDecayNeutral->SetYTitle("z_{h^{0}}");
1259 fhZTDecayNeutral->SetXTitle("p_{T decay}");
e09cf5ef 1260
1261 outputContainer->Add(fhDeltaPhiDecayNeutral) ;
3f150b4b 1262 outputContainer->Add(fhXEDecayNeutral) ;
1263 outputContainer->Add(fhZTDecayNeutral) ;
1264
e09cf5ef 1265 }
1266
547c2f01 1267 if(fMakeSeveralUE)
1268 {
e09cf5ef 1269 fhDeltaPhiUeLeftNeutral = new TH2F
babcbc9d 1270 ("hDeltaPhiUeLeftNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs p_{T h^{0}} with neutral UE left side range of trigger particles",
62f2fe4d 1271 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 1272 fhDeltaPhiUeLeftNeutral->SetYTitle("#Delta #phi");
1273 fhDeltaPhiUeLeftNeutral->SetXTitle("p_{T h^{0}} (GeV/c)");
1274 outputContainer->Add(fhDeltaPhiUeLeftNeutral) ;
1275
1276 fhDeltaPhiUeRightNeutral = new TH2F
babcbc9d 1277 ("hDeltaPhiUeRightNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs p_{T Ueh^{0}} with neutral UE right side range of trigger particles",
62f2fe4d 1278 nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
e09cf5ef 1279 fhDeltaPhiUeRightNeutral->SetYTitle("#Delta #phi");
1280 fhDeltaPhiUeRightNeutral->SetXTitle("p_{T h^{0}} (GeV/c)");
1281 outputContainer->Add(fhDeltaPhiUeRightNeutral) ;
1282
3f150b4b 1283 fhXEUeLeftNeutral =
1284 new TH2F("hXEUeNeutralLeft","x_{E} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE left side of trigger",
1285 nptbins,ptmin,ptmax,140,0.,2.);
1286 fhXEUeLeftNeutral->SetYTitle("z_{trigger Ueh^{0}}");
1287 fhXEUeLeftNeutral->SetXTitle("p_{T trigger}");
1288 outputContainer->Add(fhXEUeLeftNeutral) ;
1289
1290 fhXEUeRightNeutral =
1291 new TH2F("hXEUeNeutralRight","x_{E} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE right side of trigger",
1292 nptbins,ptmin,ptmax,200,0.,2.);
1293 fhXEUeRightNeutral->SetYTitle("z_{trigger Ueh^{0}}");
1294 fhXEUeRightNeutral->SetXTitle("p_{T trigger}");
1295 outputContainer->Add(fhXEUeRightNeutral) ;
1296
1297 fhPtHbpXEUeLeftNeutral =
1298 new TH2F("hHbpXEUeNeutralLeft","#xi = ln(1/x_{E}) with neutral UE left side of trigger",
1299 nptbins,ptmin,ptmax,200,0.,10.);
1300 fhPtHbpXEUeLeftNeutral->SetYTitle("ln(1/x_{E})");
1301 fhPtHbpXEUeLeftNeutral->SetXTitle("p_{T trigger}");
1302 outputContainer->Add(fhPtHbpXEUeLeftNeutral) ;
1303
1304 fhPtHbpXEUeRightNeutral =
1305 new TH2F("hHbpXEUeNeutralRight","#xi = ln(1/x_{E}) with neutral UE right side of trigger",
1306 nptbins,ptmin,ptmax,200,0.,10.);
1307 fhPtHbpXEUeRightNeutral->SetYTitle("ln(1/x_{E})");
1308 fhPtHbpXEUeRightNeutral->SetXTitle("p_{T trigger}");
1309 outputContainer->Add(fhPtHbpXEUeRightNeutral) ;
1310
1311 fhZTUeLeftNeutral =
1312 new TH2F("hZTUeNeutralLeft","z_{trigger h^{0}} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE left side of trigger",
e09cf5ef 1313 nptbins,ptmin,ptmax,140,0.,2.);
3f150b4b 1314 fhZTUeLeftNeutral->SetYTitle("z_{trigger Ueh^{0}}");
1315 fhZTUeLeftNeutral->SetXTitle("p_{T trigger}");
1316 outputContainer->Add(fhZTUeLeftNeutral) ;
e09cf5ef 1317
3f150b4b 1318 fhZTUeRightNeutral =
1319 new TH2F("hZTUeNeutralRight","z_{trigger h^{0}} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE right side of trigger",
e09cf5ef 1320 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1321 fhZTUeRightNeutral->SetYTitle("z_{trigger Ueh^{0}}");
1322 fhZTUeRightNeutral->SetXTitle("p_{T trigger}");
1323 outputContainer->Add(fhZTUeRightNeutral) ;
e09cf5ef 1324
3f150b4b 1325 fhPtHbpZTUeLeftNeutral =
1326 new TH2F("hHbpZTUeNeutralLeft","#xi = ln(1/z_{T}) with neutral UE left side of trigger",
e09cf5ef 1327 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1328 fhPtHbpZTUeLeftNeutral->SetYTitle("ln(1/z_{T})");
1329 fhPtHbpZTUeLeftNeutral->SetXTitle("p_{T trigger}");
1330 outputContainer->Add(fhPtHbpZTUeLeftNeutral) ;
e09cf5ef 1331
3f150b4b 1332 fhPtHbpZTUeRightNeutral =
1333 new TH2F("hHbpZTUeNeutralRight","#xi = ln(1/z_{T}) with neutral UE right side of trigger",
e09cf5ef 1334 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1335 fhPtHbpZTUeRightNeutral->SetYTitle("ln(1/z_{T})");
1336 fhPtHbpZTUeRightNeutral->SetXTitle("p_{T trigger}");
1337 outputContainer->Add(fhPtHbpZTUeRightNeutral) ;
e09cf5ef 1338
1339 }
fe871b21 1340
1341 }//Correlation with neutral hadrons
1342
1343 //if data is MC, fill more histograms
babcbc9d 1344 if(IsDataMC())
1345 {
1346 fh2phiLeadingParticle=new TH2F("h2phiLeadingParticle","#phi resolustion for trigger particles",nptbins,ptmin,ptmax,100,-1,1);
fe871b21 1347 fh2phiLeadingParticle->GetXaxis()->SetTitle("p_{T gen Leading} (GeV/c)");
1348 fh2phiLeadingParticle->GetYaxis()->SetTitle("(#phi_{rec}-#phi_{gen})/#phi_{gen}");
e09cf5ef 1349
fe871b21 1350 fhMCEtaCharged = new TH2F
babcbc9d 1351 ("hMCEtaCharged","MC #eta_{h^{#pm}} vs p_{T #pm}",
fe871b21 1352 nptbins,ptmin,ptmax,netabins,etamin,etamax);
1353 fhMCEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)");
1354 fhMCEtaCharged->SetXTitle("p_{T #pm} (GeV/c)");
1355
1356 fhMCPhiCharged = new TH2F
babcbc9d 1357 ("hMCPhiCharged","#MC phi_{h^{#pm}} vs p_{T #pm}",
fe871b21 1358 200,ptmin,ptmax,nphibins,phimin,phimax);
1359 fhMCPhiCharged->SetYTitle("MC #phi_{h^{#pm}} (rad)");
1360 fhMCPhiCharged->SetXTitle("p_{T #pm} (GeV/c)");
1361
1362 fhMCDeltaPhiDeltaEtaCharged = new TH2F
babcbc9d 1363 ("hMCDeltaPhiDeltaEtaCharged","#MC phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",
fe871b21 1364 140,-2.,5.,200,-2,2);
1365 fhMCDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi");
1366 fhMCDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
1367
1368 fhMCDeltaEtaCharged = new TH2F
babcbc9d 1369 ("hMCDeltaEtaCharged","MC #eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger} and p_{T assoc}",
fe871b21 1370 nptbins,ptmin,ptmax,200,-2,2);
1371 fhMCDeltaEtaCharged->SetYTitle("#Delta #eta");
1372 fhMCDeltaEtaCharged->SetXTitle("p_{T trigger} (GeV/c)");
1373
1374 fhMCDeltaPhiCharged = new TH2F
babcbc9d 1375 ("hMCDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",
62f2fe4d 1376 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
fe871b21 1377 fhMCDeltaPhiCharged->SetYTitle("#Delta #phi");
1378 fhMCDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)");
1379
1380 fhMCDeltaPhiChargedPt = new TH2F
babcbc9d 1381 ("hMCDeltaPhiChargedPt","MC #phi_{trigger} - #phi_{#h^{#pm}} vs p_{T h^{#pm}}",
62f2fe4d 1382 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
fe871b21 1383 fhMCDeltaPhiChargedPt->SetYTitle("#Delta #phi");
1384 fhMCDeltaPhiChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
1385
3f150b4b 1386 fhMCPtXECharged =
1387 new TH2F("hMCPtXECharged","x_{E}",
fe871b21 1388 nptbins,ptmin,ptmax,200,0.,2.);
3f150b4b 1389 fhMCPtXECharged->SetYTitle("x_{E}");
1390 fhMCPtXECharged->SetXTitle("p_{T trigger}");
fe871b21 1391
3f150b4b 1392 fhMCPtHbpXECharged =
1393 new TH2F("hMCHbpXECharged","MC #xi = ln(1/x_{E}) with charged hadrons",
fe871b21 1394 nptbins,ptmin,ptmax,200,0.,10.);
3f150b4b 1395 fhMCPtHbpXECharged->SetYTitle("ln(1/x_{E})");
1396 fhMCPtHbpXECharged->SetXTitle("p_{T trigger}");
1397
1398 fhMCPtZTCharged =
1399 new TH2F("hMCPtZTCharged","z_{T}",
1400 nptbins,ptmin,ptmax,200,0.,2.);
1401 fhMCPtZTCharged->SetYTitle("z_{T}");
1402 fhMCPtZTCharged->SetXTitle("p_{T trigger}");
1403
1404 fhMCPtHbpZTCharged =
1405 new TH2F("hMCHbpZTCharged","MC #xi = ln(1/z_{T}) with charged hadrons",
1406 nptbins,ptmin,ptmax,200,0.,10.);
1407 fhMCPtHbpZTCharged->SetYTitle("ln(1/z_{T})");
1408 fhMCPtHbpZTCharged->SetXTitle("p_{T trigger}");
fe871b21 1409
1410 fhMCPtTrigPout =
babcbc9d 1411 new TH2F("hMCPtTrigPout","AOD MC Pout with triggers",
fe871b21 1412 nptbins,ptmin,ptmax,2*nptbins,-ptmax,ptmax);
1413 fhMCPtTrigPout->SetYTitle("p_{out} (GeV/c)");
1414 fhMCPtTrigPout->SetXTitle("p_{T trigger} (GeV/c)");
1415
1416 fhMCPtAssocDeltaPhi =
babcbc9d 1417 new TH2F("hMCPtAssocDeltaPhi","AOD MC delta phi with associated charged hadrons",
62f2fe4d 1418 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
fe871b21 1419 fhMCPtAssocDeltaPhi->SetYTitle("#Delta #phi");
1420 fhMCPtAssocDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)");
1421
1422 outputContainer->Add(fh2phiLeadingParticle);
fe871b21 1423 outputContainer->Add(fhMCDeltaPhiDeltaEtaCharged);
1424 outputContainer->Add(fhMCPhiCharged) ;
1425 outputContainer->Add(fhMCEtaCharged) ;
1426 outputContainer->Add(fhMCDeltaEtaCharged) ;
1427 outputContainer->Add(fhMCDeltaPhiCharged) ;
1428
1429 outputContainer->Add(fhMCDeltaPhiChargedPt) ;
3f150b4b 1430 outputContainer->Add(fhMCPtXECharged) ;
1431 outputContainer->Add(fhMCPtZTCharged) ;
1432 outputContainer->Add(fhMCPtHbpXECharged) ;
1433 outputContainer->Add(fhMCPtHbpZTCharged) ;
fe871b21 1434 outputContainer->Add(fhMCPtTrigPout) ;
1435 outputContainer->Add(fhMCPtAssocDeltaPhi) ;
1436 } //for MC histogram
1437
2e876d85 1438 if(DoOwnMix())
029dea5a 1439 {
1440 //create event containers
029dea5a 1441
283f989c 1442 if(!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForTracksExists()))
2e876d85 1443 {
283f989c 1444 fListMixEvents= new TList*[GetNCentrBin()*GetNZvertBin()*GetNRPBin()] ;
1445
1446 for(Int_t ic=0; ic<GetNCentrBin(); ic++)
2e876d85 1447 {
283f989c 1448 for(Int_t iz=0; iz<GetNZvertBin(); iz++)
2e876d85 1449 {
283f989c 1450 for(Int_t irp=0; irp<GetNRPBin(); irp++)
1451 {
1452 //printf("GetCreateOutputObjects - Bins : cent %d, vz %d, RP %d, event %d/%d\n",
1453 // ic,iz, irp, ic*GetNZvertBin()*GetNRPBin()+iz*GetNRPBin()+irp,GetNZvertBin()*GetNRPBin()*GetNCentrBin());
1454 fListMixEvents[ic*GetNZvertBin()*GetNRPBin()+iz*GetNRPBin()+irp] = new TList() ;
1455 fListMixEvents[ic*GetNZvertBin()*GetNRPBin()+iz*GetNRPBin()+irp]->SetOwner(kFALSE);
1456 }
2e876d85 1457 }
283f989c 1458 }
1459 }
1460
1461 //Init the list in the reader if not done previously
1462 if(!GetReader()->ListWithMixedEventsForTracksExists() && fUseMixStoredInReader)
1463 {
1464 printf("%s : Set the list of events \n",GetInputAODName().Data());
1465 GetReader()->SetListWithMixedEventsForTracks(fListMixEvents);
1466 }
029dea5a 1467
2e876d85 1468 fhEventBin=new TH1I("hEventBin","Number of real events per bin(cen,vz,rp)",
1469 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
1470 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
1471 fhEventBin->SetXTitle("bin");
1472 outputContainer->Add(fhEventBin) ;
283f989c 1473
2e876d85 1474 fhEventMixBin=new TH1I("hEventMixBin","Number of events per bin(cen,vz,rp)",
1475 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
1476 GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
1477 fhEventMixBin->SetXTitle("bin");
1478 outputContainer->Add(fhEventMixBin) ;
283f989c 1479
029dea5a 1480 fhNtracksAll=new TH1F("hNtracksAll","Number of tracks w/o event trigger",2000,0,2000);
1481 outputContainer->Add(fhNtracksAll);
1482
1483 fhNtracksTrigger=new TH1F("hNtracksTriggerEvent","Number of tracks w/ event trigger",2000,0,2000);
1484 outputContainer->Add(fhNtracksTrigger);
1485
2e876d85 1486 fhNtracksMB=new TH1F("hNtracksMBEvent","Number of tracks w/ event trigger kMB",2000,0,2000);
1487 outputContainer->Add(fhNtracksMB);
029dea5a 1488
1489 fhMixDeltaPhiCharged = new TH2F
1490 ("hMixDeltaPhiCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",
62f2fe4d 1491 nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
029dea5a 1492 fhMixDeltaPhiCharged->SetYTitle("#Delta #phi");
1493 fhMixDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)");
1494 outputContainer->Add(fhMixDeltaPhiCharged);
283f989c 1495
029dea5a 1496 fhMixDeltaPhiDeltaEtaCharged = new TH2F
1497 ("hMixDeltaPhiDeltaEtaCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",
62f2fe4d 1498 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
029dea5a 1499 fhMixDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi");
1500 fhMixDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
1501 outputContainer->Add(fhMixDeltaPhiDeltaEtaCharged);
283f989c 1502
029dea5a 1503 fhMixDeltaPhiChargedAssocPtBin = new TH2F*[fNAssocPtBins] ;
1504 fhMixDeltaPhiDeltaEtaChargedAssocPtBin = new TH2F*[fNAssocPtBins] ;
283f989c 1505
029dea5a 1506 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
1507 {
1508 fhMixDeltaPhiChargedAssocPtBin[i] = new TH2F(Form("hMixDeltaPhiChargedAssocPtBin%2.1f_%2.1f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
283f989c 1509 Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
1510 nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
029dea5a 1511 fhMixDeltaPhiChargedAssocPtBin[i]->SetXTitle("p_{T trigger}");
1512 fhMixDeltaPhiChargedAssocPtBin[i]->SetYTitle("#Delta #phi");
283f989c 1513
029dea5a 1514 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[i] = new TH2F(Form("hMixDeltaPhiDeltaEtaChargedAssocPtBin%2.1f_%2.1f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
283f989c 1515 Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
1516 ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
029dea5a 1517 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[i]->SetXTitle("#Delta #phi");
1518 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[i]->SetYTitle("#Delta #eta");
1519
1520 outputContainer->Add(fhMixDeltaPhiChargedAssocPtBin[i]);
1521 outputContainer->Add(fhMixDeltaPhiDeltaEtaChargedAssocPtBin[i]);
1522
050ad675 1523 }
029dea5a 1524 }
050ad675 1525
e09cf5ef 1526 return outputContainer;
1527
1528}
1529
907b38cd 1530//_________________________________________________________________________________________________
1531Bool_t AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum(const AliAODPWG4Particle* trigger,
1532 TLorentzVector & mom1,
1533 TLorentzVector & mom2)
1534{
1535 // Get the momentum of the pi0/eta assigned decay photons
1536 // In case of pi0/eta trigger, we may want to check their decay correlation,
1537 // get their decay children
1538
1539 Int_t indexPhoton1 = trigger->GetCaloLabel(0);
1540 Int_t indexPhoton2 = trigger->GetCaloLabel(1);
1541 Float_t ptTrig = trigger->Pt();
1542
1543 if(indexPhoton1!=-1 || indexPhoton2!=-1) return kFALSE;
1544
1545 if(GetDebug() > 1)
1546 printf("AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum() - indexPhoton1 = %d, indexPhoton2 = %d \n", indexPhoton1, indexPhoton2);
1547
1548 TObjArray * clusters = 0x0 ;
1549 if(trigger->GetDetector()=="EMCAL") clusters = GetEMCALClusters() ;
1550 else clusters = GetPHOSClusters() ;
1551
1552 for(Int_t iclus = 0; iclus < clusters->GetEntriesFast(); iclus++)
1553 {
1554 AliVCluster * photon = (AliVCluster*) (clusters->At(iclus));
1555 if(photon->GetID()==indexPhoton1)
1556 {
1557 photon->GetMomentum(mom1,GetVertex(0)) ;
1558 if(ptTrig) fhPtPi0DecayRatio->Fill(ptTrig, mom1.Pt()/ptTrig);
1559 }
1560 if(photon->GetID()==indexPhoton2)
1561 {
1562 photon->GetMomentum(mom1,GetVertex(0)) ;
1563 if(ptTrig > 0) fhPtPi0DecayRatio->Fill(ptTrig, mom2.Pt()/ptTrig);
1564 }
1565
1566 if(GetDebug() > 1)printf("AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum() - Photon1 = %f, Photon2 = %f \n", mom1.Pt(), mom2.Pt());
1567
1568 } //cluster loop
1569
1570 return kTRUE;
1571
1572}
1573
05d0d05d 1574//____________________________________________________
e09cf5ef 1575void AliAnaParticleHadronCorrelation::InitParameters()
1576{
1577
1578 //Initialize the parameters of the analysis.
1579 SetInputAODName("PWG4Particle");
1580 SetAODObjArrayName("Hadrons");
1581 AddToHistogramsName("AnaHadronCorr_");
045396c8 1582
e09cf5ef 1583 SetPtCutRange(0.,300);
045396c8 1584 fDeltaPhiMinCut = 1.5 ;
1585 fDeltaPhiMaxCut = 4.5 ;
1586 fSelectIsolated = kFALSE;
1587 fMakeSeveralUE = kFALSE;
1588 fUeDeltaPhiMinCut = 1. ;
1589 fUeDeltaPhiMaxCut = 1.5 ;
907b38cd 1590
045396c8 1591 fNeutralCorr = kFALSE ;
1592 fPi0Trigger = kFALSE ;
907b38cd 1593 fDecayTrigger = kFALSE ;
1594 fHMPIDCorrelation = kFALSE ;
045396c8 1595
3f150b4b 1596 fMakeAbsoluteLeading = kTRUE;
1597 fMakeNearSideLeading = kFALSE;
1598
050ad675 1599 fNAssocPtBins = 9 ;
1600 fAssocPtBinLimit[0] = 0.2 ;
1601 fAssocPtBinLimit[1] = 2.0 ;
1602 fAssocPtBinLimit[2] = 4.0 ;
1603 fAssocPtBinLimit[3] = 6.0 ;
1604 fAssocPtBinLimit[4] = 8.0 ;
1605 fAssocPtBinLimit[5] = 10. ;
1606 fAssocPtBinLimit[6] = 12. ;
1607 fAssocPtBinLimit[7] = 15. ;
1608 fAssocPtBinLimit[8] = 25. ;
1609 fAssocPtBinLimit[9] = 50. ;
045396c8 1610
283f989c 1611 fUseMixStoredInReader = kTRUE;
1612
e09cf5ef 1613}
1614
05d0d05d 1615//__________________________________________________________
e09cf5ef 1616void AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD()
1617{
1618 //Particle-Hadron Correlation Analysis, fill AODs
1619
547c2f01 1620 if(!GetInputAODBranch())
1621 {
e09cf5ef 1622 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - No input particles in AOD with name branch < %s >, STOP \n",GetInputAODName().Data());
1623 abort();
1624 }
1625
547c2f01 1626 if(strcmp(GetInputAODBranch()->GetClass()->GetName(), "AliAODPWG4ParticleCorrelation"))
1627 {
e09cf5ef 1628 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());
1629 abort();
1630 }
1631
283f989c 1632 if(GetDebug() > 1)
1633 {
e09cf5ef 1634 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - Begin hadron correlation analysis, fill AODs \n");
1635 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast());
66e64043 1636 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In CTS aod entries %d\n", GetCTSTracks() ->GetEntriesFast());
e09cf5ef 1637 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetEMCALClusters()->GetEntriesFast());
66e64043 1638 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In PHOS aod entries %d\n", GetPHOSClusters() ->GetEntriesFast());
e09cf5ef 1639 }
1640
045396c8 1641 //Get the vertex and check it is not too large in z
1642 Double_t v[3] = {0,0,0}; //vertex ;
1643 GetReader()->GetVertex(v);
1644 if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ;
1645
029dea5a 1646 // Fill the pool with tracks if requested
2e876d85 1647 if(DoOwnMix()) FillChargedEventMixPool();
029dea5a 1648
045396c8 1649 //Loop on stored AOD particles, find leading trigger
66e64043 1650 Double_t ptTrig = fMinTriggerPt ;
045396c8 1651 fLeadingTriggerIndex = -1 ;
1652 Int_t naod = GetInputAODBranch()->GetEntriesFast() ;
04f7a616 1653 for(Int_t iaod = 0; iaod < naod ; iaod++)
1654 {
e09cf5ef 1655 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
045396c8 1656
04f7a616 1657 // Vertex cut in case of mixing
1658 Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0));
1659 if(check == 0) continue;
1660 if(check == -1) return;
1661
045396c8 1662 // find the leading particles with highest momentum
547c2f01 1663 if (particle->Pt() > ptTrig)
1664 {
045396c8 1665 ptTrig = particle->Pt() ;
1666 fLeadingTriggerIndex = iaod ;
1667 }
1668 }// finish search of leading trigger particle
e09cf5ef 1669
66e64043 1670
e09cf5ef 1671 //Do correlation with leading particle
547c2f01 1672 if(fLeadingTriggerIndex >= 0)
1673 {
e09cf5ef 1674
045396c8 1675 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(fLeadingTriggerIndex));
1676
1677 //check if the particle is isolated or if we want to take the isolation into account
1678 if(OnlyIsolated() && !particle->IsIsolated()) return;
1679
e09cf5ef 1680 //Make correlation with charged hadrons
045396c8 1681 Bool_t okcharged = kTRUE;
1682 Bool_t okneutral = kTRUE;
e09cf5ef 1683 if(GetReader()->IsCTSSwitchedOn() )
045396c8 1684 okcharged = MakeChargedCorrelation(particle, GetCTSTracks(),kFALSE);
e09cf5ef 1685
1686 TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); //For the future, foresee more possible pi0 lists
1687 if(fNeutralCorr && pi0list && pi0list->GetEntriesFast() > 0)
045396c8 1688 okneutral = MakeNeutralCorrelation(particle, pi0list,kFALSE);
e09cf5ef 1689
1690 }//Correlate leading
1691
1692 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - End fill AODs \n");
1693
1694}
1695
05d0d05d 1696//_________________________________________________________________
e09cf5ef 1697void AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms()
1698{
1699 //Particle-Hadron Correlation Analysis, fill histograms
1700
3f150b4b 1701 if(!GetInputAODBranch())
1702 {
e09cf5ef 1703 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - No input particles in AOD with name branch < %s >, STOP \n",GetInputAODName().Data());
1704 abort();
1705 }
1706
3f150b4b 1707 if(GetDebug() > 1)
1708 {
e09cf5ef 1709 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Begin hadron correlation analysis, fill histograms \n");
1710 printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast());
1711 }
babcbc9d 1712
e09cf5ef 1713 //Get the vertex and check it is not too large in z
1714 Double_t v[3] = {0,0,0}; //vertex ;
1715 GetReader()->GetVertex(v);
1716 if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ;
1717
1718 //Loop on stored AOD particles, find leading
66e64043 1719 Double_t ptTrig = fMinTriggerPt;
04f7a616 1720 if(fLeadingTriggerIndex < 0)
1721 {
1722 //Search leading if not done before
045396c8 1723 Int_t naod = GetInputAODBranch()->GetEntriesFast() ;
547c2f01 1724 for(Int_t iaod = 0; iaod < naod ; iaod++)
1725 { //loop on input trigger AOD file
045396c8 1726 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
04f7a616 1727
1728 // Vertex cut in case of mixing
1729 Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0));
1730 if(check == 0) continue;
1731 if(check == -1) return;
1732
045396c8 1733 //check if the particle is isolated or if we want to take the isolation into account
1734 if(OnlyIsolated() && !particle->IsIsolated()) continue;
e09cf5ef 1735
045396c8 1736 //find the leading particles with highest momentum
547c2f01 1737 if (particle->Pt() > ptTrig)
1738 {
045396c8 1739 ptTrig = particle->Pt() ;
1740 fLeadingTriggerIndex = iaod ;
e09cf5ef 1741 }
547c2f01 1742
1743 }// Finish search of leading trigger particle
1744 }// Search leading if not done before
045396c8 1745
547c2f01 1746 if(fLeadingTriggerIndex >= 0 )
1747 { //using trigger particle to do correlations
1748
045396c8 1749 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(fLeadingTriggerIndex));
06d3bad7 1750
547c2f01 1751 // Check if trigger is in fiducial region
1752 if(IsFiducialCutOn())
1753 {
1754 Bool_t in = GetFiducialCut()->IsInFiducialCut(*particle->Momentum(),particle->GetDetector()) ;
1755 if(! in ) return ;
1756 }
1757
1758 // Check if the particle is isolated or if we want to take the isolation into account
045396c8 1759 if(OnlyIsolated() && !particle->IsIsolated()) return;
e09cf5ef 1760
547c2f01 1761 // Make correlation with charged hadrons
045396c8 1762 Bool_t okcharged = kTRUE;
1763 Bool_t okneutral = kTRUE;
547c2f01 1764 if(GetReader()->IsCTSSwitchedOn() )
1765 {
045396c8 1766 okcharged = MakeChargedCorrelation(particle, GetCTSTracks(),kTRUE);
547c2f01 1767 if(IsDataMC())
1768 {
045396c8 1769 MakeMCChargedCorrelation(particle);
1770 }
a5f1e836 1771 }
1772
e09cf5ef 1773 TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); //For the future, foresee more possible pi0 lists
547c2f01 1774 if(fNeutralCorr && pi0list)
1775 {
a5f1e836 1776 if(pi0list->GetEntriesFast() > 0)
1777 okneutral = MakeNeutralCorrelation(particle, pi0list,kTRUE);
1778 }
e09cf5ef 1779
045396c8 1780 // Fill leading particle histogram if correlation went well and
1781 // no problem was found, like not absolute leading, or bad vertex in mixing.
547c2f01 1782 if(okcharged && okneutral)
1783 {
045396c8 1784 fhPtLeading->Fill(particle->Pt());
1785 Float_t phi = particle->Phi();
1786 if(phi<0)phi+=TMath::TwoPi();
1787 fhPhiLeading->Fill(particle->Pt(), phi);
1788 fhEtaLeading->Fill(particle->Pt(), particle->Eta());
283f989c 1789 //printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Leading particle : pt %f, eta %f, phi %f\n",particle->Pt(),particle->Eta(),phi);
1790
045396c8 1791 }//ok charged && neutral
e09cf5ef 1792 }//Aod branch loop
1793
045396c8 1794 //Reinit for next event
1795 fLeadingTriggerIndex = -1;
e09cf5ef 1796
045396c8 1797 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - End fill histograms \n");
e09cf5ef 1798}
1799
c5693f62 1800//___________________________________________________________________________________________________________
045396c8 1801Bool_t AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle,
c5693f62 1802 const TObjArray* pl, const Bool_t bFillHisto)
e09cf5ef 1803{
1804 // Charged Hadron Correlation Analysis
283f989c 1805 if(GetDebug() > 1)
1806 printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Make trigger particle - charged hadron correlation \n");
907b38cd 1807
1808 Float_t phiTrig = aodParticle->Phi();
1809 Float_t etaTrig = aodParticle->Eta();
1810 Float_t ptTrig = aodParticle->Pt();
1811 Bool_t decay = aodParticle->IsTagged();
1812
1813 Float_t pt = -100. ;
1814 Float_t zT = -100. ;
1815 Float_t xE = -100. ;
1816 Float_t hbpXE = -100. ;
1817 Float_t hbpZT = -100. ;
1818 Float_t phi = -100. ;
1819 Float_t eta = -100. ;
1820 Float_t pout = -100. ;
1821 Float_t deltaPhi = -100. ;
e09cf5ef 1822
907b38cd 1823 TVector3 p3;
1824 TLorentzVector photonMom ;
1825 TObjArray * reftracks = 0x0;
1826 Int_t nrefs = 0;
1827 Int_t nTracks = GetCTSTracks()->GetEntriesFast() ;
1828
1829 // Mixed event settings
1830 Int_t evtIndex11 = -1 ; // cluster trigger or pi0 trigger
045396c8 1831 Int_t evtIndex12 = -1 ; // pi0 trigger
1832 Int_t evtIndex13 = -1 ; // charged trigger
045396c8 1833
1834 Double_t v[3] = {0,0,0}; //vertex ;
e09cf5ef 1835 GetReader()->GetVertex(v);
e09cf5ef 1836
04f7a616 1837 if (GetMixedEvent())
1838 {
e09cf5ef 1839 evtIndex11 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(0)) ;
1840 evtIndex12 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(1)) ;
1841 evtIndex13 = GetMixedEvent()->EventIndex(aodParticle->GetTrackLabel(0)) ;
1842 }
1843
907b38cd 1844 // In case of pi0/eta trigger, we may want to check their decay correlation,
1845 // get their decay children
1846 TLorentzVector decayMom1;
1847 TLorentzVector decayMom2;
1848 Bool_t decayFound = kFALSE;
1849 if(fPi0Trigger && bFillHisto) decayFound = GetDecayPhotonMomentum(aodParticle,decayMom1, decayMom2);
1850
1851 //-----------------------------------------------------------------------
e09cf5ef 1852 //Track loop, select tracks with good pt, phi and fill AODs or histograms
907b38cd 1853 //-----------------------------------------------------------------------
1854
547c2f01 1855 for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ )
1856 {
e09cf5ef 1857 AliVTrack * track = (AliVTrack *) (pl->At(ipr)) ;
045396c8 1858
e09cf5ef 1859 Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
1860 p3.SetXYZ(mom[0],mom[1],mom[2]);
1861 pt = p3.Pt();
e09cf5ef 1862 eta = p3.Eta();
1863 phi = p3.Phi() ;
1864 if(phi < 0) phi+=TMath::TwoPi();
045396c8 1865
e09cf5ef 1866 //Select only hadrons in pt range
66e64043 1867 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
1868
e09cf5ef 1869 //remove trigger itself for correlation when use charged triggers
1870 if( track->GetID() == aodParticle->GetTrackLabel(0) || track->GetID() == aodParticle->GetTrackLabel(1) ||
66e64043 1871 track->GetID() == aodParticle->GetTrackLabel(2) || track->GetID() == aodParticle->GetTrackLabel(3) )
045396c8 1872 continue ;
1873
045396c8 1874 //jump out this event if near side associated particle pt larger than trigger
3f150b4b 1875 if (fMakeNearSideLeading)
547c2f01 1876 {
3f150b4b 1877 if(pt > ptTrig && TMath::Abs(phi-phiTrig) < TMath::PiOver2()) return kFALSE;
1878 }
1879 //jump out this event if there is any other particle with pt larger than trigger
1880 else if(fMakeAbsoluteLeading)
1881 {
1882 if(pt > ptTrig) return kFALSE;
045396c8 1883 }
1884
1885 //Only for mixed event
1886 Int_t evtIndex2 = 0 ;
04f7a616 1887 if (GetMixedEvent())
1888 {
045396c8 1889 evtIndex2 = GetMixedEvent()->EventIndex(track->GetID()) ;
1890 if (evtIndex11 == evtIndex2 || evtIndex12 == evtIndex2 || evtIndex13 == evtIndex2 ) // photon and track from different events
1891 continue ;
1892 //vertex cut
1893 if (TMath::Abs(GetVertex(evtIndex2)[2]) > GetZvertexCut())
1894 return kFALSE;
1895 }
1896
045396c8 1897 // Fill Histograms
3f150b4b 1898 if(bFillHisto)
907b38cd 1899 {
66e64043 1900
283f989c 1901 if(GetDebug() > 2 )
1902 printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Selected charge for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta);
907b38cd 1903
1904 // Set the pt associated bin for the defined bins
1905 Int_t assocBin = -1;
1906 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
547c2f01 1907 {
907b38cd 1908 if(pt > fAssocPtBinLimit[i] && pt < fAssocPtBinLimit[i+1]) assocBin= i;
1909 }
66e64043 1910
907b38cd 1911 // Azimuthal Angle
1912 // calculate deltaPhi for later, shift when needed
1913 FillChargedAngularCorrelationHistograms(pt, ptTrig, assocBin, phi, phiTrig, deltaPhi,
1914 eta, etaTrig, decay, track->GetHMPIDsignal(),nTracks);
05d0d05d 1915
907b38cd 1916 // Imbalance zT/xE/pOut
1917 zT = pt/ptTrig ;
2e876d85 1918 if(zT > 0 ) hbpZT = TMath::Log10(1./zT);
907b38cd 1919 else hbpZT =-100;
e09cf5ef 1920
907b38cd 1921 xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
1922 //if(xE <0.)xE =-xE;
2e876d85 1923 if(xE > 0 ) hbpXE = TMath::Log10(1./xE);
907b38cd 1924 else hbpXE =-100;
1925
1926 pout = pt*TMath::Sin(deltaPhi) ;
66e64043 1927
907b38cd 1928 //delta phi cut for momentum imbalance correlation
547c2f01 1929 if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
1930 {
3f150b4b 1931
907b38cd 1932 FillChargedMomentumImbalanceHistograms(ptTrig, pt, xE, hbpXE, zT, hbpZT, pout, deltaPhi,
1933 nTracks, track->Charge(), assocBin, decay);
3f150b4b 1934
907b38cd 1935 }
547c2f01 1936 else if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
1937 { //UE study
3f150b4b 1938
907b38cd 1939 FillChargedUnderlyingEventHistograms(ptTrig, pt, deltaPhi, nTracks);
3f150b4b 1940
907b38cd 1941 }
e09cf5ef 1942
907b38cd 1943 if(fPi0Trigger && decayFound)
1944 FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2, kTRUE) ;
e09cf5ef 1945
1946 //several UE calculation
907b38cd 1947 if(fMakeSeveralUE) FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,xE,hbpXE,zT,hbpZT,deltaPhi);
1948
e09cf5ef 1949 } //Fill histogram
547c2f01 1950 else
1951 {
e09cf5ef 1952 nrefs++;
547c2f01 1953 if(nrefs==1)
1954 {
e09cf5ef 1955 reftracks = new TObjArray(0);
045396c8 1956 TString trackname = Form("%s+Tracks", GetAODObjArrayName().Data());
1957 reftracks->SetName(trackname.Data());
029dea5a 1958 reftracks->SetOwner(kFALSE);
e09cf5ef 1959 }
029dea5a 1960
e09cf5ef 1961 reftracks->Add(track);
029dea5a 1962
e09cf5ef 1963 }//aod particle loop
1964 }// track loop
1965
1966 //Fill AOD with reference tracks, if not filling histograms
547c2f01 1967 if(!bFillHisto && reftracks)
1968 {
e09cf5ef 1969 aodParticle->AddObjArray(reftracks);
1970 }
283f989c 1971
029dea5a 1972 //Own mixed event, add event and remove previous or fill the mixed histograms
2e876d85 1973 if(DoOwnMix() && bFillHisto)
029dea5a 1974 {
1975 MakeChargedMixCorrelation(aodParticle);
1976 }
1977
045396c8 1978 return kTRUE;
e09cf5ef 1979
1980}
1981
029dea5a 1982
1983//______________________________________________________________________________________________________________________
1984void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4ParticleCorrelation *aodParticle)
1985{
2e876d85 1986 // Mix current trigger with tracks in another MB event
029dea5a 1987
2e876d85 1988 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Make trigger particle - charged hadron mixed event correlation \n");
029dea5a 1989
1990 if(GetMixedEvent()) return; // This is not the mixed event from general mixing frame
1991
029dea5a 1992 // Get the event with similar caracteristics
2e876d85 1993 //printf("MakeChargedMixCorrelation for %s\n",GetInputAODName().Data());
1994
1995 AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
1996 AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
1997
1998 if(!(inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask())) return;
029dea5a 1999
2000 // Get the pool, check if it exits
2e876d85 2001 Int_t eventBin = GetEventMixBin();
2002
2003 fhEventBin->Fill(eventBin);
029dea5a 2004
2e876d85 2005 //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
2006 if(eventBin < 0) return;
029dea5a 2007
283f989c 2008 TList * pool = 0;
2009 if(fUseMixStoredInReader) pool = GetReader()->GetListWithMixedEventsForTracks(eventBin);
2010 else pool = fListMixEvents[eventBin];
2e876d85 2011
2012 if(!pool) return ;
029dea5a 2013
2014 Double_t ptTrig = aodParticle->Pt();
2015 Double_t etaTrig = aodParticle->Eta();
2016 Double_t phiTrig = aodParticle->Phi();
2017 if(phiTrig < 0.) phiTrig+=TMath::TwoPi();
2018
2e876d85 2019 if(GetDebug() > 1)
283f989c 2020 printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Pool bin %d size %d, leading trigger pt=%f, phi=%f, eta=%f\n",
2021 eventBin,pool->GetSize(), ptTrig,phiTrig,etaTrig);
029dea5a 2022
2023 Double_t ptAssoc = -999.;
2e876d85 2024 Double_t phiAssoc = -999.;
029dea5a 2025 Double_t etaAssoc = -999.;
2026 Double_t deltaPhi = -999.;
2027 Double_t deltaEta = -999.;
2028
2e876d85 2029 //Start from first event in pool except if in this same event the pool was filled
283f989c 2030 Int_t ev0 = 0;
2031 if(GetReader()->GetLastTracksMixedEvent() == GetEventNumber()) ev0 = 1;
2032 for(Int_t ev=ev0; ev < pool->GetSize(); ev++)
029dea5a 2033 {
2034 TObjArray* bgTracks = static_cast<TObjArray*>(pool->At(ev));
2035
2e876d85 2036 fhEventMixBin->Fill(eventBin);
029dea5a 2037
2e876d85 2038 Int_t nTracks=bgTracks->GetEntriesFast();
2039 //printf("\t Read Pool event %d, nTracks %d\n",ev,nTracks);
2040
029dea5a 2041 for(Int_t j1 = 0;j1 <nTracks; j1++ )
2042 {
2043 AliAODPWG4Particle *track = (AliAODPWG4Particle*) bgTracks->At(j1) ;
2044
2045 if(!track) continue;
2046
2047 ptAssoc = track->Pt();
2048 etaAssoc = track->Eta();
2049 phiAssoc = track->Phi() ;
2050 if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
2e876d85 2051
029dea5a 2052 if(IsFiducialCutOn())
2053 {
2054 Bool_t in = GetFiducialCut()->IsInFiducialCut(*aodParticle->Momentum(),"CTS") ;
2055 if(!in) continue ;
2056 }
2057
2058 deltaPhi = phiTrig-phiAssoc;
2059 if(deltaPhi < -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
2060 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
2061 deltaEta = etaTrig-etaAssoc;
2062
2063 if(GetDebug()>0)
2064 printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation(): deltaPhi= %f, deltaEta=%f\n",deltaPhi, deltaEta);
2065
2066 // Set the pt associated bin for the defined bins
2067 Int_t assocBin = -1;
2068 for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
2069 {
2070 if(ptAssoc > fAssocPtBinLimit[i] && ptAssoc < fAssocPtBinLimit[i+1]) assocBin= i;
2071 }
2072
2073 fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi);
2074 fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta);
2075
2076 if(assocBin < 0) continue ; // this pt bin was not considered
2077
2078 fhMixDeltaPhiChargedAssocPtBin[assocBin] ->Fill(ptTrig, deltaPhi);
2079 fhMixDeltaPhiDeltaEtaChargedAssocPtBin[assocBin]->Fill(deltaPhi, deltaEta);
2080
2081 } // track loop
2082 } // mixed event loop
2083}
2084
2085
05d0d05d 2086//________________________________________________________________________________________________________________
045396c8 2087Bool_t AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4ParticleCorrelation * const aodParticle,
c5693f62 2088 const TObjArray* pi0list, const Bool_t bFillHisto)
e09cf5ef 2089{
2090 // Neutral Pion Correlation Analysis
907b38cd 2091 if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Make trigger particle - pi0 correlation, %d pi0's \n",
2092 pi0list->GetEntriesFast());
e09cf5ef 2093
2094 Int_t evtIndex11 = 0 ;
2095 Int_t evtIndex12 = 0 ;
04f7a616 2096 if (GetMixedEvent())
2097 {
e09cf5ef 2098 evtIndex11 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(0)) ;
2099 evtIndex12 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(1)) ;
2100 }
2101
907b38cd 2102 Float_t pt = -100. ;
2103 Float_t zT = -100. ;
2104 Float_t phi = -100. ;
2105 Float_t eta = -100. ;
2106 Float_t xE = -100. ;
2107 Float_t hbpXE= -100. ;
2108 Float_t hbpZT= -100. ;
2109
2110 Float_t ptTrig = aodParticle->Pt();
2111 Float_t phiTrig = aodParticle->Phi();
2112 Float_t etaTrig = aodParticle->Eta();
2113 Float_t deltaPhi= -100. ;
3f150b4b 2114
045396c8 2115 TLorentzVector photonMom ;
2116
907b38cd 2117 // In case of pi0/eta trigger, we may want to check their decay correlation,
2118 // get their decay children
2119 TLorentzVector decayMom1;
2120 TLorentzVector decayMom2;
2121 Bool_t decayFound = kFALSE;
2122 if(fPi0Trigger && bFillHisto) decayFound = GetDecayPhotonMomentum(aodParticle,decayMom1, decayMom2);
e09cf5ef 2123
907b38cd 2124 TObjArray * refpi0 = 0x0;
2125 Int_t nrefs = 0;
e09cf5ef 2126
2127 //Loop on stored AOD pi0
547c2f01 2128
e09cf5ef 2129 Int_t naod = pi0list->GetEntriesFast();
045396c8 2130 if(GetDebug() > 0)
2131 printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillHistograms() - aod branch entries %d\n", naod);
547c2f01 2132
2133 for(Int_t iaod = 0; iaod < naod ; iaod++)
2134 {
e09cf5ef 2135 AliAODPWG4Particle* pi0 = (AliAODPWG4Particle*) (pi0list->At(iaod));
2136
2137 Int_t evtIndex2 = 0 ;
2138 Int_t evtIndex3 = 0 ;
04f7a616 2139 if (GetMixedEvent())
2140 {
e09cf5ef 2141 evtIndex2 = GetMixedEvent()->EventIndexForCaloCluster(pi0->GetCaloLabel(0)) ;
2142 evtIndex3 = GetMixedEvent()->EventIndexForCaloCluster(pi0->GetCaloLabel(1)) ;
2143
045396c8 2144 if (evtIndex11 == evtIndex2 || evtIndex12 == evtIndex2 ||
2145 evtIndex11 == evtIndex3 || evtIndex12 == evtIndex3) // trigger and pi0 are not from different events
e09cf5ef 2146 continue ;
2147 }
907b38cd 2148
e09cf5ef 2149 pt = pi0->Pt();
907b38cd 2150
66e64043 2151 if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
2152
907b38cd 2153 //jump out this event if near side associated particle pt larger than trigger
2154 if (fMakeNearSideLeading)
2155 {
2156 if(pt > ptTrig && TMath::Abs(phi-phiTrig) < TMath::PiOver2()) return kFALSE;
2157 }
2158 //jump out this event if there is any other particle with pt larger than trigger
2159 else if(fMakeAbsoluteLeading)
2160 {
2161 if(pt > ptTrig) return kFALSE;
2162 }
e09cf5ef 2163
547c2f01 2164 if(bFillHisto)
2165 {
e09cf5ef 2166 phi = pi0->Phi() ;
2167 eta = pi0->Eta() ;
907b38cd 2168
2169 FillNeutralAngularCorrelationHistograms(pt, ptTrig, phi, phiTrig, deltaPhi, eta, etaTrig);
2170
3f150b4b 2171 zT = pt/ptTrig ;
2172 xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
2173
66e64043 2174 //if(xE <0.)xE =-xE;
e09cf5ef 2175
3f150b4b 2176 hbpXE = -100;
2177 hbpZT = -100;
907b38cd 2178
2e876d85 2179 if(xE > 0 ) hbpXE = TMath::Log10(1./xE);
2180 if(zT > 0 ) hbpZT = TMath::Log10(1./zT);
e09cf5ef 2181
907b38cd 2182 if(fPi0Trigger && decayFound)
2183 FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2,kFALSE) ;
e09cf5ef 2184
2185 //delta phi cut for correlation
547c2f01 2186 if( (deltaPhi > fDeltaPhiMinCut) && ( deltaPhi < fDeltaPhiMaxCut) )
2187 {
045396c8 2188 fhDeltaPhiNeutralPt->Fill(pt,deltaPhi);
3f150b4b 2189 fhXENeutral ->Fill(ptTrig,xE);
2190 fhPtHbpXENeutral ->Fill(ptTrig,hbpXE);
e09cf5ef 2191 }
907b38cd 2192 else if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
547c2f01 2193 {
045396c8 2194 fhDeltaPhiUeNeutralPt->Fill(pt,deltaPhi);
3f150b4b 2195 fhXEUeNeutral ->Fill(ptTrig,xE);
2196 fhPtHbpXEUeNeutral ->Fill(ptTrig,hbpXE);
e09cf5ef 2197 }
907b38cd 2198
e09cf5ef 2199 //several UE calculation
907b38cd 2200 if(fMakeSeveralUE) FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,xE,hbpXE,zT,hbpZT,deltaPhi);
2201
e09cf5ef 2202 }
547c2f01 2203 else
2204 {
e09cf5ef 2205 nrefs++;
547c2f01 2206 if(nrefs==1)
2207 {
e09cf5ef 2208 refpi0 = new TObjArray(0);
2209 refpi0->SetName(GetAODObjArrayName()+"Pi0s");
2210 refpi0->SetOwner(kFALSE);
2211 }
2212 refpi0->Add(pi0);
2213 }//put references in trigger AOD
045396c8 2214
2215 if(GetDebug() > 2 )
2216 printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Selected neutral for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta);
2217
2218 }//loop
2219
2220 return kTRUE;
2221}
2222
05d0d05d 2223//_________________________________________________________________________________________________________
045396c8 2224void AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle)
2225{
2226 // Charged Hadron Correlation Analysis with MC information
a426f453 2227
045396c8 2228 if(GetDebug()>1)
2229 printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation() - Make trigger particle - charged hadron correlation in AOD MC level\n");
2230
2231 AliStack * stack = 0x0 ;
2232 TParticle * primary = 0x0 ;
2233 TClonesArray * mcparticles0 = 0x0 ;
2234 TClonesArray * mcparticles = 0x0 ;
2235 AliAODMCParticle * aodprimary = 0x0 ;
2236
2237 Double_t eprim = 0 ;
2238 Double_t ptprim = 0 ;
2239 Double_t phiprim = 0 ;
2240 Double_t etaprim = 0 ;
045396c8 2241 Int_t nTracks = 0 ;
2242 Int_t iParticle = 0 ;
2243 Double_t charge = 0.;
66e64043 2244
547c2f01 2245 if(GetReader()->ReadStack())
2246 {
045396c8 2247 nTracks = GetMCStack()->GetNtrack() ;
2248 }
547c2f01 2249 else
2250 {
2251 nTracks = GetReader()->GetAODMCParticles()->GetEntriesFast() ;
2252 }
045396c8 2253 //Int_t trackIndex[nTracks];
2254
2255 Int_t label= aodParticle->GetLabel();
a426f453 2256 if(label < 0)
2257 {
2258 if(GetDebug() > 0) printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** bad label ***: label %d \n", label);
045396c8 2259 return;
2260 }
2261
547c2f01 2262 if(GetReader()->ReadStack())
2263 {
045396c8 2264 stack = GetMCStack() ;
2e876d85 2265 if(!stack)
2266 {
045396c8 2267 printf(" AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation- Stack not available, is the MC handler called? STOP\n");
2268 abort();
2269 }
2270
2271 nTracks=stack->GetNprimary();
547c2f01 2272 if(label >= stack->GetNtrack())
2273 {
045396c8 2274 if(GetDebug() > 2) printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** large label ***: label %d, n tracks %d \n", label, stack->GetNtrack());
2275 return ;
2276 }
547c2f01 2277
045396c8 2278 primary = stack->Particle(label);
547c2f01 2279 if(!primary)
2280 {
045396c8 2281 printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** no primary ***: label %d \n", label);
2282 return;
2283 }
2284
547c2f01 2285 if(primary)
2286 {
2747966a 2287 eprim = primary->Energy();
2288 ptprim = primary->Pt();
2289 phiprim = primary->Phi();
2290 etaprim = primary->Eta();
2747966a 2291
2292 if(ptprim < 0.01 || eprim < 0.01) return ;
2293
547c2f01 2294 for (iParticle = 0 ; iParticle < nTracks ; iParticle++)
2295 {
045396c8 2296 TParticle * particle = stack->Particle(iParticle);
2297 TLorentzVector momentum;
3f150b4b 2298
045396c8 2299 //keep only final state particles
2300 if(particle->GetStatusCode()!=1) continue ;
3f150b4b 2301
2302 Int_t pdg = particle->GetPdgCode();
2303
045396c8 2304 charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
3f150b4b 2305
045396c8 2306 particle->Momentum(momentum);
2307
2308 //---------- Charged particles ----------------------
547c2f01 2309 if(charge != 0)
2310 {
045396c8 2311 //Particles in CTS acceptance
2312 Bool_t inCTS = GetFiducialCut()->IsInFiducialCut(momentum,"CTS");
3f150b4b 2313
045396c8 2314 if(TMath::Abs(pdg) == 11 && stack->Particle(particle->GetFirstMother())->GetPdgCode()==22) continue ;
3f150b4b 2315
66e64043 2316 if(inCTS)
045396c8 2317 {
907b38cd 2318 if( label!=iParticle) // avoid trigger particle
2319 {
2320 if(!FillChargedMCCorrelationHistograms(particle->Pt(),particle->Phi(),particle->Eta(),ptprim,phiprim,etaprim)) return;
2321 }
2322 }// in CTS acceptance
2323 }// charged
045396c8 2324 } //track loop
2325 } //when the leading particles could trace back to MC
2326 } //ESD MC
547c2f01 2327 else if(GetReader()->ReadAODMCParticles())
2328 {
045396c8 2329 //Get the list of MC particles
2330 mcparticles0 = GetReader()->GetAODMCParticles(0);
2331 if(!mcparticles0) return;
547c2f01 2332 if(label >=mcparticles0->GetEntriesFast())
2333 {
045396c8 2334 if(GetDebug() > 2)
2335 printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** large label ***: label %d, n tracks %d \n", label,mcparticles0->GetEntriesFast());
2336 return;
2337 }
2338 //Get the particle
2339 aodprimary = (AliAODMCParticle*) mcparticles0->At(label);
547c2f01 2340 if(!aodprimary)
2341 {
045396c8 2342 printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** no AOD primary ***: label %d \n", label);
2343 return;
2344 }
2345
547c2f01 2346 if(aodprimary)
2347 {
2747966a 2348 ptprim = aodprimary->Pt();
2349 phiprim = aodprimary->Phi();
2350 etaprim = aodprimary->Eta();
2747966a 2351
2352 if(ptprim < 0.01 || eprim < 0.01) return ;
2353
045396c8 2354 mcparticles= GetReader()->GetAODMCParticles();
907b38cd 2355 for (Int_t i = 0; i < nTracks; i++)
547c2f01 2356 {
045396c8 2357 AliAODMCParticle *part = (AliAODMCParticle*) mcparticles->At(i);
2358 if (!part->IsPhysicalPrimary()) continue;
2359 Int_t pdg = part->GetPdgCode();
2360 charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
2361 TLorentzVector momentum(part->Px(),part->Py(),part->Pz(),part->E());
547c2f01 2362 if(charge != 0)
2363 {
2364 if(part->Pt()> GetReader()->GetCTSPtMin())
2365 {
045396c8 2366 //Particles in CTS acceptance
2367 Bool_t inCTS = GetFiducialCut()->IsInFiducialCut(momentum,"CTS");
2368 Int_t indexmother=part->GetMother();
2369 if(indexmother>-1)
2370 {
2371 Int_t mPdg = ((AliAODMCParticle*) mcparticles->At(indexmother)) ->GetPdgCode();
2372 if(TMath::Abs(pdg) == 11 && mPdg == 22) continue;
2373 }
547c2f01 2374
66e64043 2375 if(inCTS)
045396c8 2376 {
907b38cd 2377 if( label!=iParticle) // avoid trigger particle
2378 {
2379 if(!FillChargedMCCorrelationHistograms(part->Pt(),part->Phi(),part->Eta(),ptprim,phiprim,etaprim)) return;
2380 }
2381 } // in acceptance
2382 } // min pt cut
045396c8 2383 } //only charged particles
2384 } //MC particle loop
2385 } //when the leading particles could trace back to MC
2386 }// AOD MC
e09cf5ef 2387}
045396c8 2388
05d0d05d 2389//_____________________________________________________________________
2390void AliAnaParticleHadronCorrelation::Print(const Option_t * opt) const
2391{
2392
2393 //Print some relevant parameters set for the analysis
2394 if(! opt)
2395 return;
2396
2397 printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
745913ae 2398 AliAnaCaloTrackCorrBaseClass::Print(" ");
66e64043 2399 printf("Pt trigger > %3.2f\n", fMinTriggerPt) ;
2400 printf("Pt associated hadron < %3.2f\n", fMaxAssocPt) ;
2401 printf("Pt associated hadron > %3.2f\n", fMinAssocPt) ;
2402 printf("Phi trigger particle-Hadron < %3.2f\n", fDeltaPhiMaxCut) ;
2403 printf("Phi trigger particle-Hadron > %3.2f\n", fDeltaPhiMinCut) ;
2404 printf("Phi trigger particle-UeHadron < %3.2f\n", fUeDeltaPhiMaxCut) ;
2405 printf("Phi trigger particle-UeHadron > %3.2f\n", fUeDeltaPhiMinCut) ;
2406 printf("Isolated Trigger? %d\n" , fSelectIsolated) ;
2407 printf("Several UE? %d\n" , fMakeSeveralUE) ;
2408 printf("Name of AOD Pi0 Branch %s \n", fPi0AODBranchName.Data());
05d0d05d 2409 printf("Do Decay-hadron correlation ? %d\n", fPi0Trigger) ;
3f150b4b 2410 printf("Select absolute leading for cluster triggers ? %d or Near Side %d\n",
2411 fMakeAbsoluteLeading, fMakeNearSideLeading) ;
05d0d05d 2412 printf("Trigger pt bins %d\n", fNAssocPtBins) ;
2413 for (Int_t ibin = 0; ibin<fNAssocPtBins; ibin++) {
2414 printf("\t bin %d = [%2.1f,%2.1f]\n", ibin, fAssocPtBinLimit[ibin], fAssocPtBinLimit[ibin+1]) ;
2415 }
2416
2417}
2418
2419//____________________________________________________________
2420void AliAnaParticleHadronCorrelation::SetNAssocPtBins(Int_t n)
045396c8 2421{
2422 // Set number of bins
e09cf5ef 2423
05d0d05d 2424 fNAssocPtBins = n ;
2425
2426
045396c8 2427 if(n < 10 && n > 0)
2428 {
05d0d05d 2429 fNAssocPtBins = n ;
045396c8 2430 }
2431 else
2432 {
2433 printf("n = larger than 9 or too small, set to 9 \n");
05d0d05d 2434 fNAssocPtBins = 9;
045396c8 2435 }
2436}
e09cf5ef 2437
05d0d05d 2438//______________________________________________________________________________
2439void AliAnaParticleHadronCorrelation::SetAssocPtBinLimit(Int_t ibin, Float_t pt)
045396c8 2440{
2441 // Set the list of limits for the trigger pt bins
2442
05d0d05d 2443 if(ibin <= fNAssocPtBins || ibin >= 0)
045396c8 2444 {
05d0d05d 2445 fAssocPtBinLimit[ibin] = pt ;
045396c8 2446 }
2e876d85 2447 else
2448 {
05d0d05d 2449 printf("AliAnaParticleHadronCorrelation::SetAssocPtBinLimit() - bin number too large %d > %d or small, nothing done\n", ibin, fNAssocPtBins) ;
045396c8 2450 }
2451}
2452