AliPhysics  58f3d52 (58f3d52)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnaParticleJetLeadingConeCorrelation.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: The ALICE Off-line Project. *
5  * Contributors are mentioned in the code where appropriate. *
6  * *
7  * Permission to use, copy, modify and distribute this software and its *
8  * documentation strictly for non-commercial purposes 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  **************************************************************************/
15 
16 // --- ROOT system ---
17 #include "TH2F.h"
18 #include "TClonesArray.h"
19 #include "TClass.h"
20 //#include "Riostream.h"
21 
22 // --- Analysis system ---
23 #include "AliVTrack.h"
24 #include "AliVCluster.h"
25 #include "AliCaloTrackReader.h"
28 #include "AliCaloPID.h"
30 #include "AliFiducialCut.h"
31 
35 
36 //_________________________________________________________________________________
38 //_________________________________________________________________________________
40 AliAnaCaloTrackCorrBaseClass(), fJetsOnlyInCTS(kFALSE), fPbPb(kFALSE),
41 fSeveralConeAndPtCuts(0), fReMakeJet(0),
42 fDeltaPhiMaxCut(0.), fDeltaPhiMinCut(0.),
43 fLeadingRatioMaxCut(0.), fLeadingRatioMinCut(0.),
44 fJetCTSRatioMaxCut(0.), fJetCTSRatioMinCut(0.),
45 fJetRatioMaxCut(0.), fJetRatioMinCut(0.),
46 fJetNCone(0),fJetNPt(0), fJetCone(0),
47 fJetPtThreshold(0),fJetPtThresPbPb(0),
48 fPtTriggerSelectionCut(0.0), fSelect(0),fSelectIsolated(0),
49 fTrackVector(),fBkgMom(),fJetMom(),fJetConstMom(),
50 fLeadingMom(),fLeadingPi0Mom(),fLeadingPhoMom1(),fLeadingPhoMom2(),fLeadingChargeMom(),
51 // Histograms
52 fOutCont(0x0),
53 // Leading
54 fhChargedLeadingPt(0),fhChargedLeadingPhi(0),fhChargedLeadingEta(0),
55 fhChargedLeadingDeltaPt(0),fhChargedLeadingDeltaPhi(0),fhChargedLeadingDeltaEta(0),
56 fhChargedLeadingRatioPt(0),
57 fhNeutralLeadingPt(0),fhNeutralLeadingPhi(0),fhNeutralLeadingEta(0),
58 fhNeutralLeadingDeltaPt(0),fhNeutralLeadingDeltaPhi(0),fhNeutralLeadingDeltaEta(0),
59 fhNeutralLeadingRatioPt(0),fhChargedLeadingXi(0), fhNeutralLeadingXi(0),
60 fhChargedLeadingDeltaPhiRatioPt30(0), fhNeutralLeadingDeltaPhiRatioPt30(0),
61 fhChargedLeadingDeltaPhiRatioPt50(0), fhNeutralLeadingDeltaPhiRatioPt50(0),
62 //Jet
63 fhJetPt(0),fhJetRatioPt(0),fhJetDeltaPhi(0), fhJetDeltaEta(0),
64 fhJetLeadingRatioPt(0),fhJetLeadingDeltaPhi(0),fhJetLeadingDeltaEta(0),
65 fhJetFFz(0),fhJetFFxi(0),fhJetFFpt(0),fhJetNTracksInCone(0),
66 fhBkgPt(0),fhBkgRatioPt(0),fhBkgDeltaPhi(0), fhBkgDeltaEta(0),
67 fhBkgLeadingRatioPt(0),fhBkgLeadingDeltaPhi(0),fhBkgLeadingDeltaEta(0),
68 fhBkgFFz(0),fhBkgFFxi(0),fhBkgFFpt(0),fhBkgNTracksInCone(0),
69 // Several cones and thres histograms
70 fhJetPts(),fhJetRatioPts(),fhJetDeltaPhis(), fhJetDeltaEtas(),
71 fhJetLeadingRatioPts(),fhJetLeadingDeltaPhis(),fhJetLeadingDeltaEtas(),
72 fhJetFFzs(),fhJetFFxis(),fhJetFFpts(),fhJetNTracksInCones(),
73 fhBkgPts(),fhBkgRatioPts(),fhBkgDeltaPhis(), fhBkgDeltaEtas(),
74 fhBkgLeadingRatioPts(),fhBkgLeadingDeltaPhis(),fhBkgLeadingDeltaEtas(),
75 fhBkgFFzs(),fhBkgFFxis(),fhBkgFFpts(),fhBkgNTracksInCones()
76 {
77  for(Int_t i = 0; i<6; i++)
78  {
79  fJetXMin1[i] = 0.0 ;
80  fJetXMin2[i] = 0.0 ;
81  fJetXMax1[i] = 0.0 ;
82  fJetXMax2[i] = 0.0 ;
83  fBkgMean[i] = 0.0 ;
84  fBkgRMS[i] = 0.0 ;
85  if( i < 2 ){
86  fJetE1[i] = 0.0 ;
87  fJetE2[i] = 0.0 ;
88  fJetSigma1[i] = 0.0 ;
89  fJetSigma2[i] = 0.0 ;
90  }
91  }
92 
93  // Several cones and thres histograms
94  for(Int_t i = 0; i<5; i++)
95  {
96  fJetCones[i] = 0.0 ;
97  fJetNameCones[i] = "" ;
98  fJetPtThres[i] = 0.0 ;
99  fJetNamePtThres[i] = "" ;
100  for(Int_t j = 0; j<5; j++)
101  {
102  fhJetPts[i][j]=0 ;
103  fhJetRatioPts[i][j]=0 ;
104  fhJetDeltaPhis[i][j]=0 ;
105  fhJetDeltaEtas[i][j]=0 ;
106  fhJetLeadingRatioPts[i][j]=0 ;
107  fhJetLeadingDeltaPhis[i][j]=0 ;
108  fhJetLeadingDeltaEtas[i][j]=0 ;
109  fhJetFFzs[i][j]=0 ;
110  fhJetFFxis[i][j]=0 ;
111  fhJetFFpts[i][j]=0 ;
112  fhJetNTracksInCones[i][j]=0 ;
113  fhBkgPts[i][j]=0 ;
114  fhBkgRatioPts[i][j]=0 ;
115  fhBkgDeltaPhis[i][j]=0 ;
116  fhBkgDeltaEtas[i][j]=0 ;
117  fhBkgLeadingRatioPts[i][j]=0 ;
118  fhBkgLeadingDeltaPhis[i][j]=0 ;
119  fhBkgLeadingDeltaEtas[i][j]=0 ;
120  fhBkgFFzs[i][j]=0 ;
121  fhBkgFFxis[i][j]=0 ;
122  fhBkgFFpts[i][j]=0 ;
123  fhBkgNTracksInCones[i][j]=0 ;
124  }
125  }
126 
127  InitParameters();
128 }
129 
130 //____________________________________________________________________________
133 //____________________________________________________________________________
135  const Double_t *par, const Double_t *x) const
136 {
137  //printf("CalculateLimit: x1 %2.3f, x2%2.3f\n",x[0],x[1]);
138  Double_t ePP = par[0] + par[1] * ptg ;
139  Double_t sPP = par[2] + par[3] * ptg ;
140  Double_t f = x[0] + x[1] * ptg ;
141  Double_t ePbPb = ePP + par[4] ;
142  Double_t sPbPb = TMath::Sqrt(sPP*sPP+ par[5]*par[5]) ;
143  Double_t rat = (ePbPb - sPbPb * f) / ptg ;
144  //printf("CalculateLimit: ePP %2.3f, sPP %2.3f, f %2.3f\n", ePP, sPP, f);
145  //printf("CalculateLimit: ePbPb %2.3f, sPbPb %2.3f, rat %2.3f\n", ePbPb, sPbPb, rat);
146  return rat ;
147 }
148 
149 //___________________________________________________________________________________________________
151 //___________________________________________________________________________________________________
153  const TLorentzVector jet,
154  const TString & type, const TString & lastname)
155 {
156  Double_t ptTrig = particle->Pt();
157  Double_t ptJet = jet.Pt();
158  Double_t ptLead = fLeadingMom.Pt();
159  Double_t phiTrig = particle->Phi();
160  Double_t phiJet = jet.Phi();
161  if(phiJet < 0) phiJet+=TMath::TwoPi();
162  Double_t phiLead = fLeadingMom.Phi();
163  if(phiLead < 0) phiLead+=TMath::TwoPi();
164  Double_t etaTrig = particle->Eta();
165  Double_t etaJet = jet.Eta();
166  Double_t etaLead = fLeadingMom.Eta();
167 
168  TH2F *h1 = 0x0;
169  h1 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sPt%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
170  if(h1) h1->Fill(ptTrig, ptJet, GetEventWeight());
171 
172  TH2F *h2 = 0x0;
173  h2 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sRatioPt%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
174  if(h2) h2->Fill(ptTrig, ptJet/ptTrig, GetEventWeight());
175 
176  TH2F *h3 = 0x0;
177  h3 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sLeadingRatioPt%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
178  if(h3) h3->Fill(ptTrig, ptLead/ptJet, GetEventWeight());
179 
180  // dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sPhi%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())))->
181  // Fill(ptTrig,phiJet);
182  TH2F *h4 = 0x0;
183  h4 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sDeltaPhi%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
184  if(h4) h4->Fill(ptTrig, phiJet-phiTrig, GetEventWeight());
185 
186  TH2F *h5 = 0x0;
187  h5 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sLeadingDeltaPhi%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
188  if(h5) h5->Fill(ptTrig, phiJet-phiLead, GetEventWeight());
189 
190  // dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sEta%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())))->
191  // Fill(ptTrig,etaJet);
192  TH2F *h6 = 0x0;
193  h6 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sDeltaEta%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
194  if(h6) h6->Fill(ptTrig, etaJet-etaTrig, GetEventWeight());
195 
196  TH2F *h7 = 0x0;
197  h7 = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sLeadingDeltaEta%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
198  if(h7) h7->Fill(ptTrig, etaJet-etaLead, GetEventWeight());
199 
200  // Construct fragmentation function
201  TObjArray * pl = new TObjArray;
202 
203  if (type == "Jet") pl = particle->GetObjArray(Form("%sTracks",GetAODObjArrayName().Data()));
204  else if(type == "Bkg") particle->GetObjArray(Form("%sTracksBkg",GetAODObjArrayName().Data()));
205 
206  if(!pl) return ;
207 
208  // Different pt cut for jet particles in different collisions systems
209  // Only needed when jet is recalculated from AODs
210  // Float_t ptcut = fJetPtThreshold;
211  // if(fPbPb && !fSeveralConeAndPtCuts && ptTrig > fPtTriggerSelectionCut) ptcut = fJetPtThresPbPb ;
212 
213  Int_t nTracksInCone = 0;
214 
215  for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ )
216  {
217  AliVTrack* track = dynamic_cast<AliVTrack *>(pl->At(ipr)) ;
218  if(track)fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
219  else AliDebug(1,"Track not available");
220 
221  //Recheck if particle is in jet cone
223  if(!IsParticleInJetCone(fTrackVector.Eta(), fTrackVector.Phi(), fLeadingMom.Eta(), fLeadingMom.Phi()) ) continue ;
224 
225  nTracksInCone++;
226 
227  TH2F *ha =dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sFFz%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
228  if(ha) ha->Fill(ptTrig, fTrackVector.Pt()/ptTrig, GetEventWeight());
229 
230  TH2F *hb =dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sFFxi%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
231  if(hb) hb->Fill(ptTrig, TMath::Log(ptTrig/fTrackVector.Pt()), GetEventWeight());
232 
233  TH2F *hc =dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sFFpt%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
234  if(hc) hc->Fill(ptTrig, fTrackVector.Pt(), GetEventWeight());
235 
236  }//track loop
237 
238  if(nTracksInCone > 0)
239  {
240  TH2F *hd = dynamic_cast<TH2F*>(GetOutputContainer()->FindObject(Form("%s%sNTracksInCone%s",GetAddedHistogramsStringToName().Data(),type.Data(),lastname.Data())));
241  if(hd) hd->Fill(ptTrig, nTracksInCone, GetEventWeight());
242  }
243 }
244 
245 //________________________________________________________________________
248 //________________________________________________________________________
250 {
251  fOutCont = new TList() ;
252  fOutCont->SetName("ParticleJetLeadingInConeCorrelationHistograms") ;
253 
255  Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins();
256  Int_t netabins = GetHistogramRanges()->GetHistoEtaBins();
263 
264  fhChargedLeadingPt = new TH2F("ChargedLeadingPt","p_{T leading charge} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
265  fhChargedLeadingPt->SetYTitle("p_{T leading charge}");
266  fhChargedLeadingPt->SetXTitle("p_{T trigger} (GeV/c)");
267 
268  fhChargedLeadingPhi = new TH2F("ChargedLeadingPhi","#phi_{h^{#pm}} vs p_{T trigger}", nptbins,ptmin,ptmax,nphibins,phimin,phimax);
269  fhChargedLeadingPhi->SetYTitle("#phi_{h^{#pm}} (rad)");
270  fhChargedLeadingPhi->SetXTitle("p_{T trigger} (GeV/c)");
271 
272  fhChargedLeadingEta = new TH2F("ChargedLeadingEta","#eta_{h^{#pm}} vs p_{T trigger}",nptbins,ptmin,ptmax,netabins,etamin,etamax);
273  fhChargedLeadingEta->SetYTitle("#eta_{h^{#pm}} ");
274  fhChargedLeadingEta->SetXTitle("p_{T trigger} (GeV/c)");
275 
276  fhChargedLeadingDeltaPt = new TH2F("ChargedLeadingDeltaPt","p_{T trigger} - p_{T h^{#pm}} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
277  fhChargedLeadingDeltaPt->SetYTitle("#Delta p_{T} (GeV/c)");
278  fhChargedLeadingDeltaPt->SetXTitle("p_{T trigger} (GeV/c)");
279 
280  fhChargedLeadingDeltaPhi = new TH2F("ChargedLeadingDeltaPhi","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,TMath::TwoPi());
281  fhChargedLeadingDeltaPhi->SetYTitle("#Delta #phi (rad)");
282  fhChargedLeadingDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)");
283 
284  fhChargedLeadingDeltaEta = new TH2F("ChargedLeadingDeltaEta","#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2);
285  fhChargedLeadingDeltaEta->SetYTitle("#Delta #eta");
286  fhChargedLeadingDeltaEta->SetXTitle("p_{T trigger} (GeV/c)");
287 
288  fhChargedLeadingRatioPt = new TH2F("ChargedLeadingRatioPt","p_{T leading charge} /p_{T trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2);
289  fhChargedLeadingRatioPt->SetYTitle("p_{T lead charge} /p_{T trigger}");
290  fhChargedLeadingRatioPt->SetXTitle("p_{T trigger} (GeV/c)");
291 
292  fhChargedLeadingXi = new TH2F("ChargedLeadingXi","ln(p_{T trigger} / p_{T leading charge} ) vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,10);
293  fhChargedLeadingXi->SetYTitle("#xi");
294  fhChargedLeadingXi->SetXTitle("p_{T trigger} (GeV/c)");
295 
304 
305  fhChargedLeadingDeltaPhiRatioPt30 = new TH2F("ChargedLeadingDeltaPhiRatioPt30","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, charged leading, p_{T trigger} > 30 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1);
306  fhChargedLeadingDeltaPhiRatioPt30->SetXTitle("#Delta #phi (rad)");
307  fhChargedLeadingDeltaPhiRatioPt30->SetYTitle("p_{T leading} / p_{T trigger}");
308 
309  fhChargedLeadingDeltaPhiRatioPt50 = new TH2F("ChargedLeadingDeltaPhiRatioPt50","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, charged leading, p_{T trigger} > 50 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1);
310  fhChargedLeadingDeltaPhiRatioPt50->SetXTitle("#Delta #phi (rad)");
311  fhChargedLeadingDeltaPhiRatioPt50->SetYTitle("p_{T leading} / p_{T trigger}");
312 
315 
316  if(!fJetsOnlyInCTS){
317 
318  fhNeutralLeadingPt = new TH2F("NeutralLeadingPt","p_{T leading #pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
319  fhNeutralLeadingPt->SetYTitle("p_{T leading #pi^{0}}");
320  fhNeutralLeadingPt->SetXTitle("p_{T trigger} (GeV/c)");
321 
322  fhNeutralLeadingPhi = new TH2F("NeutralLeadingPhi","#phi_{#pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
323  fhNeutralLeadingPhi->SetYTitle("#phi_{#pi^{0}} (rad)");
324  fhNeutralLeadingPhi->SetXTitle("p_{T trigger} (GeV/c)");
325 
326  fhNeutralLeadingEta = new TH2F("NeutralLeadingEta","#eta_{#pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,netabins,etamin,etamax);
327  fhNeutralLeadingEta->SetYTitle("#eta_{#pi^{0}} ");
328  fhNeutralLeadingEta->SetXTitle("p_{T trigger} (GeV/c)");
329 
330  fhNeutralLeadingDeltaPt = new TH2F("NeutralLeadingDeltaPt","p_{T trigger} - p_{T #pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
331  fhNeutralLeadingDeltaPt->SetYTitle("#Delta p_{T} (GeV/c)");
332  fhNeutralLeadingDeltaPt->SetXTitle("p_{T trigger} (GeV/c)");
333 
334  fhNeutralLeadingDeltaPhi = new TH2F("NeutralLeadingDeltaPhi","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,TMath::TwoPi());
335  fhNeutralLeadingDeltaPhi->SetYTitle("#Delta #phi (rad)");
336  fhNeutralLeadingDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)");
337 
338  fhNeutralLeadingDeltaEta = new TH2F("NeutralLeadingDeltaEta","#eta_{trigger} - #eta_{#pi^{0}} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2);
339  fhNeutralLeadingDeltaEta->SetYTitle("#Delta #eta");
340  fhNeutralLeadingDeltaEta->SetXTitle("p_{T trigger} (GeV/c)");
341 
342  fhNeutralLeadingRatioPt = new TH2F("NeutralLeadingRatioPt","p_{T leading #pi^{0}} /p_{T trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2);
343  fhNeutralLeadingRatioPt->SetYTitle("p_{T lead #pi^{0}} /p_{T trigger}");
344  fhNeutralLeadingRatioPt->SetXTitle("p_{T trigger} (GeV/c)");
345 
346  fhNeutralLeadingXi = new TH2F("NeutralLeadingXi","ln(p_{T trigger} / p_{T leading #pi^{0}} ) vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,10);
347  fhNeutralLeadingXi->SetYTitle("#xi");
348  fhNeutralLeadingXi->SetXTitle("p_{T trigger} (GeV/c)");
349 
358 
359  fhNeutralLeadingDeltaPhiRatioPt30 = new TH2F("NeutralLeadingDeltaPhiRatioPt30","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, neutral leading, p_{T trigger} > 30 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1);
360  fhNeutralLeadingDeltaPhiRatioPt30->SetXTitle("#Delta #phi (rad)");
361  fhNeutralLeadingDeltaPhiRatioPt30->SetYTitle("p_{T leading} / p_{T trigger}");
362 
363  fhNeutralLeadingDeltaPhiRatioPt50 = new TH2F("NeutralLeadingDeltaPhiRatioPt50","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T leading}/p_{T trigger}, neutral leading, p_{T trigger} > 50 GeV/c",120,0,TMath::TwoPi(),nptbins,0,1);
364  fhNeutralLeadingDeltaPhiRatioPt50->SetXTitle("#Delta #phi (rad)");
365  fhNeutralLeadingDeltaPhiRatioPt50->SetYTitle("p_{T leading} / p_{T trigger}");
368 
369  }
370 
371  if(!fSeveralConeAndPtCuts){// not several cones
372 
373  //Jet Distributions
374  fhJetPt = new TH2F("JetPt","p_{T jet} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
375  fhJetPt->SetYTitle("p_{T jet}");
376  fhJetPt->SetXTitle("p_{T trigger} (GeV/c)");
377 
378  fhJetRatioPt = new TH2F("JetRatioPt","p_{T jet}/p_{T trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2);
379  fhJetRatioPt->SetYTitle("p_{T jet}/p_{T trigger}");
380  fhJetRatioPt->SetXTitle("p_{T trigger} (GeV/c)");
381 
382  fhJetDeltaPhi = new TH2F("JetDeltaPhi","#phi_{jet} - #phi_{trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,TMath::TwoPi());
383  fhJetDeltaPhi->SetYTitle("#Delta #phi (rad)");
384  fhJetDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)");
385 
386  fhJetDeltaEta = new TH2F("JetDeltaEta","#eta_{jet} - #eta_{trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2);
387  fhJetDeltaEta->SetYTitle("#Delta #eta");
388  fhJetDeltaEta->SetXTitle("p_{T trigger} (GeV/c)");
389 
390  fhJetLeadingRatioPt = new TH2F("JetLeadingRatioPt","p_{T jet} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2);
391  fhJetLeadingRatioPt->SetYTitle("p_{T leading}/p_{T jet}");
392  fhJetLeadingRatioPt->SetXTitle("p_{T trigger} (GeV/c)");
393 
394  fhJetLeadingDeltaPhi = new TH2F("JetLeadingDeltaPhi","#phi_{jet} - #phi_{leading} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-TMath::Pi(),TMath::Pi());
395  fhJetLeadingDeltaPhi->SetYTitle("#Delta #phi (rad)");
396  fhJetLeadingDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)");
397 
398  fhJetLeadingDeltaEta = new TH2F("JetLeadingDeltaEta","#eta_{jet} - #eta_{leading} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2);
399  fhJetLeadingDeltaEta->SetYTitle("#Delta #eta");
400  fhJetLeadingDeltaEta->SetXTitle("p_{T trigger} (GeV/c)");
401 
402  fhJetFFz = new TH2F("JetFFz","z = p_{T i charged}/p_{T trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,200,0.,2);
403  fhJetFFz->SetYTitle("z");
404  fhJetFFz->SetXTitle("p_{T trigger}");
405 
406  fhJetFFxi = new TH2F("JetFFxi","#xi = ln(p_{T trigger}/p_{T i charged}) vs p_{T trigger}",nptbins,ptmin,ptmax,100,0.,10.);
407  fhJetFFxi->SetYTitle("#xi");
408  fhJetFFxi->SetXTitle("p_{T trigger}");
409 
410  fhJetFFpt = new TH2F("JetFFpt","#xi = p_{T i charged}) vs p_{T trigger}",nptbins,ptmin,ptmax,200,0.,50.);
411  fhJetFFpt->SetYTitle("p_{T charged hadron}");
412  fhJetFFpt->SetXTitle("p_{T trigger}");
413 
414  fhJetNTracksInCone = new TH2F("JetNTracksInCone","N particles in cone vs p_{T trigger}",nptbins,ptmin,ptmax,5000,0, 5000);
415  fhJetNTracksInCone->SetYTitle("N tracks in jet cone");
416  fhJetNTracksInCone->SetXTitle("p_{T trigger} (GeV/c)");
417 
418  fOutCont->Add(fhJetPt) ;
419  fOutCont->Add(fhJetRatioPt) ;
420  fOutCont->Add(fhJetDeltaPhi) ;
421  fOutCont->Add(fhJetDeltaEta) ;
425  fOutCont->Add(fhJetFFz) ;
426  fOutCont->Add(fhJetFFxi) ;
427  fOutCont->Add(fhJetFFpt) ;
429 
430  //Bkg Distributions
431  fhBkgPt = new TH2F("BkgPt","p_{T bkg} vs p_{T trigger}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
432  fhBkgPt->SetYTitle("p_{T bkg}");
433  fhBkgPt->SetXTitle("p_{T trigger} (GeV/c)");
434 
435  fhBkgRatioPt = new TH2F("BkgRatioPt","p_{T bkg}/p_{T trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2);
436  fhBkgRatioPt->SetYTitle("p_{T bkg}/p_{T trigger}");
437  fhBkgRatioPt->SetXTitle("p_{T trigger} (GeV/c)");
438 
439  fhBkgDeltaPhi = new TH2F("BkgDeltaPhi","#phi_{bkg} - #phi_{trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,TMath::TwoPi());
440  fhBkgDeltaPhi->SetYTitle("#Delta #phi (rad)");
441  fhBkgDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)");
442 
443  fhBkgDeltaEta = new TH2F("BkgDeltaEta","#eta_{bkg} - #eta_{trigger} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2);
444  fhBkgDeltaEta->SetYTitle("#Delta #eta");
445  fhBkgDeltaEta->SetXTitle("p_{T trigger} (GeV/c)");
446 
447  fhBkgLeadingRatioPt = new TH2F("BkgLeadingRatioPt","p_{T bkg} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,2);
448  fhBkgLeadingRatioPt->SetYTitle("p_{T leading}/p_{T bkg}");
449  fhBkgLeadingRatioPt->SetXTitle("p_{T trigger} (GeV/c)");
450 
451  fhBkgLeadingDeltaPhi = new TH2F("BkgLeadingDeltaPhi","#phi_{bkg} - #phi_{leading} vs p_{T trigger}",nptbins,ptmin,ptmax,120,0,TMath::TwoPi());
452  fhBkgLeadingDeltaPhi->SetYTitle("#Delta #phi (rad)");
453  fhBkgLeadingDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)");
454 
455  fhBkgLeadingDeltaEta = new TH2F("BkgLeadingDeltaEta","#eta_{bkg} - #eta_{leading} vs p_{T trigger}",nptbins,ptmin,ptmax,120,-2,2);
456  fhBkgLeadingDeltaEta->SetYTitle("#Delta #eta");
457  fhBkgLeadingDeltaEta->SetXTitle("p_{T trigger} (GeV/c)");
458 
459  fhBkgFFz = new TH2F("BkgFFz","z = p_{T i charged}/p_{T trigger} vs p_{T trigger}", nptbins,ptmin,ptmax,200,0.,2);
460  fhBkgFFz->SetYTitle("z");
461  fhBkgFFz->SetXTitle("p_{T trigger}");
462 
463  fhBkgFFxi = new TH2F("BkgFFxi","#xi = ln(p_{T trigger}/p_{T i charged}) vs p_{T trigger}", nptbins,ptmin,ptmax,100,0.,10.);
464  fhBkgFFxi->SetYTitle("#xi");
465  fhBkgFFxi->SetXTitle("p_{T trigger}");
466 
467  fhBkgFFpt = new TH2F("BkgFFpt","p_{T charged hadron } vs p_{T trigger}", nptbins,ptmin,ptmax,200,0.,50.);
468  fhBkgFFpt->SetYTitle("p_{T charged} hadron");
469  fhBkgFFpt->SetXTitle("p_{T trigger}");
470 
471  fhBkgNTracksInCone = new TH2F("BkgNTracksInCone","N particles in cone vs p_{T trigger}",nptbins,ptmin,ptmax,5000,0, 5000);
472  fhBkgNTracksInCone->SetYTitle("N tracks in bkg cone");
473  fhBkgNTracksInCone->SetXTitle("p_{T trigger} (GeV/c)");
474 
475  fOutCont->Add(fhBkgPt) ;
476  fOutCont->Add(fhBkgRatioPt) ;
477  fOutCont->Add(fhBkgDeltaPhi) ;
478  fOutCont->Add(fhBkgDeltaEta) ;
482  fOutCont->Add(fhBkgFFz) ;
483  fOutCont->Add(fhBkgFFxi) ;
484  fOutCont->Add(fhBkgFFpt) ;
486 
487  }//not several cones
488  else{ //If we want to study the jet for different cones and pt
489  for(Int_t icone = 0; icone<fJetNCone; icone++){//icone
490  for(Int_t ipt = 0; ipt<fJetNPt;ipt++){ //ipt
491 
492  TString lastnamehist ="Cone"+ fJetNameCones[icone]+"Pt"+ fJetNamePtThres[ipt];
493  TString lastnametitle =", cone ="+fJetNameCones[icone]+", pt > " +fJetNamePtThres[ipt]+" GeV/c";
494 
495  //Jet Distributions
496  fhJetPts[icone][ipt] = new TH2F(Form("JetPt%s",lastnamehist.Data()),Form("p_{T jet} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
497  fhJetPts[icone][ipt]->SetYTitle("p_{T jet}");
498  fhJetPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
499 
500  fhJetRatioPts[icone][ipt] = new TH2F(Form("JetRatioPt%s",lastnamehist.Data()),Form("p_{T jet}/p_{T trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,2);
501  fhJetRatioPts[icone][ipt]->SetYTitle("p_{T jet}/p_{T trigger}");
502  fhJetRatioPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
503 
504  fhJetDeltaPhis[icone][ipt] = new TH2F(Form("JetDeltaPhi%s",lastnamehist.Data()),Form("#phi_{jet} - #phi_{trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,TMath::TwoPi());
505  fhJetDeltaPhis[icone][ipt]->SetYTitle("#Delta #phi (rad)");
506  fhJetDeltaPhis[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
507 
508  fhJetDeltaEtas[icone][ipt] = new TH2F(Form("JetDeltaEta%s",lastnamehist.Data()),Form("#eta_{jet} - #eta_{trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,-2,2);
509  fhJetDeltaEtas[icone][ipt]->SetYTitle("#Delta #eta");
510  fhJetDeltaEtas[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
511 
512  fhJetLeadingRatioPts[icone][ipt] = new TH2F(Form("JetLeadingRatioPt%s",lastnamehist.Data()),Form("p_{T jet} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,2);
513  fhJetLeadingRatioPts[icone][ipt]->SetYTitle("p_{T leading}/p_{T jet}");
514  fhJetLeadingRatioPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
515 
516  fhJetLeadingDeltaPhis[icone][ipt] = new TH2F(Form("JetLeadingDeltaPhi%s",lastnamehist.Data()),Form("#phi_{jet} - #phi_{leading} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,TMath::TwoPi());
517  fhJetLeadingDeltaPhis[icone][ipt]->SetYTitle("#Delta #phi (rad)");
518  fhJetLeadingDeltaPhis[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
519 
520  fhJetLeadingDeltaEtas[icone][ipt] = new TH2F(Form("JetLeadingDeltaEta%s",lastnamehist.Data()),Form("#eta_{jet} - #eta_{leading} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,-2,2);
521  fhJetLeadingDeltaEtas[icone][ipt]->SetYTitle("#Delta #eta");
522  fhJetLeadingDeltaEtas[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
523 
524  fhJetFFzs[icone][ipt] = new TH2F(Form("JetFFz%s",lastnamehist.Data()),"z = p_{T i charged}/p_{T trigger} vs p_{T trigger}", 120,0.,120.,200,0.,2);
525  fhJetFFzs[icone][ipt]->SetYTitle("z");
526  fhJetFFzs[icone][ipt]->SetXTitle("p_{T trigger}");
527 
528  fhJetFFxis[icone][ipt] = new TH2F(Form("JetFFxi%s",lastnamehist.Data()),"#xi = ln(p_{T trigger}/p_{T i charged}) vs p_{T trigger}", 120,0.,120.,100,0.,10.);
529  fhJetFFxis[icone][ipt]->SetYTitle("#xi");
530  fhJetFFxis[icone][ipt]->SetXTitle("p_{T trigger}");
531 
532  fhJetFFpts[icone][ipt] = new TH2F(Form("JetFFpt%s",lastnamehist.Data()),"p_{T charged hadron } in jet vs p_{T trigger}", 120,0.,120.,200,0.,50.);
533  fhJetFFpts[icone][ipt]->SetYTitle("p_{T charged hadron}");
534  fhJetFFpts[icone][ipt]->SetXTitle("p_{T trigger}");
535 
536  fhJetNTracksInCones[icone][ipt] = new TH2F(Form("JetNTracksInCone%s",lastnamehist.Data()),Form("N particles in cone vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,5000,0, 5000);
537  fhJetNTracksInCones[icone][ipt]->SetYTitle("N tracks in jet cone");
538  fhJetNTracksInCones[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
539 
540  fOutCont->Add(fhJetPts[icone][ipt]) ;
541  fOutCont->Add(fhJetRatioPts[icone][ipt]) ;
542  fOutCont->Add(fhJetDeltaPhis[icone][ipt]) ;
543  fOutCont->Add(fhJetDeltaEtas[icone][ipt]) ;
544  fOutCont->Add(fhJetLeadingRatioPts[icone][ipt]) ;
545  fOutCont->Add(fhJetLeadingDeltaPhis[icone][ipt]) ;
546  fOutCont->Add(fhJetLeadingDeltaEtas[icone][ipt]) ;
547  fOutCont->Add(fhJetFFzs[icone][ipt]) ;
548  fOutCont->Add(fhJetFFxis[icone][ipt]) ;
549  fOutCont->Add(fhJetFFpts[icone][ipt]) ;
550  fOutCont->Add(fhJetNTracksInCones[icone][ipt]) ;
551 
552  //Bkg Distributions
553  fhBkgPts[icone][ipt] = new TH2F(Form("BkgPt%s",lastnamehist.Data()),Form("p_{T bkg} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
554  fhBkgPts[icone][ipt]->SetYTitle("p_{T bkg}");
555  fhBkgPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
556 
557  fhBkgRatioPts[icone][ipt] = new TH2F(Form("BkgRatioPt%s",lastnamehist.Data()),Form("p_{T bkg}/p_{T trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,2);
558  fhBkgRatioPts[icone][ipt]->SetYTitle("p_{T bkg}/p_{T trigger}");
559  fhBkgRatioPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
560 
561  fhBkgDeltaPhis[icone][ipt] = new TH2F(Form("BkgDeltaPhi%s",lastnamehist.Data()),Form("#phi_{bkg} - #phi_{trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,TMath::TwoPi());
562  fhBkgDeltaPhis[icone][ipt]->SetYTitle("#Delta #phi (rad)");
563  fhBkgDeltaPhis[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
564 
565  fhBkgDeltaEtas[icone][ipt] = new TH2F(Form("BkgDeltaEta%s",lastnamehist.Data()),Form("#eta_{bkg} - #eta_{trigger} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,-2,2);
566  fhBkgDeltaEtas[icone][ipt]->SetYTitle("#Delta #eta");
567  fhBkgDeltaEtas[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
568 
569  fhBkgLeadingRatioPts[icone][ipt] = new TH2F(Form("BkgLeadingRatioPt%s",lastnamehist.Data()),Form("p_{T bkg} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,2);
570  fhBkgLeadingRatioPts[icone][ipt]->SetYTitle("p_{T leading}/p_{T bkg}");
571  fhBkgLeadingRatioPts[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
572 
573  fhBkgLeadingDeltaPhis[icone][ipt] = new TH2F(Form("BkgLeadingDeltaPhi%s",lastnamehist.Data()),Form("#phi_{bkg} - #phi_{leading} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,0,TMath::TwoPi());
574  fhBkgLeadingDeltaPhis[icone][ipt]->SetYTitle("#Delta #phi (rad)");
575  fhBkgLeadingDeltaPhis[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
576 
577  fhBkgLeadingDeltaEtas[icone][ipt] = new TH2F(Form("BkgLeadingDeltaEta%s",lastnamehist.Data()),Form("#eta_{bkg} - #eta_{leading} vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,120,-2,2);
578  fhBkgLeadingDeltaEtas[icone][ipt]->SetYTitle("#Delta #eta");
579  fhBkgLeadingDeltaEtas[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
580 
581  fhBkgFFzs[icone][ipt] = new TH2F(Form("BkgFFz%s",lastnamehist.Data()),"z = p_{T i charged}/p_{T trigger} vs p_{T trigger}", 120,0.,120.,200,0.,2);
582  fhBkgFFzs[icone][ipt]->SetYTitle("z");
583  fhBkgFFzs[icone][ipt]->SetXTitle("p_{T trigger}");
584 
585  fhBkgFFxis[icone][ipt] = new TH2F(Form("BkgFFxi%s",lastnamehist.Data()),"#xi = ln(p_{T trigger}/p_{T i charged}) vs p_{T trigger}", 120,0.,120.,100,0.,10.);
586  fhBkgFFxis[icone][ipt]->SetYTitle("#xi");
587  fhBkgFFxis[icone][ipt]->SetXTitle("p_{T trigger}");
588 
589  fhBkgFFpts[icone][ipt] = new TH2F(Form("BkgFFpt%s",lastnamehist.Data()),"p_{T charged hadron} in jet vs p_{T trigger}", 120,0.,120.,200,0.,50.);
590  fhBkgFFpts[icone][ipt]->SetYTitle("p_{T charged hadron}");
591  fhBkgFFpts[icone][ipt]->SetXTitle("p_{T trigger}");
592 
593  fhBkgNTracksInCones[icone][ipt] = new TH2F(Form("BkgNTracksInCone%s",lastnamehist.Data()),Form("N particles in cone vs p_{T trigger} %s",lastnametitle.Data()),nptbins,ptmin,ptmax,5000,0, 5000);
594  fhBkgNTracksInCones[icone][ipt]->SetYTitle("N tracks in bkg cone");
595  fhBkgNTracksInCones[icone][ipt]->SetXTitle("p_{T trigger} (GeV/c)");
596 
597  fOutCont->Add(fhBkgPts[icone][ipt]) ;
598  fOutCont->Add(fhBkgRatioPts[icone][ipt]) ;
599  fOutCont->Add(fhBkgDeltaPhis[icone][ipt]) ;
600  fOutCont->Add(fhBkgDeltaEtas[icone][ipt]) ;
601  fOutCont->Add(fhBkgLeadingRatioPts[icone][ipt]) ;
602  fOutCont->Add(fhBkgLeadingDeltaPhis[icone][ipt]) ;
603  fOutCont->Add(fhBkgLeadingDeltaEtas[icone][ipt]) ;
604  fOutCont->Add(fhBkgFFzs[icone][ipt]) ;
605  fOutCont->Add(fhBkgFFxis[icone][ipt]) ;
606  fOutCont->Add(fhBkgFFpts[icone][ipt]) ;
607  fOutCont->Add(fhBkgNTracksInCones[icone][ipt]) ;
608 
609  }//ipt
610  } //icone
611  }//If we want to study any cone or pt threshold
612 
613  //Keep neutral meson selection histograms if requiered
614  //Setting done in AliNeutralMesonSelection
617  if(GetNeutralMesonSelection()->AreNeutralMesonSelectionHistosKept())
618  for(Int_t i = 0; i < nmsHistos->GetEntries(); i++) fOutCont->Add(nmsHistos->At(i)) ;
619  delete nmsHistos;
620  }
621 
622  // if(GetDebug() > 2)
623  // {
624  // printf("AliAnaParticleJetLeadingConeCorrelation::GetCreateOutputObjects() - All histograms names : \n");
625  // for(Int_t i = 0 ; i< fOutCont->GetEntries(); i++)
626  // printf("Histo i %d name %s\n",i,((fOutCont->At(i))->GetName()));
627  // //cout<< (fOutCont->At(i))->GetName()<<endl;
628  // }
629 
630  return fOutCont;
631 }
632 
633 //__________________________________________________________________________________________________________
635 //__________________________________________________________________________________________________________
637 {
638  GetLeadingCharge(particle) ;
639  if(!fJetsOnlyInCTS) GetLeadingPi0(particle) ;
640 
641  Double_t ptch = fLeadingChargeMom.Pt();
642  Double_t ptpi = fLeadingPi0Mom .Pt();
643 
644  if (ptch > 0 || ptpi > 0)
645  {
646  if((ptch >= ptpi))
647  {
648  AliDebug(1,"Leading found in CTS");
649 
651 
652  AliDebug(1,Form("Found Leading: pt %2.3f, phi %2.3f deg, eta %2.3f",fLeadingMom.Pt(),fLeadingMom.Phi()*TMath::RadToDeg(),fLeadingMom.Eta())) ;
653 
654  //Put leading in AOD
655  particle->SetLeading(fLeadingChargeMom);
656  particle->SetLeadingDetector(kCTS);
657  return kTRUE;
658  }
659  else
660  {
661  AliDebug(1,"Leading found in EMCAL");
662 
664 
665  AliDebug(1,Form("Found Leading: pt %2.3f, phi %2.3f, eta %2.3f",fLeadingMom.Pt(),fLeadingMom.Phi()*TMath::RadToDeg(),fLeadingMom.Eta())) ;
666  //Put leading in AOD
667  particle->SetLeading(fLeadingPi0Mom);
668  particle->SetLeadingDetector(kEMCAL);
669  return kTRUE;
670  }
671  }
672 
673  AliDebug(1,"NO LEADING PARTICLE FOUND");
674 
675  return kFALSE;
676 }
677 
678 //_______________________________________________________________________________________________________
681 //_______________________________________________________________________________________________________
683 {
684  if(!GetCTSTracks()) return;
685 
686  Double_t ptTrig = particle->Pt();
687  Double_t phiTrig = particle->Phi();
688  Double_t rat = -100 ;
689  Double_t ptl = -100 ;
690  Double_t phil = -100 ;
691  Double_t pt = -100.;
692  Double_t phi = -100.;
693 
694  for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
695  {
696  AliVTrack* track = (AliVTrack *)(GetCTSTracks()->At(ipr)) ;
697  fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
698  pt = fTrackVector.Pt();
699  phi = fTrackVector.Phi() ;
700  if(phi < 0) phi+=TMath::TwoPi();
701  rat = pt/ptTrig ;
702 
703  //printf("AliAnaParticleJetLeadingConeCorrelation::GetLeadingCharge() - Tracks: pt %2.3f eta %2.3f phi %2.3f pt/ptTrig %2.3f \n",
704  // pt, fTrackVector.Eta(), phi,pt/ptTrig) ;
705 
706  Float_t deltaphi = TMath::Abs(phiTrig-phi);
707  if((deltaphi > fDeltaPhiMinCut) && (deltaphi < fDeltaPhiMaxCut) &&
708  (rat > fLeadingRatioMinCut) && (rat < fLeadingRatioMaxCut) && (pt > ptl))
709  {
710  phil = phi ;
711  ptl = pt ;
713  }
714  }// track loop
715 
716  if( ptl > 0 )AliDebug(1,Form("Leading in CTS: pt %2.3f eta %2.3f phi %2.3f pt/ptTrig %2.3f, |phiTrig-phi| %2.3f",
717  ptl, fLeadingChargeMom.Eta(), phil,ptl/ptTrig, TMath::Abs(phiTrig-phil))) ;
718 }
719 
720 //____________________________________________________________________________________________________
723 //____________________________________________________________________________________________________
725 {
726  if(!GetEMCALClusters()) return ;
727 
728  Double_t ptTrig = particle->Pt();
729  Double_t phiTrig = particle->Phi();
730  Double_t rat = -100 ;
731  Double_t ptl = -100 ;
732  Double_t phil = -100 ;
733  Double_t pt = -100.;
734  Double_t phi = -100.;
735 
736  //Get vertex for photon momentum calculation
737  Double_t vertex [] = {0,0,0} ; //vertex
738  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
739  {
740  GetVertex(vertex);
741  }
742 
743  //Cluster loop, select pairs with good pt, phi and fill AODs or histograms
744  for(Int_t iclus = 0;iclus < GetEMCALClusters()->GetEntriesFast() ; iclus ++ )
745  {
746  AliVCluster * calo = (AliVCluster *)(GetEMCALClusters()->At(iclus)) ;
747 
748  //Cluster selection, not charged, with photon or pi0 id and in fiducial cut
749  Int_t pdgi=0;
750  if(!SelectCluster(calo, vertex, fLeadingPhoMom1, pdgi)) continue ;
751 
752  AliDebug(1,Form("Neutral cluster: pt %2.3f, phi %2.3f",fLeadingPhoMom1.Pt(),fLeadingPhoMom1.Phi()));
753 
754  //2 gamma overlapped, found with PID
755  if(pdgi == AliCaloPID::kPi0)
756  {
757  AliDebug(1,"Neutral cluster ID as Pi0");
758 
759  pt = fLeadingPhoMom1.Pt();
760  rat = pt/ptTrig;
761  phi = fLeadingPhoMom1.Phi();
762  if(phi < 0) phi+=TMath::TwoPi();
763 
764  //Selection within angular and energy limits
765  Float_t deltaphi = TMath::Abs(phiTrig-phi);
766  if(pt > ptl && rat > fLeadingRatioMinCut && rat < fLeadingRatioMaxCut &&
767  deltaphi > fDeltaPhiMinCut && deltaphi < fDeltaPhiMaxCut )
768  {
769  phil = phi ;
770  ptl = pt ;
772  }// cuts
773  }// pdg = AliCaloPID::kPi0
774  //Make invariant mass analysis
775  else if(pdgi == AliCaloPID::kPhoton)
776  {
777  //Search the photon companion in case it comes from a Pi0 decay
778  //Apply several cuts to select the good pair
779  for(Int_t jclus = iclus+1; jclus < GetEMCALClusters()->GetEntriesFast() ; jclus++ )
780  {
781  AliVCluster * calo2 = (AliVCluster *) (GetEMCALClusters()->At(jclus)) ;
782 
783  //Cluster selection, not charged with photon or pi0 id and in fiducial cut
784  Int_t pdgj=0;
785 
786  if (!SelectCluster(calo2, vertex, fLeadingPhoMom2, pdgj)) continue ;
787 
788  if(pdgj == AliCaloPID::kPhoton )
789  {
790  pt = (fLeadingPhoMom1+fLeadingPhoMom2).Pt();
791  phi = (fLeadingPhoMom1+fLeadingPhoMom2).Phi();
792  if(phi < 0) phi+=TMath::TwoPi();
793  rat = pt/ptTrig;
794 
795  //Selection within angular and energy limits
796  Float_t deltaphi = TMath::Abs(phiTrig-phi);
797 
798  AliDebug(1,Form("Neutral Hadron Correlation: gamma pair: pt %2.2f, phi %2.2f, eta %2.2f, |phiTrig-phi| %2.3f, pt/ptTrig %2.3f, M %2.3f",
799  pt,phi,(fLeadingPhoMom1+fLeadingPhoMom2).Eta(), deltaphi, rat, (fLeadingPhoMom1+fLeadingPhoMom2).M()));
800 
801  if(pt > ptl && rat > fLeadingRatioMinCut && rat < fLeadingRatioMaxCut &&
802  deltaphi > fDeltaPhiMinCut && deltaphi < fDeltaPhiMaxCut ){
803  //Select good pair (aperture and invariant mass)
805  phil = phi ;
806  ptl = pt ;
808 
809  AliDebug(1,Form("Neutral Hadron Correlation: Selected gamma pair: pt %2.2f, phi %2.2f, eta %2.2f, M %2.3f",
811  }//pi0 selection
812  }//Pair selected as leading
813  }//if pair of gammas
814  }//2nd loop
815  }// if pdg = 22
816  }// 1st Loop
817 
818  if(fLeadingPi0Mom.Pt() > 0 )
819  AliDebug(1,Form("Leading EMCAL: pt %2.3f eta %2.3f phi %2.3f pt/Eg %2.3f",
820  fLeadingPi0Mom.Pt(), fLeadingPi0Mom.Eta(), phil, fLeadingPi0Mom.Pt()/ptTrig)) ;
821 }
822 
823 //____________________________________________________________________________
825 //____________________________________________________________________________
827 {
828  SetInputAODName("CaloTrackParticle");
829  SetAODObjArrayName("JetLeadingCone");
830  AddToHistogramsName("AnaJetLCCorr_");
831 
832  fJetsOnlyInCTS = kFALSE ;
833  fPbPb = kFALSE ;
834  fReMakeJet = kFALSE ;
835 
836  //Leading selection parameters
837  fDeltaPhiMinCut = 2.9 ;
838  fDeltaPhiMaxCut = 3.4 ;
839  fLeadingRatioMinCut = 0.1;
840  fLeadingRatioMaxCut = 1.5;
841 
842  //Jet selection parameters
843  //Fixed cut
844  fJetRatioMaxCut = 1.2 ;
845  fJetRatioMinCut = 0.3 ;
846  fJetCTSRatioMaxCut = 1.2 ;
847  fJetCTSRatioMinCut = 0.3 ;
848  fSelect = 0 ; //0, Accept all jets, 1, selection depends on energy, 2 fixed selection
849 
850  fSelectIsolated = kFALSE;
851 
852  //Cut depending on gamma energy
853  fPtTriggerSelectionCut = 10.; //For Low pt jets+BKG, another limits applied
854  //Reconstructed jet energy dependence parameters
855  //e_jet = a1+e_gamma b2.
856  //Index 0-> Pt>2 GeV r = 0.3; Index 1-> Pt>0.5 GeV r = 0.3
857  fJetE1[0] = -5.75; fJetE1[1] = -4.1;
858  fJetE2[0] = 1.005; fJetE2[1] = 1.05;
859 
860  //Reconstructed sigma of jet energy dependence parameters
861  //s_jet = a1+e_gamma b2.
862  //Index 0-> Pt>2 GeV r = 0.3; Index 1-> Pt>0.5 GeV r = 0.3
863  fJetSigma1[0] = 2.65; fJetSigma1[1] = 2.75;
864  fJetSigma2[0] = 0.0018; fJetSigma2[1] = 0.033;
865 
866  //Background mean energy and RMS
867  //Index 0-> No BKG; Index 1-> BKG > 2 GeV;
868  //Index 2-> (low pt jets)BKG > 0.5 GeV;
869  //Index > 2, same for CTS conf
870  fBkgMean[0] = 0.; fBkgMean[1] = 8.8 ; fBkgMean[2] = 69.5;
871  fBkgMean[3] = 0.; fBkgMean[4] = 6.4; fBkgMean[5] = 48.6;
872  fBkgRMS[0] = 0.; fBkgRMS[1] = 7.5; fBkgRMS[2] = 22.0;
873  fBkgRMS[3] = 0.; fBkgRMS[4] = 5.4; fBkgRMS[5] = 13.2;
874 
875  //Factor x of min/max = E -+ x * sigma. Obtained after selecting the
876  //limits for monoenergetic jets.
877  //Index 0-> No BKG; Index 1-> BKG > 2 GeV;
878  //Index 2-> (low pt jets) BKG > 0.5 GeV;
879  //Index > 2, same for CTS conf
880 
881  fJetXMin1[0] =-0.69 ; fJetXMin1[1] = 0.39 ; fJetXMin1[2] =-0.88 ;
882  fJetXMin1[3] =-2.0 ; fJetXMin1[4] =-0.442 ; fJetXMin1[5] =-1.1 ;
883  fJetXMin2[0] = 0.066; fJetXMin2[1] = 0.038; fJetXMin2[2] = 0.034;
884  fJetXMin2[3] = 0.25 ; fJetXMin2[4] = 0.113; fJetXMin2[5] = 0.077 ;
885  fJetXMax1[0] =-3.8 ; fJetXMax1[1] =-0.76 ; fJetXMax1[2] =-3.6 ;
886  fJetXMax1[3] =-2.7 ; fJetXMax1[4] =-1.21 ; fJetXMax1[5] =-3.7 ;
887  fJetXMax2[0] =-0.012; fJetXMax2[1] =-0.022; fJetXMax2[2] = 0.016;
888  fJetXMax2[3] =-0.024; fJetXMax2[4] =-0.008; fJetXMax2[5] = 0.027;
889 
890 
891  //Different cones and pt thresholds to construct the jet
892 
893  fJetCone = 0.3 ;
894  fJetPtThreshold = 0.5 ;
895  fJetPtThresPbPb = 2. ;
896  fJetNCone = 4 ;
897  fJetNPt = 4 ;
898  fJetCones[0] = 0.2 ; fJetNameCones[0] = "02" ;
899  fJetCones[1] = 0.3 ; fJetNameCones[1] = "03" ;
900  fJetCones[2] = 0.4 ; fJetNameCones[2] = "04" ;
901  fJetCones[2] = 0.5 ; fJetNameCones[2] = "05" ;
902 
903  fJetPtThres[0] = 0.0 ; fJetNamePtThres[0] = "00" ;
904  fJetPtThres[1] = 0.5 ; fJetNamePtThres[1] = "05" ;
905  fJetPtThres[2] = 1.0 ; fJetNamePtThres[2] = "10" ;
906  fJetPtThres[3] = 2.0 ; fJetNamePtThres[3] = "20" ;
907 }
908 
909 //__________________________________________________________________________________________________
913 //__________________________________________________________________________________________________
915 {
916  if(ptjet == 0) return kFALSE;
917 
918  Double_t rat = ptTrig / ptjet ;
919 
920  //###############################################################
921  if(fSelect == 0)
922  return kTRUE; //Accept all jets, no restriction
923  //###############################################################
924  else if(fSelect == 1)
925  {
926  //Check if the energy of the reconstructed jet is within an energy window
927  //WARNING: to be rechecked, don't remember what all the steps mean
928  Double_t par[6];
929  Double_t xmax[2];
930  Double_t xmin[2];
931 
932  Int_t iCTS = 0;
933  if(fJetsOnlyInCTS)
934  iCTS = 3 ;
935 
936  if(!fPbPb){
937  //Phythia alone, jets with pt_th > 0.2, r = 0.3
938  par[0] = fJetE1[0]; par[1] = fJetE2[0];
939  //Energy of the jet peak
940  //e_jet = fJetE1[0]+fJetE2[0]*e_gamma, simulation fit
941  par[2] = fJetSigma1[0]; par[3] = fJetSigma2[0];
942  //Sigma of the jet peak
943  //sigma_jet = fJetSigma1[0]+fJetSigma2[0]*e_gamma, simulation fit
944  par[4] = fBkgMean[0 + iCTS]; par[5] = fBkgRMS[0 + iCTS];
945  //Parameters reserved for PbPb bkg.
946  xmax[0] = fJetXMax1[0 + iCTS]; xmax[1] = fJetXMax2[0 + iCTS];
947  xmin[0] = fJetXMin1[0 + iCTS]; xmin[1] = fJetXMin2[0 + iCTS];
948  //Factor that multiplies sigma to obtain the best limits,
949  //by observation, of mono jet ratios (ptjet/ptTrig)
950  //X_jet = fJetX1[0]+fJetX2[0]*e_gamma
951 
952  }
953  else
954  {
955  if(ptTrig > fPtTriggerSelectionCut)
956  {
957  //Phythia +PbPb with pt_th > 2 GeV/c, r = 0.3
958  par[0] = fJetE1[0]; par[1] = fJetE2[0];
959  //Energy of the jet peak, same as in pp
960  //e_jet = fJetE1[0]+fJetE2[0]*e_gamma, simulation fit
961  par[2] = fJetSigma1[0]; par[3] = fJetSigma2[0];
962  //Sigma of the jet peak, same as in pp
963  //sigma_jet = fJetSigma1[0]+fJetSigma2[0]*e_gamma, simulation fit
964  par[4] = fBkgMean[1 + iCTS]; par[5] = fBkgRMS[1 + iCTS];
965  //Mean value and RMS of PbPb Bkg
966  xmax[0] = fJetXMax1[1 + iCTS]; xmax[1] = fJetXMax2[1 + iCTS];
967  xmin[0] = fJetXMin1[1 + iCTS]; xmin[1] = fJetXMin2[1 + iCTS];
968  //Factor that multiplies sigma to obtain the best limits,
969  //by observation, of mono jet ratios (ptjet/ptTrig) mixed with PbPb Bkg,
970  //pt_th > 2 GeV, r = 0.3
971  //X_jet = fJetX1[0]+fJetX2[0]*e_gamma
972  }
973  else
974  {
975  //Phythia + PbPb with pt_th > 0.5 GeV/c, r = 0.3
976  par[0] = fJetE1[1]; par[1] = fJetE2[1];
977  //Energy of the jet peak, pt_th > 2 GeV/c, r = 0.3
978  //e_jet = fJetE1[0]+fJetE2[0]*e_gamma, simulation fit
979  par[2] = fJetSigma1[1]; par[3] = fJetSigma2[1];
980  //Sigma of the jet peak, pt_th > 2 GeV/c, r = 0.3
981  //sigma_jet = fJetSigma1[0]+fJetSigma2[0]*e_gamma, simulation fit
982  par[4] = fBkgMean[2 + iCTS]; par[5] = fBkgRMS[2 + iCTS];
983  //Mean value and RMS of PbPb Bkg in a 0.3 cone, pt > 2 GeV.
984  xmax[0] = fJetXMax1[2 + iCTS]; xmax[1] = fJetXMax2[2 + iCTS];
985  xmin[0] = fJetXMin1[2 + iCTS]; xmin[1] = fJetXMin2[2 + iCTS];
986  //Factor that multiplies sigma to obtain the best limits,
987  //by observation, of mono jet ratios (ptjet/ptTrig) mixed with PbPb Bkg,
988  //pt_th > 2 GeV, r = 0.3
989  //X_jet = fJetX1[0]+fJetX2[0]*e_gamma
990  }//If low pt jet in bkg
991  }//if Bkg
992 
993  //Calculate minimum and maximum limits of the jet ratio.
994  Double_t min = CalculateJetRatioLimit(ptTrig, par, xmin);
995  Double_t max = CalculateJetRatioLimit(ptTrig, par, xmax);
996 
997  AliDebug(3,Form("Jet selection? : Limits min %2.3f, max %2.3f, pt_jet %2.3f, pt_gamma %2.3f, pt_jet / pt_gamma %2.3f",min,max,ptjet,ptTrig,rat));
998 
999  if(( min < rat ) && ( max > ptjet/rat))
1000  return kTRUE;
1001  else
1002  return kFALSE;
1003  }//fSelect = 1
1004  //###############################################################
1005  else if(fSelect == 2)
1006  {
1007  //Simple selection
1008  if(!fJetsOnlyInCTS)
1009  {
1010  if((rat < fJetRatioMaxCut) && (rat > fJetRatioMinCut )) return kTRUE;
1011  }
1012  else
1013  {
1014  if((rat < fJetCTSRatioMaxCut) && (rat > fJetCTSRatioMinCut )) return kTRUE;
1015  }
1016  }// fSelect = 2
1017  //###############################################################
1018  else
1019  {
1020  AliWarning(")Jet selection option larger than 2, DON'T SELECT JETS");
1021  return kFALSE ;
1022  }
1023 
1024  return kFALSE;
1025 }
1026 
1027 //___________________________________________________________________
1030 //___________________________________________________________________
1032  Double_t etal, Double_t phil) const
1033 {
1034  if(phi < 0) phi+=TMath::TwoPi();
1035  if(phil < 0) phil+=TMath::TwoPi();
1036  Double_t rad = 10000 + fJetCone;
1037 
1038  if(TMath::Abs(phi-phil) <= (TMath::TwoPi() - fJetCone))
1039  rad = TMath::Sqrt(TMath::Power(eta-etal,2)+TMath::Power(phi-phil,2));
1040  else{
1041  if(phi-phil > TMath::TwoPi() - fJetCone)
1042  rad = TMath::Sqrt(TMath::Power(eta-etal,2)+TMath::Power((phi-TMath::TwoPi())-phil,2));
1043  if(phi-phil < -(TMath::TwoPi() - fJetCone))
1044  rad = TMath::Sqrt(TMath::Power(eta-etal,2)+TMath::Power((phi+TMath::TwoPi())-phil,2));
1045  }
1046 
1047  if(rad < fJetCone) return kTRUE ;
1048  else return kFALSE ;
1049 }
1050 
1051 //__________________________________________________________________
1052 // Particle-Jet/Hadron Correlation Analysis, fill AODs.
1053 //__________________________________________________________________
1055 {
1056  if(!GetInputAODBranch())
1057  {
1058  AliFatal(Form("No input particles in AOD with name branch < %s >",GetInputAODName().Data()));
1059  return;// coverity
1060  }
1061 
1062  if(strcmp(GetInputAODBranch()->GetClass()->GetName(), "AliCaloTrackParticleCorrelation"))
1063  AliFatal(Form("Wrong type of AOD object, change AOD class name in input AOD: It should be <AliCaloTrackParticleCorrelation> and not <%s>",
1064  GetInputAODBranch()->GetClass()->GetName()));
1065 
1066 
1067  AliDebug(1,"Begin jet leading cone correlation analysis, fill AODs");
1068  AliDebug(1,Form("In particle branch aod entries %d", GetInputAODBranch()->GetEntriesFast()));
1069  AliDebug(1,Form("In CTS aod entries %d", GetCTSTracks() ->GetEntriesFast()));
1070  AliDebug(1,Form("In EMCAL aod entries %d", GetEMCALClusters() ->GetEntriesFast()));
1071 
1072  //Loop on stored AOD particles, trigger
1073  Int_t naod = GetInputAODBranch()->GetEntriesFast();
1074  for(Int_t iaod = 0; iaod < naod ; iaod++)
1075  {
1077 
1078  // printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillAOD() - Trigger : pt %3.2f, phi %2.2f, eta %2.2f\n",particle->Pt(), particle->Phi(), particle->Eta());
1079 
1080  //Search leading particles in CTS and EMCAL
1081  if(GetLeadingParticle(particle))
1082  {
1083  //Construct the jet around the leading, Fill AOD jet particle list, select jet
1084  //and fill AOD with jet and background
1085  MakeAODJet(particle);
1086 
1087  }//Leading found
1088  }//AOD trigger particle loop
1089 
1090  AliDebug(1,"End of jet leading cone analysis, fill AODs");
1091 }
1092 
1093 //_________________________________________________________________________
1095 //_________________________________________________________________________
1097 {
1098  if(!GetInputAODBranch())
1099  {
1100  printf("AliAnaParticleJetLeadingConeCorrelation::MakeAnalysisFillHistograms() - No input particles in AOD with name branch < %s >",
1101  GetInputAODName().Data());
1102  return;
1103  }
1104 
1105  AliDebug(1,"Begin jet leading cone correlation analysis, fill histograms");
1106  AliDebug(1,Form("In particle branch aod entries %d", GetInputAODBranch()->GetEntriesFast()));
1107  AliDebug(1,Form("In CTS aod entries %d", GetCTSTracks() ->GetEntriesFast()));
1108  AliDebug(1,Form("In EMCAL aod entries %d", GetEMCALClusters() ->GetEntriesFast()));
1109 
1110  //Loop on stored AOD particles, trigger
1111  Int_t naod = GetInputAODBranch()->GetEntriesFast();
1112  for(Int_t iaod = 0; iaod < naod ; iaod++)
1113  {
1115 
1116  if(OnlyIsolated() && !particle->IsIsolated()) continue;
1117 
1118  Double_t pt = particle->Pt();
1119  Double_t phi = particle->Phi();
1120  Double_t eta = particle->Eta();
1121 
1122  //Get leading particle, fill histograms
1123  fLeadingMom = particle->GetLeading();
1124  Int_t det = particle->GetLeadingDetector();
1125 
1126  if(det > 0 && fLeadingMom.Pt() > 0)
1127  {
1128  Double_t ptL = fLeadingMom.Pt();
1129  Double_t phiL = fLeadingMom.Phi();
1130  if(phiL < 0 ) phiL+=TMath::TwoPi();
1131  Double_t etaL = fLeadingMom.Eta();
1132 
1133  AliDebug(1,Form("Trigger with pt %3.2f, phi %2.2f, eta %2.2f", pt, phi, eta));
1134 
1135  if(det == kCTS)
1136  {
1137  fhChargedLeadingPt ->Fill(pt, ptL , GetEventWeight());
1138  fhChargedLeadingPhi ->Fill(pt, phiL , GetEventWeight());
1139  fhChargedLeadingEta ->Fill(pt, etaL , GetEventWeight());
1140  fhChargedLeadingDeltaPt ->Fill(pt, pt-ptL , GetEventWeight());
1141  fhChargedLeadingDeltaPhi->Fill(pt, TMath::Abs(phi-phiL), GetEventWeight());
1142  fhChargedLeadingDeltaEta->Fill(pt, eta-etaL, GetEventWeight());
1143  fhChargedLeadingRatioPt ->Fill(pt, ptL/pt , GetEventWeight());
1144  fhChargedLeadingXi ->Fill(pt, TMath::Log(pt/ptL), GetEventWeight());
1145  if(pt > 30) fhChargedLeadingDeltaPhiRatioPt30->Fill(TMath::Abs(phi-phiL), ptL/pt, GetEventWeight());
1146  if(pt > 50) fhChargedLeadingDeltaPhiRatioPt50->Fill(TMath::Abs(phi-phiL), ptL/pt, GetEventWeight());
1147  }
1148  else if(det == kEMCAL)
1149  {
1150  fhNeutralLeadingPt ->Fill(pt, ptL , GetEventWeight());
1151  fhNeutralLeadingPhi ->Fill(pt, phiL , GetEventWeight());
1152  fhNeutralLeadingEta ->Fill(pt, etaL , GetEventWeight());
1153  fhNeutralLeadingDeltaPt ->Fill(pt, pt-ptL, GetEventWeight());
1154  fhNeutralLeadingDeltaPhi->Fill(pt, TMath::Abs(phi-phiL), GetEventWeight());
1155  fhNeutralLeadingDeltaEta->Fill(pt, eta-etaL, GetEventWeight());
1156  fhNeutralLeadingRatioPt ->Fill(pt, ptL/pt , GetEventWeight());
1157  fhNeutralLeadingXi ->Fill(pt, TMath::Log(pt/ptL), GetEventWeight());
1158  if(pt > 30) fhNeutralLeadingDeltaPhiRatioPt30->Fill(TMath::Abs(phi-phiL), ptL/pt, GetEventWeight());
1159  if(pt > 50) fhNeutralLeadingDeltaPhiRatioPt50->Fill(TMath::Abs(phi-phiL), ptL/pt, GetEventWeight());
1160  }
1161 
1162  // Fill Jet histograms
1163 
1165  {//just fill histograms
1166  if(!fReMakeJet)
1167  {
1168  fJetMom=particle->GetCorrelatedJet();
1169  fBkgMom=particle->GetCorrelatedBackground();
1170  }
1171  else MakeJetFromAOD(particle);
1172 
1173  if(fJetMom.Pt() > 0)
1174  {//Jet was found
1175  FillJetHistos(particle, fJetMom,"Jet","");
1176  FillJetHistos(particle, fBkgMom,"Bkg","");
1177  }
1178  }
1179  else if(fSeveralConeAndPtCuts)
1180  {
1181  for(Int_t icone = 0; icone<fJetNCone; icone++)
1182  {
1183  fJetCone=fJetCones[icone];
1184  for(Int_t ipt = 0; ipt<fJetNPt;ipt++)
1185  {
1186  TString lastname ="Cone"+ fJetNameCones[icone]+"Pt"+ fJetNamePtThres[ipt];
1188 
1189  MakeJetFromAOD(particle);
1190 
1191  if(fJetMom.Pt() > 0)
1192  {//Jet was found
1193  FillJetHistos(particle, fJetMom,"Jet",lastname);
1194  FillJetHistos(particle, fBkgMom,"Bkg",lastname);
1195  }
1196  }//icone
1197  }//ipt
1198  }//fSeveralConeAndPtCuts
1199  }//Leading
1200  }//AOD trigger particle loop
1201 
1202  AliDebug(1,"End of jet leading cone analysis, fill histograms");
1203 }
1204 
1205 //_______________________________________________________________________________________________
1209 //_______________________________________________________________________________________________
1211 {
1212  Double_t ptTrig = particle->Pt();
1213  Double_t phiTrig = particle->Phi();
1214  Double_t phil = fLeadingMom.Phi();
1215  if(phil<0) phil+=TMath::TwoPi();
1216  Double_t etal = fLeadingMom.Eta();
1217 
1218  // Different pt cut for jet particles in different collisions systems
1219  Float_t ptcut = fJetPtThreshold;
1221 
1222  // Add charged particles to jet if they are in cone around the leading particle
1223  if(!GetCTSTracks())
1224  {
1225  AliFatal("Cannot construct jets without tracks, STOP analysis");
1226  return;
1227  }
1228 
1229  // Fill jet with tracks
1230  // Initialize reference arrays that will contain jet and background tracks
1231  TObjArray * reftracks = new TObjArray;
1232  TObjArray * reftracksbkg = new TObjArray;
1233 
1234  for(Int_t ipr = 0;ipr < (GetCTSTracks())->GetEntriesFast() ; ipr ++ ){
1235  AliVTrack* track = (AliVTrack *)((GetCTSTracks())->At(ipr)) ;
1236  fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
1237 
1238  //Particles in jet
1239  if(IsParticleInJetCone(fTrackVector.Eta(), fTrackVector.Phi(), etal, phil)){
1240 
1241  reftracks->Add(track);
1242 
1243  if(fTrackVector.Pt() > ptcut )
1244  {
1245  fJetConstMom.SetVect(fTrackVector);
1247  }
1248  }
1249 
1250  // Background around (phi_gamma-pi, eta_leading)
1251  else if(IsParticleInJetCone(fTrackVector.Eta(),fTrackVector.Phi(),etal, phiTrig)) {
1252 
1253  reftracksbkg->Add(track);
1254 
1255  if(fTrackVector.Pt() > ptcut ){
1256  fJetConstMom.SetVect(fTrackVector);
1258  }
1259  }
1260  }// Track loop
1261 
1262  // Add referenced tracks to AOD
1263  if(reftracks->GetEntriesFast() > 0 )
1264  {
1265  reftracks->SetName(Form("%sTracks",GetAODObjArrayName().Data()));
1266  particle->AddObjArray(reftracks);
1267  }
1268  else AliDebug(2,"No tracks in jet cone");
1269 
1270  if(reftracksbkg->GetEntriesFast() > 0 )
1271  {
1272  reftracksbkg->SetName(Form("%sTracksBkg",GetAODObjArrayName().Data()));
1273  particle->AddObjArray(reftracksbkg);
1274  }
1275  else AliDebug(1,"No background tracks in jet cone");
1276 
1277  // Add neutral particles to jet
1278  // Initialize reference arrays that will contain jet and background tracks
1279  TObjArray * refclusters = new TObjArray;
1280  TObjArray * refclustersbkg = new TObjArray;
1282  {
1283  // Get vertex for photon momentum calculation
1284  Double_t vertex[] = {0,0,0} ; //vertex
1285  if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC)
1286  {
1287  GetReader()->GetVertex(vertex);
1288  //if(GetReader()->GetSecondInputAODTree()) GetReader()->GetSecondInputAODVertex(vertex2);
1289  }
1290 
1291  for(Int_t iclus = 0;iclus < (GetEMCALClusters())->GetEntriesFast() ; iclus ++ )
1292  {
1293  AliVCluster * calo = (AliVCluster *) (GetEMCALClusters()->At(iclus)) ;
1294 
1295  // Cluster selection, not charged
1296  if(IsTrackMatched(calo,GetReader()->GetInputEvent())) continue ;
1297 
1298  // Get Momentum vector,
1299  calo->GetMomentum(fJetConstMom,vertex) ;//Assume that come from vertex in straight line
1300 
1301  // Particles in jet
1302  if(IsParticleInJetCone(fJetConstMom.Eta(),fJetConstMom.Phi(), etal, phil))
1303  {
1304  refclusters->Add(calo);
1305 
1306  if(fJetConstMom.Pt() > ptcut ) fJetMom+=fJetConstMom;
1307  }
1308  //Background around (phi_gamma-pi, eta_leading)
1309  else if(IsParticleInJetCone(fJetConstMom.Eta(),fJetConstMom.Phi(),etal, phiTrig))
1310  {
1311  refclustersbkg->Add(calo);
1312 
1313  if(fJetConstMom.Pt() > ptcut ) fBkgMom+=fJetConstMom;
1314  }
1315  }//cluster loop
1316  }//jets with neutral particles
1317 
1318  //Add referenced clusters to AOD
1319  if(refclusters->GetEntriesFast() > 0 )
1320  {
1321  refclusters->SetName(Form("%sClusters",GetAODObjArrayName().Data()));
1322  particle->AddObjArray(refclusters);
1323  }
1324  else AliDebug(2,"No clusters in jet cone");
1325 
1326  if(refclustersbkg->GetEntriesFast() > 0 )
1327  {
1328  refclustersbkg->SetName(Form("%sClustersBkg",GetAODObjArrayName().Data()));
1329  particle->AddObjArray(refclustersbkg);
1330  }
1331  else AliDebug(1,"No background clusters in jet cone");
1332 
1333  // If there is any jet found, select after some criteria and
1334  // and fill AOD with corresponding TLorentzVector kinematics
1335  if(IsJetSelected(particle->Pt(), fJetMom.Pt()))
1336  {
1337  particle->SetCorrelatedJet(fJetMom);
1338  particle->SetCorrelatedBackground(fBkgMom);
1339  AliDebug(1,Form("Found jet: Trigger pt %2.3f, Jet pt %2.3f, Bkg pt %2.3f",ptTrig,fJetMom.Pt(),fBkgMom.Pt()));
1340  }
1341 }
1342 
1343 //______________________________________________________________________________________________________
1347 //______________________________________________________________________________________________________
1349 {
1350  Double_t ptTrig = particle->Pt();
1351  Double_t phiTrig = particle->Phi();
1352  Double_t etal = fLeadingMom.Eta();
1353  Double_t phil = fLeadingMom.Phi();
1354  if(phil < 0) phil+=TMath::TwoPi();
1355 
1356  TObjArray * refclusters = particle->GetObjArray(Form("Clusters%s" ,GetAODObjArrayName().Data()));
1357  TObjArray * reftracks = particle->GetObjArray(Form("Tracks%s" ,GetAODObjArrayName().Data()));
1358  TObjArray * refclustersbkg = particle->GetObjArray(Form("ClustersBkg%s",GetAODObjArrayName().Data()));
1359  TObjArray * reftracksbkg = particle->GetObjArray(Form("TracksBkg%s" ,GetAODObjArrayName().Data()));
1360 
1361  //Different pt cut for jet particles in different collisions systems
1362  Float_t ptcut = fJetPtThreshold;
1364 
1365  //Fill jet with tracks
1366  //Particles in jet
1367  if(reftracks)
1368  {
1369  for(Int_t ipr = 0;ipr < reftracks->GetEntriesFast() ; ipr ++ )
1370  {
1371  AliVTrack* track = (AliVTrack *) reftracks->At(ipr) ;
1372  fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
1373  Float_t phi = fTrackVector.Phi();
1374  if(phi < 0) phi+=TMath::TwoPi();
1375  if(fTrackVector.Pt() > ptcut && IsParticleInJetCone(fTrackVector.Eta(), phi, etal, phil) )
1376  {
1377  fJetConstMom.SetVect(fTrackVector);
1379  }
1380  }//jet Track loop
1381  }
1382 
1383  // Particles in background
1384  if(reftracksbkg){
1385  for(Int_t ipr = 0;ipr < reftracksbkg->GetEntriesFast() ; ipr ++ )
1386  {
1387  AliVTrack* track = (AliVTrack *) reftracksbkg->At(ipr) ;
1388  fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
1389  if(fTrackVector.Pt() > ptcut && IsParticleInJetCone(fTrackVector.Eta(),fTrackVector.Phi(),etal, phiTrig) )
1390  {
1391  fJetConstMom.SetVect(fTrackVector);
1393  }
1394  }//background Track loop
1395  }
1396 
1397  // Add neutral particles to jet
1398  if(!fJetsOnlyInCTS && refclusters)
1399  {
1400  // Get vertex for photon momentum calculation
1401  Double_t vertex[] = {0,0,0} ; //vertex
1402  if(GetReader()->GetDataType()!= AliCaloTrackReader::kMC)
1403  {
1404  GetReader()->GetVertex(vertex);
1405  }
1406 
1407  // Loop on jet particles
1408  if(refclusters){
1409  for(Int_t iclus = 0;iclus < refclusters->GetEntriesFast() ; iclus ++ )
1410  {
1411  AliVCluster * calo = (AliVCluster *) refclusters->At(iclus) ;
1412 
1413  calo->GetMomentum(fJetConstMom,vertex) ;//Assume that come from vertex in straight line
1414 
1415  if(fJetConstMom.Pt() > ptcut && IsParticleInJetCone(fJetConstMom.Eta(),fJetConstMom.Phi(), etal, phil)) fJetMom+=fJetConstMom;
1416  }//jet cluster loop
1417  }
1418 
1419  // Loop on background particles
1420  if(refclustersbkg)
1421  {
1422  for(Int_t iclus = 0;iclus < refclustersbkg->GetEntriesFast() ; iclus ++ )
1423  {
1424  AliVCluster * calo = (AliVCluster *) refclustersbkg->At(iclus) ;
1425 
1426  calo->GetMomentum(fJetConstMom,vertex) ;//Assume that come from vertex in straight line
1427 
1428  if( fJetConstMom.Pt() > ptcut && IsParticleInJetCone(fJetConstMom.Eta(),fJetConstMom.Phi(),etal, phiTrig)) fBkgMom+=fJetConstMom;
1429  }// background cluster loop
1430  }
1431  }// clusters in jet
1432 
1433  // If there is any jet found, leave jet and bkg as they are,
1434  // if not set them to 0.
1435  if(!IsJetSelected(particle->Pt(), fJetMom.Pt()))
1436  {
1437  fJetMom.SetPxPyPzE(0.,0.,0.,0.);
1438  fBkgMom.SetPxPyPzE(0.,0.,0.,0.);
1439  }
1440  else AliDebug(1,Form("Found jet: Trigger pt %2.3f, Jet pt %2.3f, Bkg pt %2.3f",ptTrig,fJetMom.Pt(),fBkgMom.Pt()));
1441 }
1442 
1443 //__________________________________________________________________
1444 // Print some relevant parameters set for the analysis.
1445 //__________________________________________________________________
1447 {
1448  if(! opt)
1449  return;
1450 
1451  printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
1453 
1454  if(fJetsOnlyInCTS)printf("Jets reconstructed in CTS \n");
1455  else printf("Jets reconstructed in CTS+EMCAL \n");
1456 
1457  if(fPbPb) printf("PbPb events, pT cut in jet cone energy reconstruction %2.1f \n", fJetPtThreshold);
1458  else printf("pp events, pT cut in jet cone energy reconstruction %2.1f \n", fJetPtThresPbPb);
1459 
1460  printf("If pT of trigger < %2.3f, select jets as in pp? \n", fPtTriggerSelectionCut);
1461 
1462  printf("Phi gamma-Leading < %3.2f\n", fDeltaPhiMaxCut) ;
1463  printf("Phi gamma-Leading > %3.2f\n", fDeltaPhiMinCut) ;
1464  printf("pT Leading / pT Trigger < %3.2f\n", fLeadingRatioMaxCut) ;
1465  printf("pT Leading / pT Trigger > %3.2f\n", fLeadingRatioMinCut) ;
1466 
1467  if(fSelect == 2){
1468  printf("pT Jet / pT Gamma < %3.2f\n", fJetRatioMaxCut) ;
1469  printf("pT Jet / pT Gamma > %3.2f\n", fJetRatioMinCut) ;
1470  printf("pT Jet (Only CTS)/ pT Trigger < %3.2f\n", fJetCTSRatioMaxCut) ;
1471  printf("pT Jet (Only CTS)/ pT Trigger > %3.2f\n", fJetCTSRatioMinCut) ;
1472  }
1473  else if(fSelect == 0)
1474  printf("Accept all reconstructed jets \n") ;
1475  else if(fSelect == 1)
1476  printf("Accept jets depending on trigger energy \n") ;
1477  else
1478  printf("Wrong jet selection option: %d \n", fSelect) ;
1479 
1480  printf("Isolated Trigger? %d\n", fSelectIsolated) ;
1481 }
1482 
Float_t GetHistoPtMax() const
TH2F * fhBkgFFz
! Accepted reconstructed background fragmentation function, z=ptjet/pttrig
Double_t fJetXMax2[6]
X Factor to set jet max limit for PbPb.
Double_t fJetPtThres[5]
Jet pT threshold under study(fSeveralConeAndPtCuts)
virtual Double_t Eta() const
Double_t fJetSigma2[2]
Rec. sigma of jet energy parameters.
Int_t fJetNCone
Number of jet cones sizes, maximum 5.
Double_t fJetPtThreshold
Jet pT threshold under study(!fSeveralConeAndPtCuts)
virtual Double_t Pt() const
Float_t GetHistoPtMin() const
virtual TObjArray * GetCTSTracks() const
void MakeAODJet(AliCaloTrackParticleCorrelation *particle)
double Double_t
Definition: External.C:58
TH2F * fhChargedLeadingDeltaPhiRatioPt30
! Difference of charged hadron and trigger phi as function of pT leading / trigger pT...
virtual void AddToHistogramsName(TString add)
Definition: External.C:236
Double_t fJetXMin2[6]
X Factor to set jet min limit for PbPb.
Bool_t GetLeadingParticle(AliCaloTrackParticleCorrelation *particle)
Search Charged or Neutral leading particle, select the highest one and fill AOD.
TH2F * fhNeutralLeadingRatioPt
! Ratio of Pt leading neutral and trigger
Double_t fPtTriggerSelectionCut
Jet pt to change to low pt jets analysis.
Double_t fLeadingRatioMinCut
Leading/gamma Ratio cut minimum.
virtual void GetVertex(Double_t vertex[3]) const
TH2F * fhJetLeadingRatioPts[5][5]
! Ratio of pt leading and pt jet
TH2F * fhBkgFFzs[5][5]
! Accepted reconstructed background fragmentation function, z=ptjet/pttrig
Double_t fJetXMin1[6]
X Factor to set jet min limit for pp.
TH2F * fhBkgFFxis[5][5]
! Accepted reconstructed background fragmentation function, xsi = ln(pttrig/ptjet) ...
Double_t fLeadingRatioMaxCut
Leading /gamma Ratio cut maximum.
virtual void SetInputAODName(TString name)
TH2F * fhChargedLeadingPt
! Pt(Pt trigger) distribution of charged hadrons
virtual void AddObjArray(TObjArray *refarray)
TLorentzVector fLeadingPhoMom2
! leading particle momentum
TH2F * fhNeutralLeadingPhi
! Phi(Pt trigger) distribution of neutral hadrons
virtual Bool_t IsTrackMatched(AliVCluster *cluster, AliVEvent *event)
void MakeAnalysisFillHistograms()
Particle-Jet/Hadron Correlation Analysis, fill histograms.
TH2F * fhBkgNTracksInCones[5][5]
! Background multiplicity in cone
Double_t fJetSigma1[2]
Rec. sigma of jet energy parameters.
virtual AliNeutralMesonSelection * GetNeutralMesonSelection()
Int_t GetHistoPhiBins() const
Bool_t fReMakeJet
Re-make the jet reconstruction from AODParticleCorrelation input.
TH2F * fhBkgPt
! Leading pt bakground vs pt trigger
virtual void SetLeading(TLorentzVector lead)
virtual Bool_t IsIsolated() const
Double_t fDeltaPhiMinCut
Maximum Delta Phi Gamma-Leading.
TH2F * fhJetFFpts[5][5]
! Jet particle pt distribution in cone
Double_t fJetCTSRatioMaxCut
Jet(CTS) /gamma Ratio cut maximum.
TH2F * fhBkgLeadingRatioPts[5][5]
! Ratio of pt leading and pt background
virtual TObjArray * GetObjArray(TString refname) const
virtual void GetVertex(Double_t v[3]) const
TH2F * fhNeutralLeadingDeltaPhiRatioPt30
! Difference of neutral hadron and trigger phi as function of pT leading / trigger pT...
TH2F * fhNeutralLeadingDeltaPt
! Difference of neutral hadron and trigger pT as function of trigger pT
Float_t GetHistoPhiMin() const
TLorentzVector fLeadingChargeMom
! leading particle momentum
TH2F * fhNeutralLeadingXi
! Ln (pt leading neutral / pt trigger)
TH2F * fhBkgNTracksInCone
! Background multiplicity in cone
TH2F * fhChargedLeadingEta
! Eta(Pt trigger) distribution of charged hadrons
void GetLeadingCharge(AliCaloTrackParticleCorrelation *particle)
TH2F * fhNeutralLeadingDeltaEta
! Difference of charged particle and trigger eta as function of trigger pT
void InitParameters()
Initialize the parameters of the analysis.
virtual TString GetAODObjArrayName() const
TH2F * fhBkgLeadingRatioPt
! Ratio of pt leading and pt background
Daughter of AliCaloTrackParticle that includes correlation part.
const Double_t etamin
TH2F * fhNeutralLeadingDeltaPhi
! Difference of neutral hadron and trigger phi as function of trigger pT
TH2F * fhBkgPts[5][5]
! Leading pt bakground vs pt trigger
Base class for CaloTrackCorr analysis algorithms.
TH2F * fhJetFFpt
! Jet particle pt distribution in cone
Bool_t IsJetSelected(Double_t ptTrig, Double_t ptjet) const
TH2F * fhJetFFz
! Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
Int_t fJetNPt
Number of jet particle pT threshold, maximum 5.
TH2F * fhJetLeadingRatioPt
! Ratio of pt leading and pt jet
AliAnaParticleJetLeadingConeCorrelation()
Default constructor. Initialize parameters.
Double_t fJetCone
Jet cone sizes under study (!fSeveralConeAndPtCuts)
void MakeJetFromAOD(AliCaloTrackParticleCorrelation *particle)
int Int_t
Definition: External.C:63
TH2F * fhChargedLeadingPhi
! Phi(Pt trigger) distribution of charged hadrons
virtual TClonesArray * GetInputAODBranch() const
Bool_t SelectCluster(AliVCluster *calo, Double_t *vertex, TLorentzVector &mom, Int_t &pdg)
virtual AliHistogramRanges * GetHistogramRanges()
TH2F * fhNeutralLeadingPt
! Pt(Pt trigger) distribution of neutral hadrons
float Float_t
Definition: External.C:68
const Double_t ptmax
Bool_t fSelectIsolated
Select only trigger particles isolated.
void FillJetHistos(AliCaloTrackParticleCorrelation *particle, const TLorentzVector jet, const TString &type, const TString &lastname)
Fill jet and background histograms.
Double_t fJetRatioMaxCut
Jet(EMCAL+CTS)/gamma Ratio cut maximum.
TH2F * fhChargedLeadingDeltaPt
! Difference of charged hadron and trigger pT as function of trigger p
TH2F * fhJetFFzs[5][5]
! Accepted reconstructed jet fragmentation function, z=ptjet/pttrig
Correlate trigger particle and reconstructed jet.
TH2F * fhChargedLeadingXi
! Ln (pt leading charge / pt trigger)
TH2F * fhBkgRatioPt
! Ratio of pt background and pt trigger
TLorentzVector fJetConstMom
! jet constituent momentum
TH2F * fhChargedLeadingRatioPt
! Ratio of Pt leading charge and trigger
TH2F * fhChargedLeadingDeltaPhi
! Difference of charged hadron and trigger phi as function of trigger pT
const Double_t ptmin
TLorentzVector fLeadingPi0Mom
! leading particle momentum
virtual void SetCorrelatedBackground(TLorentzVector bkg)
TH2F * fhBkgFFxi
! Accepted reconstructed background fragmentation function, xsi = ln(pttrig/ptjet) ...
Double_t fDeltaPhiMaxCut
Minimum Delta Phi Gamma-Leading.
virtual Double_t GetEventWeight() const
Double_t fJetPtThresPbPb
Jet pT threshold under study(!fSeveralConeAndPtCuts)
virtual TString GetAddedHistogramsStringToName() const
TH2F * fhJetFFxi
! Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
TLorentzVector fLeadingPhoMom1
! leading particle momentum
TH2F * fhJetFFxis[5][5]
! Accepted reconstructed jet fragmentation function, xsi = ln(pttrig/ptjet)
Float_t GetHistoEtaMin() const
void Print(const Option_t *opt) const
Print some relevant parameters set for the analysis.
Bool_t Data(TH1F *h, Double_t *rangefit, Bool_t writefit, Double_t &sgn, Double_t &errsgn, Double_t &bkg, Double_t &errbkg, Double_t &sgnf, Double_t &errsgnf, Double_t &sigmafit, Int_t &status)
Bool_t IsParticleInJetCone(Double_t eta, Double_t phi, Double_t etal, Double_t phil) const
void GetLeadingPi0(AliCaloTrackParticleCorrelation *particle)
TH2F * fhBkgLeadingDeltaPhis[5][5]
! Delta phi background-leading
Float_t GetHistoEtaMax() const
TH2F * fhJetRatioPts[5][5]
! Ratio of pt jet and pt trigger
Int_t GetHistoPtBins() const
TH2F * fhJetNTracksInCones[5][5]
! jet multiplicity in cone
Double_t fJetCones[5]
Jet cone sizes under study (fSeveralConeAndPtCuts)
TH2F * fhChargedLeadingDeltaPhiRatioPt50
! Difference of charged hadron and trigger phi as function of pT leading / trigger pT...
UInt_t fSelect
kTRUE: Selects all jets, no limits.
Double_t fJetXMax1[6]
X Factor to set jet max limit for pp.
TString fJetNameCones[5]
String name of cone to append to histos.
virtual void SetAODObjArrayName(TString name)
virtual TLorentzVector GetCorrelatedJet() const
const Double_t etamax
virtual Double_t Phi() const
Double_t CalculateJetRatioLimit(Double_t ptTrig, const Double_t *param, const Double_t *x) const
virtual TLorentzVector GetLeading() const
Bool_t fSeveralConeAndPtCuts
To play with the jet cone size and pt th.
virtual void Print(const Option_t *) const
Print some relevant parameters set for the analysis.
Double_t fJetCTSRatioMinCut
Jet(CTS) /gamma Ratio cut maximum.
TH2F * fhNeutralLeadingDeltaPhiRatioPt50
! Difference of neutral hadron and trigger phi as function of pT leading / trigger pT...
const char Option_t
Definition: External.C:48
TH2F * fhBkgRatioPts[5][5]
! Ratio of pt background and pt trigger
TH2F * fhBkgLeadingDeltaEtas[5][5]
! Delta eta background-leading
TH2F * fhNeutralLeadingEta
! Eta(Pt trigger) distribution of neutral hadrons
TH2F * fhJetPts[5][5]
! Leading pt jet vs pt trigger
TString fJetNamePtThres[5]
String name of pt th to append to histos.
virtual void SetCorrelatedJet(TLorentzVector jet)
Float_t GetHistoPhiMax() const
virtual AliCaloTrackReader * GetReader() const
bool Bool_t
Definition: External.C:53
Int_t GetHistoEtaBins() const
Double_t fJetRatioMinCut
Jet(EMCAL+CTS)/gamma Ratio cut minimum.
virtual TObjArray * GetEMCALClusters() const
TH2F * fhBkgDeltaPhis[5][5]
! Delta phi background-trigger
virtual TLorentzVector GetCorrelatedBackground() const
Int_t nptbins
TLorentzVector fLeadingMom
! leading particle momentum
TH2F * fhBkgDeltaEtas[5][5]
! Delta eta background-trigger
TH2F * fhBkgFFpt
! Background particle pt distribution in cone
TH2F * fhBkgFFpts[5][5]
! Background particle pt distribution in cone
const Double_t phimin
TH2F * fhChargedLeadingDeltaEta
! Difference of charged particle and trigger eta as function of trigger pT