AliPhysics  b555aef (b555aef)
AliAnalysisTaskSoftDrop.cxx
Go to the documentation of this file.
1 #include <TClonesArray.h>
2 #include <TH1F.h>
3 #include <TH2F.h>
4 #include <TH3F.h>
5 #include <TList.h>
6 #include <TLorentzVector.h>
7 
8 #include "AliVCluster.h"
9 #include "AliAODCaloCluster.h"
10 #include "AliESDCaloCluster.h"
11 #include "AliVTrack.h"
12 #include "AliEmcalJet.h"
13 #include "AliRhoParameter.h"
14 #include "AliLog.h"
15 #include "AliJetContainer.h"
16 #include "AliParticleContainer.h"
17 #include "AliClusterContainer.h"
18 #include "AliPicoTrack.h"
19 
21 
23 
24 //________________________________________________________________________
27  fHistTracksPt(0),
28  fHistClustersPt(0),
29  fHistLeadingJetPt(0),
30  fHistJetsPhiEta(0),
31  fHistJetsPtArea(0),
32  fHistJetsPtLeadHad(0),
33  fHistJetsCorrPtArea(0),
34  fHistPtDEtaDPhiTrackClus(0),
35  fHistPtDEtaDPhiClusTrack(0),
36  fHistNTracks(0),
37  fHistClustDx(0),
38  fHistClustDz(0),
39  fNAccJets(0),
40  fhZg(0),
41  fJetsCont(0),
42  fTracksCont(0),
43  fCaloClustersCont(0)
44 
45 {
46  // Default constructor.
47 
48  fHistTracksPt = new TH1*[fNcentBins];
49  fHistNTracks = new TH1*[fNcentBins];
50  fHistClustersPt = new TH1*[fNcentBins];
51  fHistLeadingJetPt = new TH1*[fNcentBins];
52  fHistJetsPhiEta = new TH2*[fNcentBins];
53  fHistJetsPtArea = new TH2*[fNcentBins];
54  fHistJetsPtLeadHad = new TH2*[fNcentBins];
55  fHistJetsCorrPtArea = new TH2*[fNcentBins];
56 
57  for (Int_t i = 0; i < fNcentBins; i++) {
58  fHistTracksPt[i] = 0;
59  fHistNTracks[i] = 0;
60  fHistClustersPt[i] = 0;
61  fHistLeadingJetPt[i] = 0;
62  fHistJetsPhiEta[i] = 0;
63  fHistJetsPtArea[i] = 0;
64  fHistJetsPtLeadHad[i] = 0;
65  fHistJetsCorrPtArea[i] = 0;
66  }
67 
68  SetMakeGeneralHistograms(kTRUE);
69 }
70 
71 //________________________________________________________________________
73  AliAnalysisTaskEmcalJet(name, kTRUE),
74  fHistTracksPt(0),
75  fHistClustersPt(0),
76  fHistLeadingJetPt(0),
77  fHistJetsPhiEta(0),
78  fHistJetsPtArea(0),
79  fHistJetsPtLeadHad(0),
80  fHistJetsCorrPtArea(0),
81  fHistPtDEtaDPhiTrackClus(0),
82  fHistPtDEtaDPhiClusTrack(0),
83  fHistNTracks(0),
84  fHistClustDx(0),
85  fHistClustDz(0),
86  fNAccJets(0),
87  fhZg(0),
88  fJetsCont(0),
89  fTracksCont(0),
90  fCaloClustersCont(0)
91 {
92  // Standard constructor.
93 
95  fHistNTracks = new TH1*[fNcentBins];
102 
103  for (Int_t i = 0; i < fNcentBins; i++) {
104  fHistTracksPt[i] = 0;
105  fHistNTracks[i] = 0;
106  fHistClustersPt[i] = 0;
107  fHistLeadingJetPt[i] = 0;
108  fHistJetsPhiEta[i] = 0;
109  fHistJetsPtArea[i] = 0;
110  fHistJetsPtLeadHad[i] = 0;
111  fHistJetsCorrPtArea[i] = 0;
112  }
113 
115 }
116 
117 //________________________________________________________________________
119 {
120  // Destructor.
121 }
122 
123 //________________________________________________________________________
125 {
126  // Create user output.
127 
129 
131  if(fJetsCont) { //get particles and clusters connected to jets
134  } else { //no jets, just analysis tracks and clusters
137  }
138  if(fTracksCont) fTracksCont->SetClassName("AliVTrack");
139  if(fCaloClustersCont) fCaloClustersCont->SetClassName("AliVCluster");
140 
141  TString histname;
142 
143  for (Int_t i = 0; i < fNcentBins; i++) {
144  if (fParticleCollArray.GetEntriesFast()>0) {
145  histname = "fHistTracksPt_";
146  histname += i;
147  fHistTracksPt[i] = new TH1F(histname.Data(), histname.Data(), fNbins / 2, fMinBinPt, fMaxBinPt / 2);
148  fHistTracksPt[i]->GetXaxis()->SetTitle("p_{T,track} (GeV/c)");
149  fHistTracksPt[i]->GetYaxis()->SetTitle("counts");
150  fOutput->Add(fHistTracksPt[i]);
151 
152  histname = "fHistNTracks_";
153  histname += i;
154  fHistNTracks[i] = new TH1F(histname.Data(), histname.Data(), 200, 0., 199.);
155  fOutput->Add(fHistNTracks[i]);
156  }
157 
158  if (fClusterCollArray.GetEntriesFast()>0) {
159  histname = "fHistClustersPt_";
160  histname += i;
161  fHistClustersPt[i] = new TH1F(histname.Data(), histname.Data(), fNbins / 2, fMinBinPt, fMaxBinPt / 2);
162  fHistClustersPt[i]->GetXaxis()->SetTitle("p_{T,clus} (GeV/c)");
163  fHistClustersPt[i]->GetYaxis()->SetTitle("counts");
164  fOutput->Add(fHistClustersPt[i]);
165  }
166 
167  if (fJetCollArray.GetEntriesFast()>0) {
168  histname = "fHistLeadingJetPt_";
169  histname += i;
170  fHistLeadingJetPt[i] = new TH1F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt);
171  fHistLeadingJetPt[i]->GetXaxis()->SetTitle("p_{T}^{raw} (GeV/c)");
172  fHistLeadingJetPt[i]->GetYaxis()->SetTitle("counts");
173  fOutput->Add(fHistLeadingJetPt[i]);
174 
175  histname = "fHistJetsPhiEta_";
176  histname += i;
177  fHistJetsPhiEta[i] = new TH2F(histname.Data(), histname.Data(), 50, -1, 1, 101, 0, TMath::Pi()*2 + TMath::Pi()/200);
178  fHistJetsPhiEta[i]->GetXaxis()->SetTitle("#eta");
179  fHistJetsPhiEta[i]->GetYaxis()->SetTitle("#phi");
180  fOutput->Add(fHistJetsPhiEta[i]);
181 
182  histname = "fHistJetsPtArea_";
183  histname += i;
184  fHistJetsPtArea[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, 50, 0, 1);
185  fHistJetsPtArea[i]->GetXaxis()->SetTitle("p_{T}^{raw} (GeV/c)");
186  fHistJetsPtArea[i]->GetYaxis()->SetTitle("area");
187  fOutput->Add(fHistJetsPtArea[i]);
188 
189  histname = "fHistJetsPtLeadHad_";
190  histname += i;
191  fHistJetsPtLeadHad[i] = new TH2F(histname.Data(), histname.Data(), fNbins, fMinBinPt, fMaxBinPt, fNbins / 2, fMinBinPt, fMaxBinPt / 2);
192  fHistJetsPtLeadHad[i]->GetXaxis()->SetTitle("p_{T}^{raw} (GeV/c)");
193  fHistJetsPtLeadHad[i]->GetYaxis()->SetTitle("p_{T,lead} (GeV/c)");
194  fHistJetsPtLeadHad[i]->GetZaxis()->SetTitle("counts");
195  fOutput->Add(fHistJetsPtLeadHad[i]);
196 
197  if (!(GetJetContainer()->GetRhoName().IsNull())) {
198  histname = "fHistJetsCorrPtArea_";
199  histname += i;
200  fHistJetsCorrPtArea[i] = new TH2F(histname.Data(), histname.Data(), fNbins*2, -fMaxBinPt, fMaxBinPt, 50, 0, 1);
201  fHistJetsCorrPtArea[i]->GetXaxis()->SetTitle("p_{T}^{corr} [GeV/c]");
202  fHistJetsCorrPtArea[i]->GetYaxis()->SetTitle("area");
203  fOutput->Add(fHistJetsCorrPtArea[i]);
204  }
205  }
206  }
207 
208  histname = "fHistPtDEtaDPhiTrackClus";
209  fHistPtDEtaDPhiTrackClus = new TH3F(histname.Data(),Form("%s;#it{p}_{T}^{track};#Delta#eta;#Delta#varphi",histname.Data()),100,0.,100.,100,-0.1,0.1,100,-0.1,0.1);
211 
212  histname = "fHistPtDEtaDPhiClusTrack";
213  fHistPtDEtaDPhiClusTrack = new TH3F(histname.Data(),Form("%s;#it{p}_{T}^{clus};#Delta#eta;#Delta#varphi",histname.Data()),100,0.,100.,100,-0.1,0.1,100,-0.1,0.1);
215 
216  fHistClustDx = new TH1F("fHistClustDx","fHistClustDx;Dx",1000,0.,1.);
217  fOutput->Add(fHistClustDx);
218 
219  fHistClustDz = new TH1F("fHistClustDz","fHistClustDz;Dz",1000,0.,1.);
220  fOutput->Add(fHistClustDz);
221 
222  fNAccJets = new TH1F("fNAccJets","fNAccJets;N/ev",11,-0.5, 9.5);
223  fOutput->Add(fNAccJets);
224 
225  fhZg = new TH1F("fhZg", "#it{Z}_{g}; #it{Z}_{g}; Entries", 200, 0., 0.5);
226  fOutput->Add(fhZg);
227 
228  fhCorrPtZg = new TH2F("fhCorrPtZg", "#it{Z}_{g}; p_{T}^{corr} [GeV/c]; #it{Z}_{g}", 16, 0, 160, 20, 0., 0.5);
229  fOutput->Add(fhCorrPtZg);
230 
231  fhCorrPtZg2 = new TH2F("fhCorrPtZg2", "#it{Z}_{g}; p_{T}^{corr} [GeV/c]; #it{Z}_{g}", 16, 0, 160, 20, 0., 0.5);
232  fOutput->Add(fhCorrPtZg2);
233 
234  fhCorrPtZgD = new TH2F("fhCorrPtZgD", "#it{Z}_{g}; p_{T}^{corr} [GeV/c]; #it{Z}_{g}", 16, 0, 160, 20, 0., 0.5);
235  fOutput->Add(fhCorrPtZgD);
236 
237  fhCorrPtRg = new TH2F("fhCorrPtRg", "R_{g}; p_{T}^{corr} [GeV/c]; R_{g}", 16, 0, 160, 40, 0., 0.5);
238  fOutput->Add(fhCorrPtRg);
239 
240  fhCorrPtRgD = new TH2F("fhCorrPtRgD", "R_{g}; p_{T}^{corr} [GeV/c]; R_{g}", 16, 0, 160, 40, 0., 0.5);
241  fOutput->Add(fhCorrPtRgD);
242 
243  fhCorrPtZgSDstep = new TH3F("fhCorrPtZgSDstep", "fhCorrPtZgSDstep", 16, 0, 160, 20, 0., 0.5, 20, 0, 20);
245 
246  fhCorrPtRgSDstep = new TH3F("fhCorrPtRgSDstep", "fhCorrPtRgSDstep", 16, 0, 160, 20, 0., 0.5, 20, 0, 20);
248 
249  fhCorrPtPtfrac = new TH2F("fhCorrPtPtfrac", "#deltap_{T}; p_{T}^{corr} [GeV/c]; #deltap_{T}", 16, 0, 160, 80, 0., 1.0);
250  fOutput->Add(fhCorrPtPtfrac);
251 
252  fhCorrPtDropCount = new TH2F("fhCorrPtDropCount", "fhCorrPtDropCount; p_{T}^{corr} [GeV/c]; Counts", 16, 0, 160, 50, 0., 50);
254 
255  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
256 }
257 
258 //________________________________________________________________________
260 {
261  // Fill histograms.
262 
263  if (fTracksCont) {
265  fTracksCont->ResetCurrentID();
266  AliVTrack *track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle());
267  while(track) {
268  fHistTracksPt[fCentBin]->Fill(track->Pt());
269  track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle());
270 
271  }
272  }
273 
274  if (fCaloClustersCont) {
275  AliVCluster *cluster = fCaloClustersCont->GetNextAcceptCluster();
276  while(cluster) {
277  TLorentzVector nPart;
278  cluster->GetMomentum(nPart, fVertex);
279  fHistClustersPt[fCentBin]->Fill(nPart.Pt());
280  Double_t dx = cluster->GetTrackDx();
281  Double_t dz = cluster->GetTrackDz();
282  fHistClustDx->Fill(dx);
283  fHistClustDz->Fill(dz);
285  }
286  }
287 
288  if (fJetsCont) {
289  Int_t count = 0;
290  for (auto jet : fJetsCont->accepted() ) {
291  count++;
292  fHistJetsPtArea[fCentBin]->Fill(jet->Pt(), jet->Area());
293  fHistJetsPhiEta[fCentBin]->Fill(jet->Eta(), jet->Phi());
294 
295  Float_t ptLeading = fJetsCont->GetLeadingHadronPt(jet);
296  fHistJetsPtLeadHad[fCentBin]->Fill(jet->Pt(), ptLeading);
297 
299  Float_t corrPt = jet->Pt() - fJetsCont->GetRhoVal() * jet->Area();
300  fHistJetsCorrPtArea[fCentBin]->Fill(corrPt, jet->Area());
301  }
302 
303  Double_t jetpt_ungrmd = jet->Pt() / ( jet->GetShapeProperties()->GetSoftDropPtfrac() );
304 
305  std::vector<fastjet::PseudoJet> particles;
306  UShort_t ntracks = jet->GetNumberOfTracks();
307  for (int j = 0; j < ntracks; j++) {
308  particles.push_back( fastjet::PseudoJet( jet->Track(j)->Px(), jet->Track(j)->Py(), jet->Track(j)->Pz(), jet->Track(j)->E() ) );
309  }
310  fastjet::JetDefinition jet_def(fastjet::cambridge_algorithm, 0.4, fastjet::E_scheme);
311  fastjet::ClusterSequence cs(particles, jet_def);
312  std::vector<fastjet::PseudoJet> jets = sorted_by_pt(cs.inclusive_jets());
313 
314  if (jets.size() > 0) {
315  fSDM = 0;
316  SoftDropDeepDeclustering( jets[0], jets[0].pt() );
317  fhCorrPtZg2->Fill( jets[0].pt(), SoftDropDeclustering(jets[0], 0.5, 1.5) );
318  }
319 
320  fhZg->Fill(jet->GetShapeProperties()->GetSoftDropZg());
321  fhCorrPtZg->Fill(jetpt_ungrmd - fJetsCont->GetRhoVal() * jet->Area(), jet->GetShapeProperties()->GetSoftDropZg() );
322  fhCorrPtRg->Fill(jetpt_ungrmd - fJetsCont->GetRhoVal() * jet->Area(), jet->GetShapeProperties()->GetSoftDropdR() );
323  fhCorrPtPtfrac->Fill(jetpt_ungrmd - fJetsCont->GetRhoVal() * jet->Area(), jet->GetShapeProperties()->GetSoftDropPtfrac() );
324  fhCorrPtDropCount->Fill(jetpt_ungrmd - fJetsCont->GetRhoVal() * jet->Area(), jet->GetShapeProperties()->GetSoftDropDropCount() );
325  }
326  fNAccJets->Fill(count);
327  auto jet = (AliEmcalJet*)fJetsCont->GetLeadingJet();
328  if(jet) fHistLeadingJetPt[fCentBin]->Fill(jet->Pt());
329  }
330 
332 
333  return kTRUE;
334 }
335 
336 //________________________________________________________________________
338 {
339 
341  return;
342 
343  Double_t deta = 999;
344  Double_t dphi = 999;
345 
346  //Get closest cluster to track
347  AliVTrack *track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle());
348  while(track) {
349  //Get matched cluster
350  Int_t emc1 = track->GetEMCALcluster();
351  if(fCaloClustersCont && emc1>=0) {
352  AliVCluster *clusMatch = fCaloClustersCont->GetCluster(emc1);
353  if(clusMatch) {
354  AliPicoTrack::GetEtaPhiDiff(track, clusMatch, dphi, deta);
355  fHistPtDEtaDPhiTrackClus->Fill(track->Pt(),deta,dphi);
356  }
357  }
358  track = static_cast<AliVTrack*>(fTracksCont->GetNextAcceptParticle());
359  }
360 
361  //Get closest track to cluster
362  AliVCluster *cluster = fCaloClustersCont->GetNextAcceptCluster();
363  while(cluster) {
364  TLorentzVector nPart;
365  cluster->GetMomentum(nPart, fVertex);
366  fHistClustersPt[fCentBin]->Fill(nPart.Pt());
367 
368  //Get matched track
369  AliVTrack *mt = NULL;
370  AliAODCaloCluster *acl = dynamic_cast<AliAODCaloCluster*>(cluster);
371  if(acl) {
372  if(acl->GetNTracksMatched()>1)
373  mt = static_cast<AliVTrack*>(acl->GetTrackMatched(0));
374  }
375  else {
376  AliESDCaloCluster *ecl = dynamic_cast<AliESDCaloCluster*>(cluster);
377  Int_t im = ecl->GetTrackMatchedIndex();
378  if(fTracksCont && im>=0) {
379  mt = static_cast<AliVTrack*>(fTracksCont->GetParticle(im));
380  }
381  }
382  if(mt) {
383  AliPicoTrack::GetEtaPhiDiff(mt, cluster, dphi, deta);
384  fHistPtDEtaDPhiClusTrack->Fill(nPart.Pt(),deta,dphi);
385 
386  /* //debugging
387  if(mt->IsEMCAL()) {
388  Int_t emc1 = mt->GetEMCALcluster();
389  Printf("current id: %d emc1: %d",fCaloClustersCont->GetCurrentID(),emc1);
390  AliVCluster *clm = fCaloClustersCont->GetCluster(emc1);
391  AliPicoTrack::GetEtaPhiDiff(mt, clm, dphi, deta);
392  Printf("deta: %f dphi: %f",deta,dphi);
393  }
394  */
395  }
397  }
398 }
399 
400 void AliAnalysisTaskSoftDrop::SoftDropDeepDeclustering(fastjet::PseudoJet jet, const Float_t inpt) {
401 
402  fastjet::PseudoJet jet1;
403  fastjet::PseudoJet jet2;
404 
405  if ( jet.has_parents(jet1, jet2) ) {
406 
407  Float_t pt1 = jet1.pt();
408  Float_t pt2 = jet2.pt();
409 
410  Float_t dr = TMath::Sqrt( jet1.plain_distance(jet2) );
411 
412  Float_t z;
413  if (pt1 < pt2) z = pt1/(pt1+pt2);
414  else z = pt2/(pt1+pt2);
415 
416  if (z > 0.1) {
417  fSDM++;
418  fhCorrPtZgD->Fill(inpt, z);
419  fhCorrPtRgD->Fill(inpt, dr);
420  fhCorrPtZgSDstep->Fill(inpt, z, fSDM);
421  fhCorrPtRgSDstep->Fill(inpt, dr, fSDM);
422  }
423 
424  if (pt1 > pt2) SoftDropDeepDeclustering(jet1, inpt);
425  else SoftDropDeepDeclustering(jet2, inpt);
426 
427  }
428 
429 }
430 
431 Float_t AliAnalysisTaskSoftDrop::SoftDropDeclustering(fastjet::PseudoJet jet, const Float_t zcut, const Float_t beta) {
432 
433  fastjet::PseudoJet jet1;
434  fastjet::PseudoJet jet2;
435 
436  if ( !(jet.has_parents(jet1, jet2)) ) {
437  return 0.0;
438  }
439  else {
440  Float_t pt1 = jet1.pt();
441  Float_t pt2 = jet2.pt();
442 
443  Float_t dr = TMath::Sqrt( jet1.plain_distance(jet2) );
444  Float_t angular_term = TMath::Power(dr/0.4, beta);
445 
446  Float_t z;
447  if (pt1 < pt2) z = pt1/(pt1+pt2);
448  else z = pt2/(pt1+pt2);
449 
450  if ( z > (zcut*angular_term) ) return z;
451  else {
452  if (pt1 > pt2) return SoftDropDeclustering(jet1, zcut, beta);
453  else return SoftDropDeclustering(jet2, zcut, beta);
454  }
455  }
456 
457 }
458 
459 //________________________________________________________________________
461 
463 
464  if (fJetsCont && fJetsCont->GetArray() == 0) fJetsCont = 0;
465  if (fTracksCont && fTracksCont->GetArray() == 0) fTracksCont = 0;
466  if (fCaloClustersCont && fCaloClustersCont->GetArray() == 0) fCaloClustersCont = 0;
467 
468 }
469 
470 //________________________________________________________________________
472 {
473  // Run analysis code here, if needed. It will be executed before FillHistograms().
474 
475  return kTRUE; // If return kFALSE FillHistogram() will NOT be executed.
476 }
477 
478 //________________________________________________________________________
480 {
481  // Called once at the end of the analysis.
482 }
TH2 * fhCorrPtZgD
! iterative SD, distribution of zg, jet pt-diff
TObjArray fClusterCollArray
cluster collection array
AliClusterContainer * fCaloClustersCont
Tracks.
virtual AliVParticle * GetNextAcceptParticle()
Double_t GetRhoVal() const
double Double_t
Definition: External.C:58
Definition: External.C:260
Definition: External.C:236
AliJetContainer * GetJetContainer(Int_t i=0) const
TH2 * fhCorrPtRgD
! iterative SD, distribution of Rg, jet pt-diff
const TString & GetRhoName(Int_t c=0) const
TH3 * fhCorrPtZgSDstep
! iterative SD, distribution of zg, jet pt-diff, SD step diff
void SoftDropDeepDeclustering(fastjet::PseudoJet jet, const Float_t inpt)
TH3 * fHistPtDEtaDPhiClusTrack
track pt, delta eta, delta phi to matched cluster
Double_t fMinBinPt
min pt in histograms
AliClusterContainer * GetClusterContainer() const
Int_t fCentBin
!event centrality bin
TH1 ** fHistLeadingJetPt
Cluster pt spectrum.
TH1 ** fHistNTracks
cluster pt, delta eta, delta phi to matched track
TObjArray fParticleCollArray
particle/track collection array
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Get particle container attached to this task.
AliParticleContainer * GetParticleContainer() const
TH2 ** fHistJetsPtArea
Phi-Eta distribution of jets.
AliEmcalJet * GetLeadingJet(const char *opt="")
TH2 * fhCorrPtRg
! distribution of groomed jet radius, jet pt-diff
int Int_t
Definition: External.C:63
Double_t GetLeadingHadronPt(const AliEmcalJet *jet) const
float Float_t
Definition: External.C:68
void Terminate(Option_t *option)
virtual AliVParticle * GetParticle(Int_t i=-1) const
TH2 * fhCorrPtDropCount
! distribution of dropped branches number, jet pt-diff
Int_t fNcentBins
how many centrality bins
TH2 * fhCorrPtZg
! distribution of zg, jet pt-diff
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Get cluster container attached to this task.
TH2 ** fHistJetsCorrPtArea
Jet pt vs. leading hadron.
TH1 * fhZg
number of jets per event
AliParticleContainer * fTracksCont
Jets.
AliVCluster * GetCluster(Int_t i) const
TObjArray fJetCollArray
jet collection array
Bool_t FillHistograms()
Function filling histograms.
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.
Int_t fSDM
number of the SD iterations
AliEmcalList * fOutput
!output list
Double_t fMaxBinPt
max pt in histograms
TH1 * fHistClustDx
number of tracks per event
Definition: External.C:220
TH2 ** fHistJetsPhiEta
Leading jet pt spectrum.
Double_t fVertex[3]
!event vertex
TH2 * fhCorrPtPtfrac
! distribution of ptfrac, jet pt-diff
TH2 * fhCorrPtZg2
! other SD settings
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
unsigned short UShort_t
Definition: External.C:28
const char Option_t
Definition: External.C:48
TH1 ** fHistClustersPt
Track pt spectrum.
void UserCreateOutputObjects()
Main initialization function on the worker.
static void GetEtaPhiDiff(const AliVTrack *t, const AliVCluster *v, Double_t &phidiff, Double_t &etadiff)
const AliJetIterableContainer accepted() const
bool Bool_t
Definition: External.C:53
TH3 * fHistPtDEtaDPhiTrackClus
Jet pt - bkg vs. area.
Int_t GetNAcceptedParticles() const
void ExecOnce()
Perform steps needed to initialize the analysis.
static Float_t SoftDropDeclustering(fastjet::PseudoJet jet, const Float_t zcut, const Float_t beta)
AliVCluster * GetNextAcceptCluster()
TH2 ** fHistJetsPtLeadHad
Jet pt vs. area.
Definition: External.C:196
Int_t fNbins
no. of pt bins
TH3 * fhCorrPtRgSDstep
! iterative SD, distribution of zg, jet pt-diff, SD step diff