AliPhysics  fe039ad (fe039ad)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskEmcalHJetMass.cxx
Go to the documentation of this file.
1 //
2 // Jet mass analysis task for jets recoiling from high pT hadron
3 //
4 // Author: M.Verweij
5 
6 #include <TClonesArray.h>
7 #include <TH1F.h>
8 #include <TH2F.h>
9 #include <TH3F.h>
10 #include <THnSparse.h>
11 #include <TList.h>
12 #include <TLorentzVector.h>
13 #include <TProfile.h>
14 #include <TChain.h>
15 #include <TSystem.h>
16 #include <TFile.h>
17 #include <TKey.h>
18 #include <TArrayI.h>
19 #include <TArrayF.h>
20 #include <TRandom3.h>
21 
22 #include "AliVCluster.h"
23 #include "AliVTrack.h"
24 #include "AliEmcalJet.h"
25 #include "AliRhoParameter.h"
26 #include "AliLog.h"
27 #include "AliEmcalParticle.h"
28 #include "AliAnalysisManager.h"
29 #include "AliJetContainer.h"
30 #include "AliParticleContainer.h"
31 
32 #include "AliAODEvent.h"
33 
35 
37 
38 namespace EmcalHJetMassAnalysis {
39 
40  //________________________________________________________________________
41  AliAnalysisTaskEmcalHJetMass::AliAnalysisTaskEmcalHJetMass() :
42  AliAnalysisTaskEmcalJet("AliAnalysisTaskEmcalHJetMass", kTRUE),
43  fDoHJetAna(kTRUE),
44  fDoNSHJetAna(kFALSE),
45  fContainerBase(0),
46  fContainerUnsub(1),
47  fMinFractionShared(0),
48  fUseUnsubJet(0),
49  fJetMassType(kRaw),
50  fDPhiHJetMax(0.6),
51  fTriggerTrackType(kInclusive),
52  fPtTTMin(0),
53  fPtTTMax(0),
54  fRandom(0),
55  fEmbConstSel(0),
56  fMarkMCLabel(-1),
57  fGapPhiMin(-1),
58  fGapPhiMax(-1),
59  fh1PtHadron(0),
60  fh1PtHadronMatch(0),
61  fh1PhiHadron(0),
62  fh3PtHPtJDPhi(0),
63  fh3PtJet1VsMassVsHPtAllSel(0),
64  fh3PtJet1VsMassVsHPtAllSelMatch(0),
65  fh3PtJet1VsMassVsHPtTagged(0),
66  fh3PtJet1VsMassVsHPtTaggedMatch(0),
67  fh3PtJet1VsRatVsHPtAllSel(0),
68  fh3PtJet1VsRatVsHPtAllSelMatch(0),
69  fh3PtJet1VsRatVsHPtTagged(0),
70  fh3PtJet1VsRatVsHPtTaggedMatch(0),
71  fhnAllSel(0),
72  fhnAllSelMatch(0),
73  fhnTagged(0),
74  fhnTaggedMatch(0)
75  {
76  // Default constructor.
77 
78  fh1PtHadron = new TH1F*[fNcentBins];
79  fh1PtHadronMatch = new TH1F*[fNcentBins];
80  fh1PhiHadron = new TH1F*[fNcentBins];
90  fhnAllSel = new THnSparse*[fNcentBins];
91  fhnAllSelMatch = new THnSparse*[fNcentBins];
92  fhnTagged = new THnSparse*[fNcentBins];
93  fhnTaggedMatch = new THnSparse*[fNcentBins];
94 
95  for (Int_t i = 0; i < fNcentBins; i++) {
96  fh1PtHadron[i] = 0;
97  fh1PtHadronMatch[i] = 0;
98  fh1PhiHadron[i] = 0;
99  fh3PtHPtJDPhi[i] = 0;
108  fhnAllSel[i] = 0;
109  fhnAllSelMatch[i] = 0;
110  fhnTagged[i] = 0;
111  fhnTaggedMatch[i] = 0;
112  }
113 
114  fPtTTMin = new TArrayF();
115  fPtTTMax = new TArrayF();
116 
118  }
119 
120  //________________________________________________________________________
122  AliAnalysisTaskEmcalJet(name, kTRUE),
123  fDoHJetAna(kTRUE),
124  fDoNSHJetAna(kFALSE),
125  fContainerBase(0),
126  fContainerUnsub(1),
127  fMinFractionShared(0),
128  fUseUnsubJet(0),
129  fJetMassType(kRaw),
130  fDPhiHJetMax(0.6),
131  fTriggerTrackType(kInclusive),
132  fPtTTMin(0),
133  fPtTTMax(0),
134  fRandom(0),
135  fEmbConstSel(0),
136  fMarkMCLabel(-1),
137  fGapPhiMin(-1),
138  fGapPhiMax(-1),
139  fh1PtHadron(0),
140  fh1PtHadronMatch(0),
141  fh1PhiHadron(0),
142  fh3PtHPtJDPhi(0),
143  fh3PtJet1VsMassVsHPtAllSel(0),
144  fh3PtJet1VsMassVsHPtAllSelMatch(0),
145  fh3PtJet1VsMassVsHPtTagged(0),
146  fh3PtJet1VsMassVsHPtTaggedMatch(0),
147  fh3PtJet1VsRatVsHPtAllSel(0),
148  fh3PtJet1VsRatVsHPtAllSelMatch(0),
149  fh3PtJet1VsRatVsHPtTagged(0),
150  fh3PtJet1VsRatVsHPtTaggedMatch(0),
151  fhnAllSel(0),
152  fhnAllSelMatch(0),
153  fhnTagged(0),
154  fhnTaggedMatch(0)
155  {
156  // Standard constructor.
157 
158  fh1PtHadron = new TH1F*[fNcentBins];
159  fh1PtHadronMatch = new TH1F*[fNcentBins];
160  fh1PhiHadron = new TH1F*[fNcentBins];
161  fh3PtHPtJDPhi = new TH3F*[fNcentBins];
170  fhnAllSel = new THnSparse*[fNcentBins];
171  fhnAllSelMatch = new THnSparse*[fNcentBins];
172  fhnTagged = new THnSparse*[fNcentBins];
173  fhnTaggedMatch = new THnSparse*[fNcentBins];
174 
175  for (Int_t i = 0; i < fNcentBins; i++) {
176  fh1PtHadron[i] = 0;
177  fh1PtHadronMatch[i] = 0;
178  fh1PhiHadron[i] = 0;
179  fh3PtHPtJDPhi[i] = 0;
188  fhnAllSel[i] = 0;
189  fhnAllSelMatch[i] = 0;
190  fhnTagged[i] = 0;
191  fhnTaggedMatch[i] = 0;
192  }
193 
194  fPtTTMin = new TArrayF();
195  fPtTTMax = new TArrayF();
196 
198  }
199 
200  //________________________________________________________________________
202  {
203  // Destructor.
204 
205  if(fRandom) delete fRandom;
206  if(fPtTTMin) delete fPtTTMin;
207  if(fPtTTMax) delete fPtTTMax;
208  }
209 
210  //________________________________________________________________________
212  {
213  // Create user output.
214 
216 
217  Bool_t oldStatus = TH1::AddDirectoryStatus();
218  TH1::AddDirectory(kFALSE);
219 
220  const Int_t nBinsPt = 200;
221  const Double_t minPt = -50.;
222  const Double_t maxPt = 150.;
223 
224  const Int_t nBinsM = 90;
225  const Double_t minM = -10.;
226  const Double_t maxM = 80.;
227 
228  const Int_t nBinsR = 100;
229  const Double_t minR = -0.2;
230  const Double_t maxR = 0.8;
231 
232  const Int_t nBinsPtH = 100;
233  const Double_t minPtH = 0.;
234  const Double_t maxPtH = 100.;
235 
236  const Int_t nBinsPhi = 18*4;
237  const Double_t minPhi = -0.5*TMath::Pi();
238  const Double_t maxPhi = 1.5*TMath::Pi();
239 
240  const Int_t nBinsSparse0 = 4; //PtJetAS,MJetAS,PtHNS,MJetNS
241  const Int_t nBins0[nBinsSparse0] = {nBinsPt,nBinsM,nBinsPtH,nBinsM};
242  const Double_t xmin0[nBinsSparse0] = { minPt, minM, minPtH, minM};
243  const Double_t xmax0[nBinsSparse0] = { maxPt, maxM, maxPtH, maxM};
244 
245  TString histName = "";
246  TString histTitle = "";
247  for (Int_t i = 0; i < fNcentBins; i++) {
248  histName = TString::Format("fh1PtHadron_%d",i);
249  histTitle = TString::Format("%s;#it{p}_{T,h}",histName.Data());
250  fh1PtHadron[i] = new TH1F(histName.Data(),histTitle.Data(),200.,0.,200.);
251  fOutput->Add(fh1PtHadron[i]);
252 
253  histName = TString::Format("fh1PtHadronMatch_%d",i);
254  histTitle = TString::Format("%s;#it{p}_{T,h}",histName.Data());
255  fh1PtHadronMatch[i] = new TH1F(histName.Data(),histTitle.Data(),200.,0.,200.);
256  fOutput->Add(fh1PtHadronMatch[i]);
257 
258  histName = TString::Format("fh1PhiHadron_%d",i);
259  histTitle = TString::Format("%s;#varphi",histName.Data());
260  fh1PhiHadron[i] = new TH1F(histName.Data(),histTitle.Data(),nBinsPhi,0.,TMath::TwoPi());
261  fOutput->Add(fh1PhiHadron[i]);
262 
263  histName = TString::Format("fh3PtHPtJDPhi_%d",i);
264  histTitle = TString::Format("%s;#it{p}_{T,h};#it{p}_{T,jet};#Delta#varphi_{h,jet}",histName.Data());
265  fh3PtHPtJDPhi[i] = new TH3F(histName.Data(),histTitle.Data(),nBinsPtH,minPtH,maxPtH,nBinsPt,minPt,maxPt,nBinsPhi,minPhi,maxPhi);
266  fOutput->Add(fh3PtHPtJDPhi[i]);
267 
268  if(fDoHJetAna) {
269  histName = TString::Format("fh3PtJet1VsMassVsHPtAllSel_%d",i);
270  histTitle = TString::Format("%s;#it{p}_{T,jet1};#it{M}_{jet1};#it{p}_{T,h}",histName.Data());
271  fh3PtJet1VsMassVsHPtAllSel[i] = new TH3F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsM,minM,maxM,nBinsPtH,minPtH,maxPtH);
272  fOutput->Add(fh3PtJet1VsMassVsHPtAllSel[i]);
273 
274  histName = TString::Format("fh3PtJet1VsMassVsHPtAllSelMatch_%d",i);
275  histTitle = TString::Format("%s;#it{p}_{T,jet1};#it{M}_{jet1};#it{p}_{T,h}",histName.Data());
276  fh3PtJet1VsMassVsHPtAllSelMatch[i] = new TH3F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsM,minM,maxM,nBinsPtH,minPtH,maxPtH);
277  fOutput->Add(fh3PtJet1VsMassVsHPtAllSelMatch[i]);
278 
279  histName = TString::Format("fh3PtJet1VsMassVsHPtTagged_%d",i);
280  histTitle = TString::Format("%s;#it{p}_{T,jet1};#it{M}_{jet1};#it{p}_{T,h}",histName.Data());
281  fh3PtJet1VsMassVsHPtTagged[i] = new TH3F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsM,minM,maxM,nBinsPtH,minPtH,maxPtH);
282  fOutput->Add(fh3PtJet1VsMassVsHPtTagged[i]);
283 
284  histName = TString::Format("fh3PtJet1VsMassVsHPtTaggedMatch_%d",i);
285  histTitle = TString::Format("%s;#it{p}_{T,jet1};#it{M}_{jet1};#it{p}_{T,h}",histName.Data());
286  fh3PtJet1VsMassVsHPtTaggedMatch[i] = new TH3F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsM,minM,maxM,nBinsPtH,minPtH,maxPtH);
287  fOutput->Add(fh3PtJet1VsMassVsHPtTaggedMatch[i]);
288 
289  //
290  histName = TString::Format("fh3PtJet1VsRatVsHPtAllSel_%d",i);
291  histTitle = TString::Format("%s;#it{p}_{T,jet1};#it{M}_{jet1}/#it{p}_{T,jet1};#it{p}_{T,h}",histName.Data());
292  fh3PtJet1VsRatVsHPtAllSel[i] = new TH3F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsR,minR,maxR,nBinsPtH,minPtH,maxPtH);
293  fOutput->Add(fh3PtJet1VsRatVsHPtAllSel[i]);
294 
295  histName = TString::Format("fh3PtJet1VsRatVsHPtAllSelMatch_%d",i);
296  histTitle = TString::Format("%s;#it{p}_{T,jet1};#it{M}_{jet1}/#it{p}_{T,jet1};#it{p}_{T,h}",histName.Data());
297  fh3PtJet1VsRatVsHPtAllSelMatch[i] = new TH3F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsR,minR,maxR,nBinsPtH,minPtH,maxPtH);
298  fOutput->Add(fh3PtJet1VsRatVsHPtAllSelMatch[i]);
299 
300  histName = TString::Format("fh3PtJet1VsRatVsHPtTagged_%d",i);
301  histTitle = TString::Format("%s;#it{p}_{T,jet1};#it{M}_{jet1}/#it{p}_{T,jet1};#it{p}_{T,h}",histName.Data());
302  fh3PtJet1VsRatVsHPtTagged[i] = new TH3F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsR,minR,maxR,nBinsPtH,minPtH,maxPtH);
303  fOutput->Add(fh3PtJet1VsRatVsHPtTagged[i]);
304 
305  histName = TString::Format("fh3PtJet1VsRatVsHPtTaggedMatch_%d",i);
306  histTitle = TString::Format("%s;#it{p}_{T,jet1};#it{M}_{jet1}/#it{p}_{T,jet1};#it{p}_{T,h}",histName.Data());
307  fh3PtJet1VsRatVsHPtTaggedMatch[i] = new TH3F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsR,minR,maxR,nBinsPtH,minPtH,maxPtH);
308  fOutput->Add(fh3PtJet1VsRatVsHPtTaggedMatch[i]);
309  }
310 
311  if(fDoNSHJetAna) {
312  histName = TString::Format("fhnAllSel_%d",i);
313  histTitle = Form("%s;#it{p}_{T,jet}^{AS};#it{M}_{jet}^{AS};#it{p}_{T,h}^{NS};#it{M}_{jet}^{NS}",histName.Data());
314  fhnAllSel[i] = new THnSparseF(histName.Data(),histTitle.Data(),nBinsSparse0,nBins0,xmin0,xmax0);
315  fOutput->Add(fhnAllSel[i]);
316 
317  histName = TString::Format("fhnAllSelMatch_%d",i);
318  histTitle = Form("%s;#it{p}_{T,jet}^{AS};#it{M}_{jet}^{AS};#it{p}_{T,h}^{NS};#it{M}_{jet}^{NS}",histName.Data());
319  fhnAllSelMatch[i] = new THnSparseF(histName.Data(),histTitle.Data(),nBinsSparse0,nBins0,xmin0,xmax0);
320  fOutput->Add(fhnAllSelMatch[i]);
321 
322  histName = TString::Format("fhnTagged_%d",i);
323  histTitle = Form("%s;#it{p}_{T,jet}^{AS};#it{M}_{jet}^{AS};#it{p}_{T,h}^{NS};#it{M}_{jet}^{NS}",histName.Data());
324  fhnTagged[i] = new THnSparseF(histName.Data(),histTitle.Data(),nBinsSparse0,nBins0,xmin0,xmax0);
325  fOutput->Add(fhnTagged[i]);
326 
327  histName = TString::Format("fhnTaggedMatch_%d",i);
328  histTitle = Form("%s;#it{p}_{T,jet}^{AS};#it{M}_{jet}^{AS};#it{p}_{T,h}^{NS};#it{M}_{jet}^{NS}",histName.Data());
329  fhnTaggedMatch[i] = new THnSparseF(histName.Data(),histTitle.Data(),nBinsSparse0,nBins0,xmin0,xmax0);
330  fOutput->Add(fhnTaggedMatch[i]);
331  }
332  }
333 
334  TH1::AddDirectory(oldStatus);
335 
336  fRandom = new TRandom3(0);
337 
338  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
339  }
340 
341  //________________________________________________________________________
343  {
344  // Run analysis code here, if needed. It will be executed before FillHistograms().
345 
348  if(!pCont || !jCont) return kFALSE;
349 
350  AliVParticle *vp = NULL;
351 
353  pCont->ResetCurrentID();
354  while((vp = pCont->GetNextAcceptParticle())) {
355  fh1PtHadron[fCentBin]->Fill(vp->Pt()); //all hadrons
356  fh1PhiHadron[fCentBin]->Fill(vp->Phi()); //all hadrons
357  if(fMarkMCLabel>0 && TMath::Abs(vp->GetLabel()) >= fMarkMCLabel )
358  fh1PtHadronMatch[fCentBin]->Fill(vp->Pt()); //hadrons matched to MC: now done in paticle container
359  AliEmcalJet* jet = NULL;
360  if(jCont) {
361  jCont->ResetCurrentID();
362  while((jet = jCont->GetNextAcceptJet())) {
363  Double_t dphi = GetDeltaPhi(vp,jet);
364  fh3PtHPtJDPhi[fCentBin]->Fill(vp->Pt(),jet->Pt() - GetRhoVal(fContainerBase)*jet->Area(),dphi);
365  if(TMath::Abs(dphi-TMath::Pi())>fDPhiHJetMax) continue;
366  FillHJetHistograms(vp,jet);
367  }
368  }
369  }
370  }
372  for(Int_t it = 0; it<fPtTTMin->GetSize(); it++) {
373  vp = GetSingleInclusiveTT(pCont,fPtTTMin->At(it),fPtTTMax->At(it));
374  if(!vp) continue;
375  fh1PtHadron[fCentBin]->Fill(vp->Pt()); //all trigger tracks
376  fh1PhiHadron[fCentBin]->Fill(vp->Phi()); //all hadrons
377  if(fMarkMCLabel>0 && TMath::Abs(vp->GetLabel()) >= fMarkMCLabel )
378  fh1PtHadronMatch[fCentBin]->Fill(vp->Pt()); //hadrons matched to MC: now done in paticle container
379  AliEmcalJet* jet = NULL;
380  jCont->ResetCurrentID();
381  while((jet = jCont->GetNextAcceptJet())) {
382  Double_t dphi = GetDeltaPhi(vp,jet);
383  fh3PtHPtJDPhi[fCentBin]->Fill(vp->Pt(),jet->Pt() - GetRhoVal(fContainerBase)*jet->Area(),dphi);
384  if(TMath::Abs(dphi-TMath::Pi())>fDPhiHJetMax) continue;
385  FillHJetHistograms(vp,jet);
386  }
387  }//trigger track types
388  }
389  return kTRUE;
390  }
391 
392  //________________________________________________________________________
394  AliVParticle *vp;
395  TArrayI arr; arr.Set(pCont->GetNParticles());
396  arr.Reset();
397  Int_t counter = -1;
398  pCont->ResetCurrentID();
399  while((vp = pCont->GetNextAcceptParticle())) {
400  if(vp->Pt()>=ptmin && vp->Pt()<ptmax ) {
401  counter++;
402  arr.SetAt(pCont->GetCurrentID(),counter);
403  }
404  }
405  if(counter<0) return NULL;
406  //select trigger track randomly
407  fRandom->SetSeed(arr.At(0)); //random selection reproducible
408  Double_t rnd = fRandom->Uniform() * counter;
409  Int_t trigID = arr.At(TMath::FloorNint(rnd));
410  vp = pCont->GetParticle(trigID);
411  if(fGapPhiMin>-1.) {
412  //check if trigger track opposite side of TPC hole dphi<fDPhiHJetMax
413  Double_t phiOp = vp->Phi()+TMath::Pi();
414  if(phiOp>TMath::TwoPi()) phiOp-=TMath::TwoPi();
415  Double_t phiOpMin = phiOp - fDPhiHJetMax;
416  if(phiOpMin<0.) phiOpMin+=TMath::TwoPi();
417  Double_t phiOpMax = phiOp + fDPhiHJetMax;
418  if(phiOpMax>TMath::TwoPi()) phiOpMax-=TMath::TwoPi();
419  if(phiOpMin > fGapPhiMin && phiOpMin < fGapPhiMax) return NULL;
420  if(phiOpMax > fGapPhiMin && phiOpMax < fGapPhiMax) return NULL;
421  }
422  return vp;
423  }
424 
425  //________________________________________________________________________
427  {
428  // Fill hadron-jet histograms.
429  Double_t pt = vp->Pt();
430  Double_t ptJet = jet->Pt() - GetRhoVal(fContainerBase)*jet->Area();
431  Double_t mJet = GetJetMass(jet);
432  Double_t rat = -1.;
433  if(ptJet<0. || ptJet>0.) rat = mJet/ptJet;
434 
435  Double_t var[4] = {ptJet,mJet,pt,-99.};
436  if(fDoNSHJetAna) {
437  AliEmcalJet *jetNS = FindNearSideJet(vp);
438  if(jetNS) var[3] = GetJetMass(jetNS);
439  }
440 
441  if(fDoHJetAna) {
442  fh3PtJet1VsMassVsHPtAllSel[fCentBin]->Fill(ptJet,mJet,pt);
443  fh3PtJet1VsRatVsHPtAllSel[fCentBin]->Fill(ptJet,rat,pt);
444  }
445 
446  if(fDoNSHJetAna)
447  fhnAllSel[fCentBin]->Fill(var);
448 
449  Double_t fraction = 1.;
450  if(fUseUnsubJet) {
451  AliEmcalJet *jetUS = NULL;
453  Int_t ifound = 0;
454  Int_t ilab = -1;
455  for(Int_t i = 0; i<jetContUS->GetNJets(); i++) {
456  jetUS = jetContUS->GetJet(i);
457  if(jetUS->GetLabel()==jet->GetLabel()) {
458  ifound++;
459  if(ifound==1) ilab = i;
460  }
461  }
462  if(ifound>1) AliDebug(2,Form("Found %d partners",ifound));
463  if(ifound==0) jetUS = 0x0;
464  else jetUS = jetContUS->GetJet(ilab);
465  fraction = jetContUS->GetFractionSharedPt(jetUS);
466  } else {
468  fraction = jetCont->GetFractionSharedPt(jet);
469  }
470 
471  Bool_t mcMatch = kFALSE;
472  if(fMarkMCLabel>0 && TMath::Abs(vp->GetLabel()) >= fMarkMCLabel ) mcMatch = kTRUE;
473  if(fMinFractionShared>0. && fraction>fMinFractionShared) mcMatch = kTRUE;
474  else mcMatch = kFALSE;
475 
476  if(mcMatch) {
477  if(fDoHJetAna) {
478  fh3PtJet1VsMassVsHPtAllSelMatch[fCentBin]->Fill(ptJet,mJet,pt);
479  fh3PtJet1VsRatVsHPtAllSelMatch[fCentBin]->Fill(ptJet,rat,pt);
480  }
481  if(fDoNSHJetAna)
482  fhnAllSelMatch[fCentBin]->Fill(var);
483  }
484 
485  if(jet->GetTagStatus()<1 || !jet->GetTaggedJet())
486  return kFALSE;
487 
488  if(fDoHJetAna) {
489  fh3PtJet1VsMassVsHPtTagged[fCentBin]->Fill(ptJet,mJet,pt);
490  fh3PtJet1VsRatVsHPtTagged[fCentBin]->Fill(ptJet,rat,pt);
491  }
492  if(fDoNSHJetAna)
493  fhnTagged[fCentBin]->Fill(var);
494 
495  if(mcMatch) {
496  if(fDoHJetAna) {
497  fh3PtJet1VsMassVsHPtTaggedMatch[fCentBin]->Fill(ptJet,mJet,pt);
498  fh3PtJet1VsRatVsHPtTaggedMatch[fCentBin]->Fill(ptJet,rat,pt);
499  }
500  if(fDoNSHJetAna)
501  fhnTaggedMatch[fCentBin]->Fill(var);
502  }
503  return kTRUE;
504  }
505 
506  //________________________________________________________________________
509  AliEmcalJet* jet = NULL;
510  if(jCont) {
511  jCont->ResetCurrentID();
512  while((jet = jCont->GetNextAcceptJet())) {
513  Int_t n = (Int_t)jet->GetNumberOfTracks();
514  if (n < 1) continue;
515  for (Int_t i = 0; i < n; i++) {
516  AliVParticle *vp2 = static_cast<AliVParticle*>(jet->TrackAt(i, jCont->GetParticleContainer()->GetArray()));
517  if(!vp2) continue;
518  if(vp->Phi()==vp2->Phi()) return jet;
519  }
520  }
521  }
522  return jet;
523  }
524 
525  //________________________________________________________________________
527  //calc subtracted jet mass
528  if(fJetMassType==kRaw)
529  return jet->M();
530  else if(fJetMassType==kDeriv)
532 
533  return 0;
534  }
535 
536  //________________________________________________________________________
537  Double_t AliAnalysisTaskEmcalHJetMass::GetDeltaPhi(const AliVParticle *vp, const AliEmcalJet* jet) const {
538  // Calculate azimuthal angle between particle and jet. range:[-0.5\pi,1.5\pi]
539  return GetDeltaPhi(vp->Phi(),jet->Phi());
540  }
541 
542  //________________________________________________________________________
544  // Calculate azimuthal angle between phi1 and phi2. range:[-0.5\pi,1.5\pi]
545  Double_t dPhi = phi1-phi2;
546  if(dPhi <-0.5*TMath::Pi()) dPhi += TMath::TwoPi();
547  if(dPhi > 1.5*TMath::Pi()) dPhi -= TMath::TwoPi();
548  return dPhi;
549  }
550 
551  //________________________________________________________________________
553  //
554  // retrieve event objects
555  //
557  return kFALSE;
558 
559  return kTRUE;
560  }
561 
562  //________________________________________________________________________
564  if(!fPtTTMin) fPtTTMin = new TArrayF();
565  if(!fPtTTMax) fPtTTMax = new TArrayF();
566  Int_t newSize = fPtTTMin->GetSize()+1;
567  fPtTTMin->Set(newSize);
568  fPtTTMax->Set(newSize);
569  fPtTTMin->AddAt(min,newSize-1);
570  fPtTTMax->AddAt(max,newSize-1);
571  }
572 
573  //_______________________________________________________________________
575  {
576  // Called once at the end of the analysis.
577  }
578 }
579 
Double_t Area() const
Definition: AliEmcalJet.h:130
TH3F ** fh3PtJet1VsRatVsHPtTagged
all jets after std selection pt vs mass/pt vs track pt matched to MC
virtual AliVParticle * GetNextAcceptParticle()
double Double_t
Definition: External.C:58
AliEmcalJet * GetTaggedJet() const
Definition: AliEmcalJet.h:337
TH3F ** fh3PtJet1VsMassVsHPtAllSel
pt hadron vs pt jet vs delta phi
Bool_t RetrieveEventObjects()
Retrieve common objects from event.
Definition: External.C:260
AliJetContainer * GetJetContainer(Int_t i=0) const
Int_t GetTagStatus() const
Definition: AliEmcalJet.h:338
TH3F ** fh3PtJet1VsMassVsHPtTaggedMatch
tagged jets pt vs mass vs track pt
Double_t Phi() const
Definition: AliEmcalJet.h:117
Int_t GetNParticles() const
Double_t GetDeltaPhi(const AliVParticle *vp, const AliEmcalJet *jet) const
Int_t GetLabel() const
Definition: AliEmcalJet.h:124
THnSparse ** fhnAllSel
tagged jets pt vs mas/pts vs track pt matched to MC
TH3F ** fh3PtJet1VsMassVsHPtTagged
all jets after std selection pt vs mass vs track pt matched to MC
Int_t fCentBin
!event centrality bin
Container for particles within the EMCAL framework.
Int_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:160
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:139
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Get particle container attached to this task.
AliParticleContainer * GetParticleContainer() const
int Int_t
Definition: External.C:63
AliVParticle * GetSingleInclusiveTT(AliParticleContainer *pCont, Double_t ptmin, Double_t ptmax) const
float Float_t
Definition: External.C:68
const Double_t ptmax
virtual AliVParticle * GetParticle(Int_t i=-1) const
Int_t GetNJets() const
Int_t fNcentBins
how many centrality bins
THnSparse ** fhnAllSelMatch
all jets after std selection pt vs mass vs track pt vs mass_NS
TH3F ** fh3PtJet1VsRatVsHPtAllSelMatch
all jets after std selection pt vs mass/pt vs track pt
const Double_t ptmin
TH3F ** fh3PtJet1VsMassVsHPtAllSelMatch
all jets after std selection pt vs mass vs track pt
AliEmcalJet * GetNextAcceptJet()
Double_t Pt() const
Definition: AliEmcalJet.h:109
Double_t GetRhoVal(Int_t i=0) const
THnSparse ** fhnTagged
all jets after std selection pt vs mass vs track pt vs mass_NS matched to MC
Bool_t Run()
Run function. This is the core function of the analysis and contains the user code. Therefore users have to implement this function.
THnSparse ** fhnTaggedMatch
tagged jets pt vs mass vs track pt vs mass_NS
AliEmcalList * fOutput
!output list
void SetMakeGeneralHistograms(Bool_t g)
Base task in the EMCAL jet framework.
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:51
Double_t GetFractionSharedPt(const AliEmcalJet *jet, AliParticleContainer *cont2=0x0) const
const char Option_t
Definition: External.C:48
void UserCreateOutputObjects()
Main initialization function on the worker.
Bool_t FillHJetHistograms(const AliVParticle *vp, const AliEmcalJet *jet)
TH3F ** fh3PtJet1VsRatVsHPtAllSel
tagged jets pt vs mass vs track pt matched to MC
bool Bool_t
Definition: External.C:53
AliEmcalJetShapeProperties * GetShapeProperties() const
Definition: AliEmcalJet.h:361
Double_t M() const
Definition: AliEmcalJet.h:120
TH3F ** fh3PtJet1VsRatVsHPtTaggedMatch
tagged jets pt vs mass/pt vs track pt
Container for jet within the EMCAL jet framework.
AliEmcalJet * GetJet(Int_t i) const