AliPhysics  9c66e61 (9c66e61)
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 
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),
128  fUseUnsubJet(0),
130  fDPhiHJetMax(0.6),
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),
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