AliPhysics  master (3d17d9d)
AliAnalysisTaskSDKL.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 <THnSparse.h>
6 //#include <TTree.h>
7 #include <TNtuple.h>
8 #include <TList.h>
9 //#include <TLorentzVector.h>
10 
11 #include "AliVCluster.h"
12 #include "AliVTrack.h"
13 #include "AliAODMCParticle.h"
14 #include "AliEmcalJet.h"
15 #include "AliRhoParameter.h"
16 #include "AliLog.h"
17 #include "AliJetContainer.h"
18 #include "AliParticleContainer.h"
19 
20 #include "AliAnalysisManager.h"
21 #include "AliAnalysisTaskSDKL.h"
22 
23 ClassImp(AliAnalysisTaskSDKL)
24 
25 //________________________________________________________________________
27  AliAnalysisTaskEmcalJet(name, kTRUE),
28  fhAll(0),
29  fhAllBackSub(0),
30  fhRho(0),
31  fhRhoSparse(0),
32  fTree(0),
33  fTreeBackSub(0),
34  fJetsCont(0),
35  fTracksCont(0),
36  fbcoption(0),
37  fCSOption(0),
38  fCSubtractor(0),
39  fCSubtractorCS(0)
40 {
41  // Default constructor.
42  // SetMakeGeneralHistograms(kTRUE);
43 }
44 
45 //________________________________________________________________________
46 AliAnalysisTaskSDKL::AliAnalysisTaskSDKL(const char *name, Int_t const backgroption) :
47  AliAnalysisTaskEmcalJet(name, kTRUE),
48  fhAll(0),
49  fhAllBackSub(0),
50  fhRho(0),
51  fhRhoSparse(0),
52  fTree(0),
53  fTreeBackSub(0),
54  fJetsCont(0),
55  fTracksCont(0),
56  fbcoption(backgroption),
57  fCSOption(0),
58  fCSubtractor(0),
59  fCSubtractorCS(0)
60 {
61  // Standard constructor.
62  // SetMakeGeneralHistograms(kTRUE);
63  DefineOutput(2, TTree::Class());
64 }
65 
66 //________________________________________________________________________
68 {
69  // Destructor.
70  if (fTree) delete fTree;
71  if (fTreeBackSub) delete fTreeBackSub;
72 }
73 
75  const char *ntracks,
76  const char *njets,
77  const char *nrho,
79  Double_t jetradius,
80  Double_t jetptcut,
81  Double_t jetareacut,
82  const char *type,
83  Int_t backgroption,
84  Int_t leadhadtype,
85  const char *taskname
86 )
87 {
88  // Get the pointer to the existing analysis manager via the static access method.
89  //==============================================================================
90  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
91  if (!mgr)
92  {
93  ::Error("AddTaskEmcalJetSample", "No analysis manager to connect to.");
94  return NULL;
95  }
96 
97  // Check the analysis type using the event handlers connected to the analysis manager.
98  //==============================================================================
99  if (!mgr->GetInputEventHandler())
100  {
101  ::Error("AddTaskEmcalJetSample", "This task requires an input event handler");
102  return NULL;
103  }
104 
105  //-------------------------------------------------------
106  // Init the task and do settings
107  //-------------------------------------------------------
108 
109  TString trackName(ntracks);
110 
111  TString name(taskname);
112  if (strcmp(njets,"")) {
113  name += "_";
114  name += njets;
115  }
116  if (strcmp(nrho,"")) {
117  name += "_";
118  name += nrho;
119  }
120  if (strcmp(type,"")) {
121  name += "_";
122  name += type;
123  }
124 
125  Printf("name: %s",name.Data());
126 
127  AliAnalysisTaskSDKL* jetTask = new AliAnalysisTaskSDKL(name, backgroption);
128  //jetTask->SetCentRange(0.,100.);
129  //jetTask->SetNCentBins(nCentBins);
130  //AliMultSelection *multSelection = static_cast<AliMultSelection*>(fAOD->FindListObject("MultSelection"));
131  //if(multSelection) centrality = multSelection->GetMultiplicityPercentile("V0M");
132 
133  AliParticleContainer* partCont = 0;
134  if (trackName == "mcparticles") {
135  partCont = jetTask->AddMCParticleContainer("mcparticles");
136  }
137  else if (trackName == "usedefault" || trackName == "tracks" || trackName == "Tracks") {
138  partCont = jetTask->AddTrackContainer("tracks");
139  }
140 // else if (!trackName.IsNull()) {
141 // partCont = new AliParticleContainer(trackName);
142 // }
143 
144  TString strType(type);
145  AliJetContainer *jetCont = jetTask->AddJetContainer(njets,strType,jetradius);
146  if(jetCont) {
147  jetCont->SetRhoName(nrho);
148 // jetCont->ConnectParticleContainer(partCont);
149 // jetCont->SetZLeadingCut(0.98,0.98);
150  jetCont->SetPercAreaCut(jetareacut);
151  jetCont->SetJetPtCut(jetptcut);
152  jetCont->SetLeadingHadronType(leadhadtype);
153  }
154 
155  //-------------------------------------------------------
156  // Final settings, pass to manager and set the containers
157  //-------------------------------------------------------
158 
159  mgr->AddTask(jetTask);
160 
161  // Create containers for input/output
162  AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer() ;
163  TString contname1(name);
164  contname1 += "_histos";
165  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contname1.Data(),
166  TList::Class(),AliAnalysisManager::kOutputContainer,
167  Form("%s", AliAnalysisManager::GetCommonFileName()));
168 
169  TString contname2(name);
170  contname2 += "_tree";
171  AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(contname2.Data(),
172  TTree::Class(),AliAnalysisManager::kOutputContainer,
173  Form("%s", AliAnalysisManager::GetCommonFileName()));
174 
175  mgr->ConnectInput (jetTask, 0, cinput1 );
176  mgr->ConnectOutput (jetTask, 1, coutput1 );
177  mgr->ConnectOutput (jetTask, 2, coutput2 );
178 
179  return jetTask;
180 }
181 
182 //________________________________________________________________________
184 {
185  // Create user output.
186 
188 
189  const Int_t nzgbins = 10;
190  Double_t zg_min = 0.0;
191  Double_t zg_max = 0.5;
192 
193  const Int_t nrgbins = 10;
194  Double_t rg_min = 0.0;
195  Double_t rg_max = 0.4;
196 
197  const Int_t nmgbins = 10;
198  Double_t mg_min = 0.0;
199  Double_t mg_max = 0.3;
200 
201  //pt n_sd nsteps_1 zg1 rg1 mg1 zg2 rg2 mg2 zg3 rg3 mg3 zg4 rg4 mg4
202  Int_t bins[15] = {15, 10, 10, nzgbins, nrgbins, nmgbins, nzgbins, nrgbins, nmgbins, nzgbins, nrgbins, nmgbins, nzgbins, nrgbins, nmgbins};
203  Double_t xmin[15] = {0., 0, 0, zg_min, rg_min, mg_min, zg_min, rg_min, mg_min, zg_min, rg_min, mg_min, zg_min, rg_min, mg_min};
204  Double_t xmax[15] = {150., 10, 10, zg_max, rg_max, mg_max, zg_max, rg_max, 0.2, zg_max, 0.3, 0.1, zg_max, 0.3, 0.1};
205  fhAll = new THnSparseD("hAll", "hAll", 15, bins, xmin, xmax);
206  fOutput->Add(fhAll);
207 
208  fhAllBackSub = new THnSparseD("hAllBackSub", "hAllBackSub", 15, bins, xmin, xmax);
209  fOutput->Add(fhAllBackSub);
210 
211  fhRho = new TH1F("fhRho","fhRho",1000,0,1000);
212  fOutput->Add(fhRho);
213 
214  fhRhoSparse = new TH1F("fhRhoSparse","fhRhoSparse",1000,0,1000);
215  fOutput->Add(fhRhoSparse);
216 
217  fTree = new TNtuple("JetTrackTree", "jet track tree", "pt:eta:phi:jetm");
218 // fOutput->Add(fTree);
219 
220  fTreeBackSub = new TNtuple("JetTrackTreeBackSub", "jet track tree back sub", "pt:eta:phi:jetm");
221  PostData(2, fTreeBackSub);
222 
223  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
224 
225 }
226 
227 //________________________________________________________________________
229  // Fill histograms.
230  float max_jet_pt = 0.0;
231 
232  if (fJetsCont) {
233  for (auto jet : fJetsCont->accepted()) {
234  auto jet_pt = jet->Pt();
235  if (jet_pt > max_jet_pt) max_jet_pt = jet_pt;
236  //hard-coded jet pt cut
237  if (jet_pt < 10.) continue;
238  std::vector<split> splits = ReclusterFindHardSplits(jet);
239  FillSparseFromSplits( fhAll, splits, jet_pt );
240  }
241  }
242 
243  //hardest jet is too soft
244  if (max_jet_pt < 10.) return kTRUE;
245 
246  //tighter cut for AA
247  if ( (1==fbcoption) && (max_jet_pt < 20.) ) return kTRUE;
248 
249  //fill full event
250  std::vector <fastjet::PseudoJet> event_full;
251  AddTracksToEvent(fTracksCont, event_full);
252 
253  //get backgr-subtracted jets
254  Double_t rho;
255  Double_t rho_sparse;
256  InitializeSubtractor(event_full, rho, rho_sparse, fbcoption);
257  fhRho->Fill(rho);
258  fhRhoSparse->Fill(rho_sparse);
259 
260  std::vector<fastjet::PseudoJet> jets_backsub = GetBackSubJets(event_full);
261 
262  std::vector<fastjet::PseudoJet> jets_backsub_filtered;
263  for (auto jet : jets_backsub) {
264  auto jet_pt = jet.pt();
265  if (jet_pt < 10.) continue;
266  if ( jet.has_area() ) {
267  auto jarea = jet.area_4vector().perp();
268  auto area_nominal = TMath::Pi() * 0.4 * 0.4;
269  if (jarea < (0.6 * area_nominal)) continue;
270  }
271  jets_backsub_filtered.push_back(jet);
272  }
273 
274  //analyze back sub jets
275  for (auto jet : jets_backsub_filtered) {
276  std::vector<split> splits = ReclusterFindHardSplits(jet);
277  FillSparseFromSplits( fhAllBackSub, splits, jet.pt() );
278  }
279 
280  FillTree(jets_backsub_filtered, fTreeBackSub);
281 
282  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
283 
284  event_full.clear();
285  jets_backsub.clear();
286 
287  if (fCSubtractor) delete fCSubtractor;
288  if (fCSubtractorCS) delete fCSubtractorCS;
289 
290  fCSubtractor = 0;
291  fCSubtractorCS = 0;
292 
293  return kTRUE;
294 }
295 
296 std::vector<fastjet::PseudoJet> AliAnalysisTaskSDKL::GetBackSubJets(std::vector <fastjet::PseudoJet> const & event_full) {
297 
298  fastjet::Selector sel_jets = fastjet::SelectorAbsEtaMax(0.9 - 0.4); //max_eta_jet
299  fastjet::JetDefinition jet_def(fastjet::antikt_algorithm, 0.4, fastjet::E_scheme);
300  fastjet::AreaDefinition area_def( fastjet::active_area_explicit_ghosts, fastjet::GhostedAreaSpec(0.9,1) ); //0.9 -> max_eta
301 
302  std::vector<fastjet::PseudoJet> jets_backsub;
303 
304  if (fCSubtractor) {
305 
306  if (0 == fCSOption) { //full event: subtract then cluster
307  std::vector<fastjet::PseudoJet> event_backsub = fCSubtractor->subtract_event(event_full, 0.9);
308  fCSubtractorCS = new fastjet::ClusterSequenceArea(event_backsub, jet_def, area_def);
309  jets_backsub = sel_jets( fCSubtractorCS->inclusive_jets() );
310  }
311  else if (1 == fCSOption) { //jet-by-jet: cluster then subtract
312  fCSubtractorCS = new fastjet::ClusterSequenceArea(event_full, jet_def, area_def);
313  std::vector<fastjet::PseudoJet> jets_full = sel_jets( fCSubtractorCS->inclusive_jets() );
314  for (auto j : jets_full) {
315  jets_backsub.push_back( fCSubtractor->result(j) );
316  }
317  }
318 
319  }
320 
321  return jets_backsub;
322 
323 }
324 
326 
327  std::vector <fastjet::PseudoJet> particles;
328  UShort_t ntracks = jet->GetNumberOfTracks();
329  for (int j = 0; j < ntracks; j++) {
330  particles.push_back(fastjet::PseudoJet(jet->Track(j)->Px(), jet->Track(j)->Py(), jet->Track(j)->Pz(), jet->Track(j)->E()));
331  }
332 
333  return ReclusterFindHardSplits(particles);
334 
335 }
336 
337 std::vector<split> AliAnalysisTaskSDKL::ReclusterFindHardSplits(fastjet::PseudoJet const & jet) {
338 
339  //remove ghost particles
340  std::vector <fastjet::PseudoJet> particles;
341  for (auto constituent : jet.constituents() ) {
342  if ( constituent.perp() > 1.e-5 ) particles.push_back( constituent );
343  }
344 
345  return ReclusterFindHardSplits(particles);
346 
347 }
348 
349 std::vector<split> AliAnalysisTaskSDKL::ReclusterFindHardSplits(std::vector <fastjet::PseudoJet> const & particles) {
350 
351  fastjet::JetDefinition jet_def(fastjet::cambridge_algorithm, 0.4, fastjet::E_scheme); //scheme
352  fastjet::ClusterSequence cs(particles, jet_def);
353  std::vector <fastjet::PseudoJet> jets = sorted_by_pt(cs.inclusive_jets());
354 
355  std::vector<split> splits;
356  if (jets.size() > 0) {
357  splits = FindHardSplits( jets[0] );
358  }
359 
360  return splits;
361 
362 }
363 
364 std::vector<split> AliAnalysisTaskSDKL::FindHardSplits(fastjet::PseudoJet const & jet) {
365 
366  auto hardest_subjet = jet;
367 
368  fastjet::PseudoJet jet1;
369  fastjet::PseudoJet jet2;
370 
371  std::vector<split> splits;
372 
373  int sd_step = 0;
374 
375  while ( hardest_subjet.has_parents(jet1, jet2) ) {
376 
377  sd_step++;
378  hardest_subjet = jet1;
379 
380  Float_t pt1 = jet1.pt();
381  Float_t pt2 = jet2.pt();
382 
383  Float_t z = pt2/(pt1 + pt2);
384  Float_t r = TMath::Sqrt( jet1.plain_distance(jet2) );
385  Float_t m = hardest_subjet.m();
386 
387  if (z > 0.1) {
388  splits.push_back( split{z,r,m,sd_step} );
389  }
390 
391  }
392 
393  return splits;
394 
395 }
396 
397 
398 void AliAnalysisTaskSDKL::FillSparseFromSplits(THnSparse *histo, std::vector<split> const & splits, const double jet_pt) {
399 
400  int nsd = splits.size();
401 
402  float zg[4] = {0.0};
403  float rg[4] = {0.0};
404  float mg[4] = {-1.0};
405  int sd_step[4] = {0};
406  for (int i = 0; (i < 4) && (i < nsd); i++) {
407  zg[i] = splits[i].z;
408  rg[i] = splits[i].r;
409  mg[i] = splits[i].m;
410  sd_step[i] = splits[i].sd_step;
411  }
412 
413  //pt n_sd nsteps_1 zg1 rg1 mg1 zg2 rg2 mg2 zg3 rg3 mg3 zg4 rg4 mg4
414  Double_t xvalue[15];
415  xvalue[0] = jet_pt;
416  xvalue[1] = splits.size();
417 
418  xvalue[2] = sd_step[0]; //for the moment nsd_steps only for the first split
419 
420  xvalue[3] = zg[0];
421  xvalue[4] = rg[0];
422  xvalue[5] = mg[0]/jet_pt;
423 
424  xvalue[6] = zg[1];
425  xvalue[7] = rg[1];
426  xvalue[8] = mg[1]/jet_pt;
427 
428  xvalue[9] = zg[2];
429  xvalue[10] = rg[2];
430  xvalue[11] = mg[2]/jet_pt;
431 
432  xvalue[12] = zg[3];
433  xvalue[13] = rg[3];
434  xvalue[14] = mg[3]/jet_pt;
435 
436  histo->Fill( xvalue );
437 
438 }
439 
440 int AliAnalysisTaskSDKL::InitializeSubtractor(std::vector <fastjet::PseudoJet> const & event_full, Double_t & rho, Double_t & rho_sparse, Int_t opt) {
441 
442  double max_eta = 0.9;
443  double max_eta_jet = 0.5;
444 
445  fastjet::Selector sel_jets = fastjet::SelectorAbsEtaMax(max_eta_jet);
446 
447  fastjet::AreaDefinition area_def(fastjet::active_area_explicit_ghosts, fastjet::GhostedAreaSpec(max_eta, 1));
448 
449  fastjet::JetDefinition jet_def_kt(fastjet::kt_algorithm, 0.4);
450  fastjet::ClusterSequenceArea cs_kt(event_full, jet_def_kt, area_def);
451  std::vector <fastjet::PseudoJet> jets_kt = sorted_by_pt(sel_jets(cs_kt.inclusive_jets()));
452 
453  std::vector <fastjet::PseudoJet> jets_akt;
454  if (0 == opt) {
455  fastjet::JetDefinition jet_def_akt(fastjet::antikt_algorithm, 0.4);
456  fastjet::ClusterSequenceArea cs_akt(event_full, jet_def_akt, area_def);
457  jets_akt = sorted_by_pt(sel_jets(cs_akt.inclusive_jets()));
458  }
459 
460  //option 0 (pPb)
461  //tag matched kt-antikt jets
462  if (0 == opt) {
463  for (auto jet_akt : jets_akt) {
464  auto jet_akt_pt = jet_akt.perp();
465  if (jet_akt_pt < 5.) continue;
466  for (auto jet_kt : jets_kt) {
467  auto dist = jet_akt.delta_R(jet_kt);
468  if (dist < 0.4 * 0.6) {
469  jet_kt.set_user_index(7); //tagging kt jets matched to anti-kt
470  }
471  }
472  }
473  jets_akt.clear();
474  }
475 
476  //option 1 (PbPb)
477  //exclude two hardest kt jets
478  if (1 == opt) {
479  if (jets_kt.size() < 3) return 1; //vector of kt-jets has only 2 elements
480  else {
481  jets_kt[0].set_user_index(7);
482  jets_kt[1].set_user_index(7);
483  }
484  }
485 
486  std::vector <fastjet::PseudoJet> jets_kt_for_estimator;
487 
488  std::vector <Double_t> vec_pt_area;
489  Double_t area_sum = 0.0;
490  for (auto jet : jets_kt) {
491 
492  if ( 7==jet.user_index() ) continue;
493 
494  //exclude ghost-only jets
495  if ( jet.has_area() && (jet.pt() > 0.001) ) {
496  auto jarea = jet.area_4vector().perp();
497  if (jarea > 0) {
498  vec_pt_area.push_back( jet.perp() / jarea ); //test
499  area_sum += jarea;
500  }
501  }
502 
503  }
504 
505  sort( vec_pt_area.begin(), vec_pt_area.end() );
506  auto size_vec_pt_area = vec_pt_area.size();
507  if (size_vec_pt_area > 0) {
508  if (size_vec_pt_area % 2 == 0) {
509  rho = (vec_pt_area[size_vec_pt_area / 2 - 1] + vec_pt_area[size_vec_pt_area / 2]) / 2.0;
510  } else {
511  rho = vec_pt_area[size_vec_pt_area / 2];
512  }
513  }
514  vec_pt_area.clear();
515 
516  Double_t const full_acceptance = 2.0 * 0.9 * 2.0 * TMath::Pi();
517  auto acc_correction = area_sum/full_acceptance;
518 
519  rho_sparse = rho * acc_correction;
520 
521  if (rho > 0.001 && rho_sparse > 0.001) {
522  //provide external rho and rhom
523  Double_t rho_C;
524  if (0==opt) rho_C = rho_sparse; //pA
525  else rho_C = rho; //AA
526  Double_t const rho_m_C = 0.0; //massless tracks
527  fCSubtractor = new fastjet::contrib::ConstituentSubtractor(rho_C, rho_m_C, 0.0, 0.25);
528  fCSubtractor->set_max_standardDeltaR(0.25);
529  fCSubtractor->set_alpha(0.0);
530  fCSubtractor->set_ghost_area(0.01);
531  return 0;
532  }
533  else return 1;
534 
535 }
536 
537 void AliAnalysisTaskSDKL::AddTracksToEvent(AliParticleContainer* cont, std::vector <fastjet::PseudoJet> & event) {
538 
539  if (cont) {
540  cont->ResetCurrentID();
541  for ( auto track : cont->accepted() ) {
542  Double_t track_p[3];
543  track->PxPyPz(track_p);
544  Double_t ptot = sqrt( track_p[0]*track_p[0] + track_p[1]*track_p[1] + track_p[2]*track_p[2] );
545  fastjet::PseudoJet pj(track_p[0], track_p[1], track_p[2], ptot); //massless particle
546  pj.set_user_index( track->GetLabel() );
547  event.push_back( pj );
548  }
549  }
550 
551 }
552 
553 void AliAnalysisTaskSDKL::FillTree(std::vector<fastjet::PseudoJet> const & jets, TNtuple* tree) {
554 
555  for (auto jet : jets) {
556 
557  if ( jet.pt() < 30. ) continue; //hard-coded jet-pt cut
558 
559  int nconst = 0;
560  for (auto c : jet.constituents() ) {
561  if ( c.pt() > 1.e-5 ) nconst++;
562  }
563  tree->Fill(jet.pt(), jet.eta(), jet.phi(), nconst);
564  for (auto c : jet.constituents() ) {
565  if ( c.pt() > 1.e-5 ) {
566  tree->Fill(c.pt(), c.eta(), c.phi(), -7);
567  }
568  }
569 
570  }
571 
572 }
573 
575 
576  if (jets) {
577  for (auto jet : jets->accepted()) {
578 
579  if ( jet->Pt() < 30. ) continue;
580  UShort_t ntracks = jet->GetNumberOfTracks();
581  tree->Fill(jet->Pt(), jet->Eta(), jet->Phi(), ntracks);
582  for (int j = 0; j < ntracks; j++) {
583  auto jtrack = jet->Track(j);
584  if (jtrack->Pt() > 1.e-5) {
585  tree->Fill(jtrack->Pt(), jtrack->Eta(), jtrack->Phi(), -7);
586  }
587  }
588 
589  }
590  }
591 
592 }
593 
594 //________________________________________________________________________
596 
598 
601 
602 // TString trackName(ntracks);
603 // if (trackName == "mcparticles") {
604 // fTracksCont->SetClassName("AliAODMCParticle");
605 // }
606 // else if (trackName == "usedefault" || trackName == "tracks" || trackName == "Tracks") {
607  fTracksCont->SetClassName("AliVTrack");
608 // }
609 
610  if (fJetsCont && fJetsCont->GetArray() == 0) fJetsCont = 0;
611  if (fTracksCont && fTracksCont->GetArray() == 0) fTracksCont = 0;
612 
613 }
614 
615 //________________________________________________________________________
617 {
618  // Run analysis code here, if needed. It will be executed before FillHistograms().
619 
620  return kTRUE; // If return kFALSE FillHistogram() will NOT be executed.
621 }
622 
623 //________________________________________________________________________
625 {
626  // Called once at the end of the analysis.
627 }
AliAnalysisTaskSDKL(const char *name="AliAnalysisTaskSDKL")
double Double_t
Definition: External.C:58
Bool_t FillHistograms()
Function filling histograms.
AliJetContainer * GetJetContainer(Int_t i=0) const
void SetLeadingHadronType(Int_t t)
std::vector< split > FindHardSplits(fastjet::PseudoJet const &jet)
AliVParticle * Track(Int_t idx) const
TCanvas * c
Definition: TestFitELoss.C:172
void Terminate(Option_t *option)
void SetPercAreaCut(Float_t p)
Int_t nCentBins
fastjet::ClusterSequenceArea * fCSubtractorCS
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.
Container for particles within the EMCAL framework.
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:139
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Get particle container attached to this task.
void SetRhoName(const char *n)
void AddTracksToEvent(AliParticleContainer *cont, std::vector< fastjet::PseudoJet > &event)
int Int_t
Definition: External.C:63
void SetJetPtCut(Float_t cut)
float Float_t
Definition: External.C:68
int InitializeSubtractor(std::vector< fastjet::PseudoJet > const &event_full, Double_t &rho, Double_t &rho_sparse, Int_t opt=0)
void FillSparseFromSplits(THnSparse *histo, std::vector< split > const &splits, double const jet_pt)
TClonesArray * GetArray() const
std::vector< split > ReclusterFindHardSplits(AliEmcalJet *jet)
THnSparse * fhAll
! distribution of all
void SetClassName(const char *clname)
static AliAnalysisTaskSDKL * AddTaskSoftDrop(const char *ntracks="usedefault", const char *njets="Jets", const char *nrho="Rho", Int_t nCentBins=1, Double_t jetradius=0.4, Double_t jetptcut=1, Double_t jetareacut=0.6, const char *type="EMCAL", Int_t backgroption=0, Int_t leadhadtype=0, const char *taskname="AliAnalysisTaskSDKL")
void FillTree(std::vector< fastjet::PseudoJet > const &jets, TNtuple *tree)
THnSparse * fhAllBackSub
! distribution of all
AliEmcalList * fOutput
!output list
AliParticleContainer * fTracksCont
Jets.
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 AliParticleIterableContainer accepted() const
const char Option_t
Definition: External.C:48
void UserCreateOutputObjects()
Main initialization function on the worker.
const AliJetIterableContainer accepted() const
bool Bool_t
Definition: External.C:53
std::vector< fastjet::PseudoJet > GetBackSubJets(std::vector< fastjet::PseudoJet > const &event_full)
TTree * tree
void ResetCurrentID(Int_t i=-1)
Reset the iterator to a given index.
Container for jet within the EMCAL jet framework.
AliJetContainer * fJetsCont
void ExecOnce()
Perform steps needed to initialize the analysis.
fastjet::contrib::ConstituentSubtractor * fCSubtractor