AliPhysics  63e47e1 (63e47e1)
AliEmcalJetTask.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2016, 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 #include <vector>
17 
18 #include <TClonesArray.h>
19 #include <TMath.h>
20 #include <TRandom3.h>
21 #include <TGrid.h>
22 #include <TFile.h>
23 
24 #include <AliVCluster.h>
25 #include <AliVEvent.h>
26 #include <AliVParticle.h>
27 #include <AliEMCALGeometry.h>
28 
29 #include <AliAnalysisManager.h>
30 #include <AliVEventHandler.h>
31 #include <AliMultiInputEventHandler.h>
32 
33 #include "AliTLorentzVector.h"
34 #include "AliEmcalJet.h"
35 #include "AliEmcalParticle.h"
36 #include "AliFJWrapper.h"
37 #include "AliEmcalJetUtility.h"
38 #include "AliParticleContainer.h"
39 #include "AliClusterContainer.h"
42 
43 #include "AliEmcalJetTask.h"
44 
45 using std::cout;
46 using std::endl;
47 using std::cerr;
48 
50 ClassImp(AliEmcalJetTask);
52 
54 
61  fJetsTag(),
62  fJetType(AliJetContainer::kFullJet),
63  fJetAlgo(AliJetContainer::antikt_algorithm),
64  fRecombScheme(AliJetContainer::pt_scheme),
65  fRadius(0.4),
66  fMinJetArea(0.001),
67  fMinJetPt(1.0),
68  fJetPhiMin(-10),
69  fJetPhiMax(+10),
70  fJetEtaMin(-1),
71  fJetEtaMax(+1),
72  fGhostArea(0.005),
73  fTrackEfficiency(1.),
74  fUtilities(0),
75  fTrackEfficiencyOnlyForEmbedding(kFALSE),
76  fTrackEfficiencyFunction(nullptr),
77  fApplyArtificialTrackingEfficiency(kFALSE),
78  fRandom(0),
79  fLocked(0),
80  fFillConstituents(kTRUE),
81  fJetsName(),
82  fIsInit(0),
83  fIsPSelSet(0),
84  fIsEmcPart(0),
85  fEnableAliBasicParticleCompatibility(kFALSE),
86  fLegacyMode(kFALSE),
87  fFillGhost(kFALSE),
88  fJets(0),
89  fFastJetWrapper("AliEmcalJetTask","AliEmcalJetTask"),
90  fClusterContainerIndexMap(),
91  fParticleContainerIndexMap()
92 {
93 }
94 
100  AliAnalysisTaskEmcal(name),
101  fJetsTag("Jets"),
102  fJetType(AliJetContainer::kFullJet),
103  fJetAlgo(AliJetContainer::antikt_algorithm),
104  fRecombScheme(AliJetContainer::pt_scheme),
105  fRadius(0.4),
106  fMinJetArea(0.001),
107  fMinJetPt(1.0),
108  fJetPhiMin(-10),
109  fJetPhiMax(+10),
110  fJetEtaMin(-1),
111  fJetEtaMax(+1),
112  fGhostArea(0.005),
113  fTrackEfficiency(1.),
114  fUtilities(0),
118  fRandom(0),
119  fLocked(0),
120  fFillConstituents(kTRUE),
121  fJetsName(),
122  fIsInit(0),
123  fIsPSelSet(0),
124  fIsEmcPart(0),
126  fLegacyMode(kFALSE),
127  fFillGhost(kFALSE),
128  fJets(0),
129  fFastJetWrapper(name,name),
132 {
133 }
134 
139 {
140 }
141 
147 {
148  if (!fUtilities) fUtilities = new TObjArray();
149  if (fUtilities->FindObject(utility)) {
150  Error("AddUtility", "Jet utility %s already connected.", utility->GetName());
151  return utility;
152  }
153  fUtilities->Add(utility);
154  utility->SetJetTask(this);
155 
156  return utility;
157 }
158 
164 {
165  TIter next(fUtilities);
166  AliEmcalJetUtility *utility = 0;
167  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->Init();
168 }
174 {
175  TIter next(fUtilities);
176  AliEmcalJetUtility *utility = 0;
177  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->InitEvent(fFastJetWrapper);
178 }
179 
186 {
187  TIter next(fUtilities);
188  AliEmcalJetUtility *utility = 0;
189  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->Prepare(fFastJetWrapper);
190 }
191 
197 {
198  TIter next(fUtilities);
199  AliEmcalJetUtility *utility = 0;
200  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->ProcessJet(jet, ij, fFastJetWrapper);
201 }
202 
208 {
209  TIter next(fUtilities);
210  AliEmcalJetUtility *utility = 0;
211  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->Terminate(fFastJetWrapper);
212 }
213 
219 {
220  InitEvent();
221  // clear the jet array (normally a null operation)
222  fJets->Delete();
223  Int_t n = FindJets();
224 
225  if (n == 0) return kFALSE;
226 
227  FillJetBranch();
228 
229  return kTRUE;
230 }
231 
240 {
241  if (fParticleCollArray.GetEntriesFast() == 0 && fClusterCollArray.GetEntriesFast() == 0){
242  AliError("No tracks or clusters, returning.");
243  return 0;
244  }
245 
247 
248  AliDebug(2,Form("Jet type = %d", fJetType));
249 
250  Int_t iColl = 1;
251  TIter nextPartColl(&fParticleCollArray);
252  AliParticleContainer* tracks = 0;
253  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
254  AliDebug(2,Form("Tracks from collection %d: '%s'. Embedded: %i, nTracks: %i", iColl-1, tracks->GetName(), tracks->GetIsEmbedding(), tracks->GetNParticles()));
256  for (AliParticleIterableMomentumContainer::iterator it = itcont.begin(); it != itcont.end(); it++) {
257 
258  // Apply artificial track inefficiency, if supplied (either constant or pT-dependent)
260  if (fTrackEfficiencyOnlyForEmbedding == kFALSE || (fTrackEfficiencyOnlyForEmbedding == kTRUE && tracks->GetIsEmbedding())) {
261  Double_t trackEfficiency = fTrackEfficiencyFunction->Eval(it->first.Pt());
262  Double_t rnd = fRandom.Rndm();
263  if (trackEfficiency < rnd) {
264  AliDebug(2,Form("Track %d rejected due to artificial tracking inefficiency", it.current_index()));
265  continue;
266  }
267  }
268  }
269 
270  AliDebug(2,Form("Track %d accepted (label = %d, pt = %f, eta = %f, phi = %f, E = %f, m = %f, px = %f, py = %f, pz = %f)", it.current_index(), it->second->GetLabel(), it->first.Pt(), it->first.Eta(), it->first.Phi(), it->first.E(), it->first.M(), it->first.Px(), it->first.Py(), it->first.Pz()));
271  Int_t uid = it.current_index() + fgkConstIndexShift * iColl;
272  fFastJetWrapper.AddInputVector(it->first.Px(), it->first.Py(), it->first.Pz(), it->first.E(), uid);
273  }
274  iColl++;
275  }
276 
277  iColl = 1;
278  TIter nextClusColl(&fClusterCollArray);
279  AliClusterContainer* clusters = 0;
280  while ((clusters = static_cast<AliClusterContainer*>(nextClusColl()))) {
281  AliDebug(2,Form("Clusters from collection %d: '%s'. Embedded: %i, nClusters: %i", iColl-1, clusters->GetName(), clusters->GetIsEmbedding(), clusters->GetNClusters()));
283  for (AliClusterIterableMomentumContainer::iterator it = itcont.begin(); it != itcont.end(); it++) {
284  AliDebug(2,Form("Cluster %d accepted (label = %d, energy = %.3f)", it.current_index(), it->second->GetLabel(), it->first.E()));
285  Int_t uid = -it.current_index() - fgkConstIndexShift * iColl;
286  fFastJetWrapper.AddInputVector(it->first.Px(), it->first.Py(), it->first.Pz(), it->first.E(), uid);
287  }
288  iColl++;
289  }
290 
291  if (fFastJetWrapper.GetInputVectors().size() == 0) return 0;
292 
293  // run jet finder
295 
296  return fFastJetWrapper.GetInclusiveJets().size();
297 }
298 
305 {
307 
308  // loop over fastjet jets
309  std::vector<fastjet::PseudoJet> jets_incl = fFastJetWrapper.GetInclusiveJets();
310  // sort jets according to jet pt
311  static Int_t indexes[9999] = {-1};
312  GetSortedArray(indexes, jets_incl);
313 
314  AliDebug(1,Form("%d jets found", (Int_t)jets_incl.size()));
315  for (UInt_t ijet = 0, jetCount = 0; ijet < jets_incl.size(); ++ijet) {
316  Int_t ij = indexes[ijet];
317  AliDebug(3,Form("Jet pt = %f, area = %f", jets_incl[ij].perp(), fFastJetWrapper.GetJetArea(ij)));
318 
319  if (jets_incl[ij].perp() < fMinJetPt) continue;
320  if (fFastJetWrapper.GetJetArea(ij) < fMinJetArea) continue;
321  if ((jets_incl[ij].eta() < fJetEtaMin) || (jets_incl[ij].eta() > fJetEtaMax) ||
322  (jets_incl[ij].phi() < fJetPhiMin) || (jets_incl[ij].phi() > fJetPhiMax))
323  continue;
324 
325  AliEmcalJet *jet = new ((*fJets)[jetCount])
326  AliEmcalJet(jets_incl[ij].perp(), jets_incl[ij].eta(), jets_incl[ij].phi(), jets_incl[ij].m());
327  jet->SetLabel(ij);
328 
329  fastjet::PseudoJet area(fFastJetWrapper.GetJetAreaVector(ij));
330  jet->SetArea(area.perp());
331  jet->SetAreaEta(area.eta());
332  jet->SetAreaPhi(area.phi());
333  jet->SetAreaE(area.E());
335 
336  // Fill constituent info
337  std::vector<fastjet::PseudoJet> constituents(fFastJetWrapper.GetJetConstituents(ij));
338  FillJetConstituents(jet, constituents, constituents);
339 
340  if (fGeom) {
341  if ((jet->Phi() > fGeom->GetArm1PhiMin() * TMath::DegToRad()) &&
342  (jet->Phi() < fGeom->GetArm1PhiMax() * TMath::DegToRad()) &&
343  (jet->Eta() > fGeom->GetArm1EtaMin()) &&
344  (jet->Eta() < fGeom->GetArm1EtaMax()))
345  jet->SetAxisInEmcal(kTRUE);
346  }
347 
348  ExecuteUtilities(jet, ij);
349 
350  AliDebug(2,Form("Added jet n. %d, pt = %f, area = %f, constituents = %d", jetCount, jet->Pt(), jet->Area(), jet->GetNumberOfConstituents()));
351  jetCount++;
352  }
353 
355 }
356 
363 Bool_t AliEmcalJetTask::GetSortedArray(Int_t indexes[], std::vector<fastjet::PseudoJet> array) const
364 {
365  static Float_t pt[9999] = {0};
366 
367  const Int_t n = (Int_t)array.size();
368 
369  if (n < 1)
370  return kFALSE;
371 
372  for (Int_t i = 0; i < n; i++)
373  pt[i] = array[i].perp();
374 
375  TMath::Sort(n, pt, indexes);
376 
377  return kTRUE;
378 }
379 
386 {
387 
388  // If a constant artificial track efficiency is supplied, create a TF1 that is constant in pT
389  if (fTrackEfficiency < 1.) {
390  // If a TF1 was already loaded, throw an error
392  AliError(Form("%s: fTrackEfficiencyFunction was already loaded! Do not apply multiple artificial track efficiencies.", GetName()));
393  }
394 
395  fTrackEfficiencyFunction = new TF1("trackEfficiencyFunction", "[0]", 0., fMaxBinPt);
396  fTrackEfficiencyFunction->SetParameter(0, fTrackEfficiency);
398  }
399 
400  // If artificial tracking efficiency is enabled (either constant or pT-depdendent), set up random number generator
402  fRandom.SetSeed(0);
403  }
404 
406  std::cout << GetName() << ": Name of the jet container: " << fJetsName << std::endl;
407  std::cout << "Use this name in order to connect jet containers in your task to connect to the collection of jets found by this jet finder" << std::endl;
408  if(auto partcont = GetParticleContainer(0)) {
409  std::cout << "Found particle container with name " << partcont->GetName() << std::endl;
410  } else {
411  std::cout << "Not particle container found for task" << std::endl;
412  }
413  if(auto clustcont = GetClusterContainer(0)){
414  std::cout << "Found cluster container with name " << clustcont->GetName() << std::endl;
415  } else {
416  std::cout << "Not cluster container found for task" << std::endl;
417  }
418 
419  // add jets to event if not yet there
420  if (!(InputEvent()->FindListObject(fJetsName))) {
421  fJets = new TClonesArray("AliEmcalJet");
422  fJets->SetName(fJetsName);
423  ::Info("AliEmcalJetTask::ExecOnce", "Jet collection with name '%s' has been added to the event.", fJetsName.Data());
424  InputEvent()->AddObject(fJets);
425  }
426  else {
427  AliError(Form("%s: Object with name %s already in event! Returning", GetName(), fJetsName.Data()));
428  return;
429  }
430 
431  // setup fj wrapper
432  fFastJetWrapper.SetAreaType(fastjet::active_area_explicit_ghosts);
438 
439 
440  // setting legacy mode
441  if (fLegacyMode) {
443  }
444 
445  InitUtilities();
446 
448 
449  // Setup container utils. Must be called after AliAnalysisTaskEmcal::ExecOnce() so that the
450  // containers' arrays are setup.
453 }
454 
464 void AliEmcalJetTask::FillJetConstituents(AliEmcalJet *jet, std::vector<fastjet::PseudoJet>& constituents,
465  std::vector<fastjet::PseudoJet>& constituents_unsub, Int_t flag, TString particlesSubName)
466 {
467  Int_t nt = 0;
468  Int_t nc = 0;
469  Double_t neutralE = 0.;
470  Double_t maxCh = 0.;
471  Double_t maxNe = 0.;
472  Int_t gall = 0;
473  Int_t gemc = 0;
474  Int_t cemc = 0;
475  Int_t ncharged = 0;
476  Int_t nneutral = 0;
477  Double_t mcpt = 0.;
478  Double_t emcpt = 0.;
479  TClonesArray * particles_sub = 0;
480 
481  Int_t uid = -1;
482 
483  jet->SetNumberOfTracks(constituents.size());
484  jet->SetNumberOfClusters(constituents.size());
485 
486  for (UInt_t ic = 0; ic < constituents.size(); ++ic) {
487 
488  if (flag == 0) {
489  uid = constituents[ic].user_index();
490  }
491  else {
492  if (constituents[ic].perp()<1.e-10) {
493  uid=-1;
494  }
495  else {
496  uid = constituents[ic].user_index();
497  }
498  if (uid==0) {
499  AliError("correspondence between un/subtracted constituent not found");
500  continue;
501  }
502  }
503 
504  AliDebug(3,Form("Processing constituent %d", uid));
505  if (uid == -1) { //ghost particle
506  ++gall;
507  if (fGeom) {
508  Double_t gphi = constituents[ic].phi();
509  if (gphi < 0) gphi += TMath::TwoPi();
510  gphi *= TMath::RadToDeg();
511  Double_t geta = constituents[ic].eta();
512  if ((gphi > fGeom->GetArm1PhiMin()) && (gphi < fGeom->GetArm1PhiMax()) &&
513  (geta > fGeom->GetArm1EtaMin()) && (geta < fGeom->GetArm1EtaMax()))
514  ++gemc;
515  }
516 
517  if (fFillGhost) jet->AddGhost(constituents[ic].px(),
518  constituents[ic].py(),
519  constituents[ic].pz(),
520  constituents[ic].e());
521  }
522  else if (uid >= fgkConstIndexShift) { // track constituent
523  Int_t iColl = uid / fgkConstIndexShift;
524  Int_t tid = uid - iColl * fgkConstIndexShift;
525  iColl--;
526  AliDebug(3,Form("Constituent %d is a track from collection %d and with ID %d", uid, iColl, tid));
527  AliParticleContainer* partCont = GetParticleContainer(iColl);
528  if (!partCont) {
529  AliError(Form("Could not find particle container %d",iColl));
530  continue;
531  }
532  AliVParticle *t = partCont->GetParticle(tid);
533  if (!t) {
534  AliError(Form("Could not find track %d",tid));
535  continue;
536  }
537  if(fFillConstituents){
538  jet->AddParticleConstituent(t, partCont->GetIsEmbedding(), fParticleContainerIndexMap.GlobalIndexFromLocalIndex(partCont, tid));
539  }
540 
541  Double_t cEta = t->Eta();
542  Double_t cPhi = t->Phi();
543  Double_t cPt = t->Pt();
544  if (t->Charge() == 0) {
546  neutralE += t->P();
547  }
548  ++nneutral;
549  if (cPt > maxNe) maxNe = cPt;
550  } else {
551  ++ncharged;
552  if (cPt > maxCh) maxCh = cPt;
553  }
554 
555  // check if MC particle
557  if (TMath::Abs(t->GetLabel()) > fMinMCLabel) mcpt += cPt;
558  }
559 
560  if (fGeom) {
561  if (cPhi < 0) cPhi += TMath::TwoPi();
562  cPhi *= TMath::RadToDeg();
563  if ((cPhi > fGeom->GetArm1PhiMin()) && (cPhi < fGeom->GetArm1PhiMax()) &&
564  (cEta > fGeom->GetArm1EtaMin()) && (cEta < fGeom->GetArm1EtaMax())) {
565  emcpt += cPt;
566  ++cemc;
567  }
568  }
569 
570  if (flag == 0 || particlesSubName == "") {
572  }
573  else {
574  // Get the particle container and array corresponding to the subtracted particles
575  partCont = GetParticleContainer(particlesSubName);
576  particles_sub = partCont->GetArray();
577  // Create the new particle in the particles_sub array and add it to the jet
578  Int_t part_sub_id = particles_sub->GetEntriesFast();
579  AliEmcalParticle* part_sub = new ((*particles_sub)[part_sub_id]) AliEmcalParticle(dynamic_cast<AliVTrack*>(t)); // SA: probably need to be fixed!!
580  part_sub->SetPtEtaPhiM(constituents[ic].perp(),constituents[ic].eta(),constituents[ic].phi(),constituents[ic].m());
581  jet->AddTrackAt(fParticleContainerIndexMap.GlobalIndexFromLocalIndex(partCont, part_sub_id), nt);
582  }
583 
584  ++nt;
585  }
586  else if (uid <= -fgkConstIndexShift) { // cluster constituent
587  Int_t iColl = -uid / fgkConstIndexShift;
588  Int_t cid = -uid - iColl * fgkConstIndexShift;
589  iColl--;
590  AliDebug(3,Form("Constituent %d is a cluster from collection %d and with ID %d", uid, iColl, cid));
591  AliClusterContainer* clusCont = GetClusterContainer(iColl);
592  AliVCluster *c = clusCont->GetCluster(cid);
593 
594  if (!c) continue;
595 
597  clusCont->GetMomentum(nP, cid);
598 
599  Double_t cEta = nP.Eta();
600  Double_t cPhi = nP.Phi_0_2pi();
601  Double_t cPt = nP.Pt();
602  Double_t cP = nP.P();
603  Double_t pvec[3] = {nP.Px(), nP.Py(), nP.Pz()};
604  if(fFillConstituents) jet->AddClusterConstituent(c, (AliVCluster::VCluUserDefEnergy_t)clusCont->GetDefaultClusterEnergy(), pvec, clusCont->GetIsEmbedding(), fClusterContainerIndexMap.GlobalIndexFromLocalIndex(clusCont, cid));
605 
606  neutralE += cP;
607  if (cPt > maxNe) maxNe = cPt;
608 
609  // MC particle
610  if (TMath::Abs(c->GetLabel()) > fMinMCLabel) mcpt += c->GetMCEnergyFraction() > 1e-6 ? cPt * c->GetMCEnergyFraction() : cPt;
611 
612  if (fGeom) {
613  if (cPhi<0) cPhi += TMath::TwoPi();
614  cPhi *= TMath::RadToDeg();
615  if ((cPhi > fGeom->GetArm1PhiMin()) && (cPhi < fGeom->GetArm1PhiMax()) &&
616  (cEta > fGeom->GetArm1EtaMin()) && (cEta < fGeom->GetArm1EtaMax())) {
617  emcpt += cPt;
618  ++cemc;
619  }
620  }
621 
622  if (flag == 0 || particlesSubName == "") {
624  }
625  else {
626  // Get the cluster container and array corresponding to the subtracted particles
627  clusCont = GetClusterContainer(particlesSubName);
628  particles_sub = clusCont->GetArray();
629  // Create the new particle in the particles_sub array and add it to the jet
630  Int_t part_sub_id = particles_sub->GetEntriesFast();
631  AliEmcalParticle* part_sub = new ((*particles_sub)[part_sub_id]) AliEmcalParticle(c);
632  part_sub->SetPtEtaPhiM(constituents[ic].perp(),constituents[ic].eta(),constituents[ic].phi(),constituents[ic].m());
633  jet->AddClusterAt(fClusterContainerIndexMap.GlobalIndexFromLocalIndex(clusCont, part_sub_id), nc);
634  }
635 
636  ++nc;
637  ++nneutral;
638  }
639  else {
640  AliError(Form("%s: No logical way to end up here (uid = %d).", GetName(), uid));
641  continue;
642  }
643  }
644 
645  jet->SetNumberOfTracks(nt);
646  jet->SetNumberOfClusters(nc);
647  jet->SetNEF(neutralE / jet->E());
648  jet->SetMaxChargedPt(maxCh);
649  jet->SetMaxNeutralPt(maxNe);
650  if (gall > 0) jet->SetAreaEmc(jet->Area() * gemc / gall);
651  else jet->SetAreaEmc(-1);
652  jet->SetNEmc(cemc);
653  jet->SetNumberOfCharged(ncharged);
654  jet->SetNumberOfNeutrals(nneutral);
655  jet->SetMCPt(mcpt);
656  jet->SetPtEmc(emcpt);
657  jet->SortConstituents();
658 }
659 
667 {
668  if (fLocked) {
669  AliFatal("Jet finder task is locked! Changing properties is not allowed.");
670  return kTRUE;
671  }
672  else {
673  return kFALSE;
674  }
675 }
676 
684 {
685  if(!fIsPSelSet) {
686  fIsPSelSet = kTRUE;
687  fOfflineTriggerMask = offlineTriggerMask;
688  }
689  else {
690  AliWarning("Manually setting the event selection for jet finders is not allowed! Using trigger=old_trigger | your_trigger");
691  fOfflineTriggerMask = fOfflineTriggerMask | offlineTriggerMask;
692  }
693 }
694 
701 {
702  if (IsLocked()) return;
703 
704  TIter nextPartColl(&fParticleCollArray);
705  AliParticleContainer* tracks = 0;
706  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
707  tracks->SetParticleEtaLimits(emi, ema);
708  }
709 }
710 
716 {
717  if (IsLocked()) return;
718 
719  TIter nextClusColl(&fClusterCollArray);
720  AliClusterContainer* clusters = 0;
721  while ((clusters = static_cast<AliClusterContainer*>(nextClusColl()))) {
722  clusters->SetClusPtCut(min);
723  }
724 }
725 
731 {
732  if (IsLocked()) return;
733 
734  TIter nextClusColl(&fClusterCollArray);
735  AliClusterContainer* clusters = 0;
736  while ((clusters = static_cast<AliClusterContainer*>(nextClusColl()))) {
737  clusters->SetClusECut(min);
738  }
739 }
740 
746 {
747  if (IsLocked()) return;
748 
749  TIter nextPartColl(&fParticleCollArray);
750  AliParticleContainer* tracks = 0;
751  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
752  tracks->SetParticlePtCut(min);
753  }
754 }
755 
762 {
763  if (IsLocked()) return;
764 
765  TIter nextPartColl(&fParticleCollArray);
766  AliParticleContainer* tracks = 0;
767  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
768  tracks->SetParticlePhiLimits(pmi, pma);
769  }
770 }
771 
778 fastjet::JetAlgorithm AliEmcalJetTask::ConvertToFJAlgo(EJetAlgo_t algo)
779 {
780  switch(algo) {
782  return fastjet::kt_algorithm;
784  return fastjet::antikt_algorithm;
786  return fastjet::cambridge_algorithm;
788  return fastjet::genkt_algorithm;
790  return fastjet::cambridge_for_passive_algorithm;
792  return fastjet::genkt_for_passive_algorithm;
794  return fastjet::plugin_algorithm;
796  return fastjet::undefined_jet_algorithm;
797 
798  default:
799  ::Error("AliEmcalJetTask::ConvertToFJAlgo", "Jet algorithm %d not recognized!!!", algo);
800  return fastjet::undefined_jet_algorithm;
801  }
802 }
803 
810 fastjet::RecombinationScheme AliEmcalJetTask::ConvertToFJRecoScheme(ERecoScheme_t reco)
811 {
812  switch(reco) {
814  return fastjet::E_scheme;
815 
817  return fastjet::pt_scheme;
818 
820  return fastjet::pt2_scheme;
821 
823  return fastjet::Et_scheme;
824 
826  return fastjet::Et2_scheme;
827 
829  return fastjet::BIpt_scheme;
830 
832  return fastjet::BIpt2_scheme;
833 
835  return fastjet::external_scheme;
836 
837  default:
838  ::Error("AliEmcalJetTask::ConvertToFJRecoScheme", "Recombination scheme %d not recognized!!!", reco);
839  return fastjet::external_scheme;
840  }
841 }
842 
848 
849  //This method has to be called after the run number is known because it needs the EMCal geometry object.
850 
851  UInt_t jetAcceptanceType = AliEmcalJet::kUser; // all jets satify the "no acceptance cut" condition
852 
853  // Check if TPC
854  if( eta < 0.9 && eta > -0.9 ) {
855  jetAcceptanceType |= AliEmcalJet::kTPC;
856  // Check if TPCfid
857  if (eta < 0.9 - r && eta > -0.9 + r)
858  jetAcceptanceType |= AliEmcalJet::kTPCfid;
859  }
860 
861  // Check if EMCAL
862  if( IsJetInEmcal(eta, phi, 0) ) {
863  jetAcceptanceType |= AliEmcalJet::kEMCAL;
864  // Check if EMCALfid
865  if( IsJetInEmcal(eta, phi, r) )
866  jetAcceptanceType |= AliEmcalJet::kEMCALfid;
867  }
868 
869  // Check if DCAL (i.e. eta-phi rectangle spanning DCal, which includes most of PHOS)
870  if( IsJetInDcal(eta, phi, 0) ) {
871  jetAcceptanceType |= AliEmcalJet::kDCAL;
872  // Check if DCALfid
873  if( IsJetInDcal(eta, phi, r) )
874  jetAcceptanceType |= AliEmcalJet::kDCALfid;
875  }
876 
877  // Check if DCALonly (i.e. ONLY DCal, does not include any of PHOS region)
878  if( IsJetInDcalOnly(eta, phi, 0) ) {
879  jetAcceptanceType |= AliEmcalJet::kDCALonly;
880  // Check if DCALonlyfid
881  if( IsJetInDcalOnly(eta, phi, r) )
882  jetAcceptanceType |= AliEmcalJet::kDCALonlyfid;
883  }
884 
885  // Check if PHOS
886  if( IsJetInPhos(eta, phi, 0) ) {
887  jetAcceptanceType |= AliEmcalJet::kPHOS;
888  // Check if PHOSfid
889  if( IsJetInPhos(eta, phi, r) )
890  jetAcceptanceType |= AliEmcalJet::kPHOSfid;
891  }
892 
893  return jetAcceptanceType;
894 }
895 
900 {
901  if (!fGeom) return kFALSE;
902 
903  if ( eta < fGeom->GetArm1EtaMax() - r && eta > fGeom->GetArm1EtaMin() + r ) {
904  if(fRunNumber >= 177295 && fRunNumber <= 197470) {//small SM masked in 2012 and 2013
905  if ( phi < 3.135 - r && phi > 1.405 + r )
906  return kTRUE;
907  }
908  else {
909  if ( phi < fGeom->GetEMCALPhiMax() * TMath::DegToRad() - r && phi > fGeom->GetArm1PhiMin() * TMath::DegToRad() + r)
910  return kTRUE;
911  }
912  }
913 
914  return kFALSE;
915 }
916 
921 {
922  if (!fGeom) return kFALSE;
923  if (eta < fGeom->GetArm1EtaMax() - r && eta > fGeom->GetArm1EtaMin() + r ) {
924  if ( phi < fGeom->GetDCALPhiMax() * TMath::DegToRad() - r && phi > fGeom->GetDCALPhiMin() * TMath::DegToRad() + r)
925  return kTRUE;
926  }
927  return kFALSE;
928 }
929 
937 {
938  if (!fGeom) return kFALSE;
939 
940  if (eta < fGeom->GetArm1EtaMax() - r && eta > fGeom->GetArm1EtaMin() + r) {
941  if ( phi < fGeom->GetDCALPhiMax() * TMath::DegToRad() - r && phi > fGeom->GetDCALPhiMin() * TMath::DegToRad() + r) {
942 
943  if (TMath::Abs(eta) > fGeom->GetDCALInnerExtandedEta() + r) {
944  return kTRUE;
945  }
946  if (r < 1e-6) {
947  if (phi > fGeom->GetEMCGeometry()->GetDCALStandardPhiMax() * TMath::DegToRad())
948  return kTRUE;
949  }
950 
951  }
952  }
953 
954  return kFALSE;
955 }
956 
961 {
962  Double_t etaMax = 0.130;
963  Double_t etaMin = -0.130;
964  Double_t phiMax = 320;
965  Double_t phiMin = 260; // Run 1
966  if (fRunNumber > 209121)
967  phiMin = 250; // Run 2
968 
969  if (eta < etaMax - r && eta > etaMin + r ) {
970  if (phi < phiMax * TMath::DegToRad() - r && phi > phiMin * TMath::DegToRad() + r)
971  return kTRUE;
972  }
973  return kFALSE;
974 }
975 
981 void AliEmcalJetTask::LoadTrackEfficiencyFunction(const std::string & path, const std::string & name)
982 {
983  TString fname(path);
984  if (fname.BeginsWith("alien://")) {
985  TGrid::Connect("alien://");
986  }
987 
988  TFile* file = TFile::Open(path.data());
989 
990  if (!file || file->IsZombie()) {
991  AliErrorStream() << "Could not open artificial track efficiency function file\n";
992  return;
993  }
994 
995  TF1* trackEff = dynamic_cast<TF1*>(file->Get(name.data()));
996 
997  if (trackEff) {
998  AliInfoStream() << Form("Artificial track efficiency function %s loaded from file %s.", name.data(), path.data()) << "\n";
999  }
1000  else {
1001  AliErrorStream() << Form("Artificial track efficiency function %s not found in file %s.", name.data(), path.data()) << "\n";
1002  return;
1003  }
1004 
1005  fTrackEfficiencyFunction = static_cast<TF1*>(trackEff->Clone());
1007 
1008  file->Close();
1009  delete file;
1010 }
1011 
1030  const TString nTracks, const TString nClusters,
1031  const AliJetContainer::EJetAlgo_t jetAlgo, const Double_t radius, const AliJetContainer::EJetType_t jetType,
1032  const Double_t minTrPt, const Double_t minClPt,
1033  const Double_t ghostArea, const AliJetContainer::ERecoScheme_t reco,
1034  const TString tag, const Double_t minJetPt,
1035  const Bool_t lockTask, const Bool_t bFillGhosts
1036 )
1037 {
1038  // Get the pointer to the existing analysis manager via the static access method
1039  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1040  if (!mgr) {
1041  ::Error("AddTaskEmcalJet", "No analysis manager to connect to.");
1042  return 0;
1043  }
1044 
1045  // Check the analysis type using the event handlers connected to the analysis manager
1046  AliVEventHandler* handler = mgr->GetInputEventHandler();
1047  if (!handler) {
1048  ::Error("AddTaskEmcalJet", "This task requires an input event handler");
1049  return 0;
1050  }
1051 
1053 
1054  if (handler->InheritsFrom("AliESDInputHandler")) {
1055  dataType = kESD;
1056  }
1057  else if (handler->InheritsFrom("AliAODInputHandler")) {
1058  dataType = kAOD;
1059  }
1060 
1061  //-------------------------------------------------------
1062  // Init the task and do settings
1063  //-------------------------------------------------------
1064 
1065  TString trackName(nTracks);
1066  TString clusName(nClusters);
1067 
1068  if (trackName == "usedefault") {
1069  if (dataType == kESD) {
1070  trackName = "Tracks";
1071  }
1072  else if (dataType == kAOD) {
1073  trackName = "tracks";
1074  }
1075  else {
1076  trackName = "";
1077  }
1078  }
1079 
1080  if (clusName == "usedefault") {
1081  if (dataType == kESD) {
1082  clusName = "CaloClusters";
1083  }
1084  else if (dataType == kAOD) {
1085  clusName = "caloClusters";
1086  }
1087  else {
1088  clusName = "";
1089  }
1090  }
1091 
1092  AliParticleContainer* partCont = 0;
1093  if (trackName == "mcparticles") {
1094  AliMCParticleContainer* mcpartCont = new AliMCParticleContainer(trackName);
1095  partCont = mcpartCont;
1096  }
1097  else if (trackName == "tracks" || trackName == "Tracks") {
1098  AliTrackContainer* trackCont = new AliTrackContainer(trackName);
1099  partCont = trackCont;
1100  }
1101  else if (!trackName.IsNull()) {
1102  partCont = new AliParticleContainer(trackName);
1103  }
1104  if (partCont) partCont->SetParticlePtCut(minTrPt);
1105 
1106  AliClusterContainer* clusCont = 0;
1107  if (!clusName.IsNull()) {
1108  clusCont = new AliClusterContainer(clusName);
1109  clusCont->SetClusECut(0.);
1110  clusCont->SetClusPtCut(0.);
1111  clusCont->SetClusHadCorrEnergyCut(minClPt);
1112  clusCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
1113  }
1114 
1115  switch (jetType) {
1117  if (partCont) partCont->SetCharge(AliParticleContainer::kCharged);
1118  break;
1120  if (partCont) partCont->SetCharge(AliParticleContainer::kNeutral);
1121  break;
1122  default:
1123  break;
1124  }
1125 
1126  TString name = AliJetContainer::GenerateJetName(jetType, jetAlgo, reco, radius, partCont, clusCont, tag);
1127 
1128  Printf("Jet task name: %s", name.Data());
1129 
1130  AliEmcalJetTask* mgrTask = static_cast<AliEmcalJetTask *>(mgr->GetTask(name.Data()));
1131  if (mgrTask) return mgrTask;
1132 
1133  AliEmcalJetTask* jetTask = new AliEmcalJetTask(name);
1134  jetTask->SetJetType(jetType);
1135  jetTask->SetJetAlgo(jetAlgo);
1136  jetTask->SetRecombScheme(reco);
1137  jetTask->SetRadius(radius);
1138  if (partCont) jetTask->AdoptParticleContainer(partCont);
1139  if (clusCont) jetTask->AdoptClusterContainer(clusCont);
1140  jetTask->SetJetsName(tag);
1141  jetTask->SetMinJetPt(minJetPt);
1142  jetTask->SetGhostArea(ghostArea);
1143 
1144  if (bFillGhosts) jetTask->SetFillGhost();
1145  if (lockTask) jetTask->SetLocked();
1146 
1147  // Final settings, pass to manager and set the containers
1148 
1149  mgr->AddTask(jetTask);
1150 
1151  // Create containers for input/output
1152  AliAnalysisDataContainer* cinput = mgr->GetCommonInputContainer();
1153  mgr->ConnectInput(jetTask, 0, cinput);
1154 
1155  return jetTask;
1156 }
Bool_t fTrackEfficiencyOnlyForEmbedding
Apply aritificial tracking inefficiency only for embedded tracks.
void SetMaxNeutralPt(Double32_t t)
Definition: AliEmcalJet.h:262
void SetJetsName(const char *n)
void SetRecombScheme(ERecoScheme_t scheme)
fastjet::PseudoJet GetJetAreaVector(UInt_t idx) const
Double_t Area() const
Definition: AliEmcalJet.h:130
TObjArray fClusterCollArray
cluster collection array
void AddTrackAt(Int_t track, Int_t idx)
Definition: AliEmcalJet.h:275
void SetParticlePtCut(Double_t cut)
TClonesArray * fJets
!jet collection
virtual Int_t Run()
double Double_t
Definition: External.C:58
Bool_t fIsEmcPart
!=true if emcal particles are given as input (for clusters)
void SetEtaRange(Double_t emi, Double_t ema)
Bool_t IsLocked() const
Bool_t fIsInit
!=true if already initialized
PHOS acceptance.
Definition: AliEmcalJet.h:75
DCal acceptance – spans entire rectangular region in eta-phi (including most of PHOS) ...
Definition: AliEmcalJet.h:71
void AdoptParticleContainer(AliParticleContainer *cont)
Double_t Eta() const
Definition: AliEmcalJet.h:121
const AliClusterIterableMomentumContainer accepted_momentum() const
Base task in the EMCAL framework.
bidirectional stl iterator over the EMCAL iterable container
Double_t fJetEtaMin
minimum eta to keep jet in output
EJetType_t fJetType
jet type (full, charged, neutral)
Bool_t IsJetInEmcal(Double_t eta, Double_t phi, Double_t r)
Double_t Phi() const
Definition: AliEmcalJet.h:117
Int_t GetNParticles() const
Container with name, TClonesArray and cuts for particles.
Bool_t fApplyArtificialTrackingEfficiency
Flag to apply artificial tracking efficiency.
void AddClusterAt(Int_t clus, Int_t idx)
Definition: AliEmcalJet.h:274
AliEmcalJetUtility * AddUtility(AliEmcalJetUtility *utility)
Bool_t fFillGhost
=true ghost particles will be filled in AliEmcalJet obj
Declaration of class AliTLorentzVector.
virtual void ProcessJet(AliEmcalJet *jet, Int_t ij, AliFJWrapper &fjw)=0
Double_t phiMin
void SetArea(Double_t a)
Definition: AliEmcalJet.h:256
void SetJetType(EJetType_t t)
void ExecuteUtilities(AliEmcalJet *jet, Int_t ij)
Full acceptance, i.e. no acceptance cut applied – left to user.
Definition: AliEmcalJet.h:77
TCanvas * c
Definition: TestFitELoss.C:172
void SetMaxRap(Double_t maxrap)
Definition: AliFJWrapper.h:126
virtual void Terminate(AliFJWrapper &fjw)=0
void SetMinJetPt(Double_t j)
void SetAreaE(Double_t a)
Definition: AliEmcalJet.h:259
AliEmcalContainerIndexMap< AliParticleContainer, AliVParticle > fParticleContainerIndexMap
! Mapping between index and particle containers
ERecoScheme_t fRecombScheme
recombination scheme used by fastjet
void SetRecombScheme(const fastjet::RecombinationScheme &scheme)
Definition: AliFJWrapper.h:122
Bool_t fFillConstituents
If true jet consituents will be filled to the AliEmcalJet.
Double_t fTrackEfficiency
artificial tracking inefficiency (0...1)
void SetMCPt(Double_t p)
Definition: AliEmcalJet.h:269
Double_t E() const
Definition: AliEmcalJet.h:119
void SetJetAlgo(EJetAlgo_t a)
virtual ~AliEmcalJetTask()
static FJRecoScheme ConvertToFJRecoScheme(ERecoScheme_t reco)
int GlobalIndexFromLocalIndex(const U *inputObject, const int localIndex) const
void SetLabel(Int_t l)
Definition: AliEmcalJet.h:255
General jet finder task implementing a wrapper for FastJet.
static TString GenerateJetName(EJetType_t jetType, EJetAlgo_t jetAlgo, ERecoScheme_t recoScheme, Double_t radius, AliParticleContainer *partCont, AliClusterContainer *clusCont, TString tag)
UShort_t GetNumberOfConstituents() const
Definition: AliEmcalJet.h:140
Container for particles within the EMCAL framework.
Bool_t fIsPSelSet
!=true if physics selection was set
Int_t GetDefaultClusterEnergy() const
void SetR(Double_t r)
Definition: AliFJWrapper.h:127
void LoadTrackEfficiencyFunction(const std::string &path, const std::string &name)
void AdoptClusterContainer(AliClusterContainer *cont)
TObjArray fParticleCollArray
particle/track collection array
void AddParticleConstituent(const AliVParticle *const part, Bool_t isFromEmbeddedEvent, UInt_t globalIndex)
Add new particle (track / mc particle) constituent to the given jet Note: this will append the consti...
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Get particle container attached to this task.
TPC fiducial acceptance (each eta edge narrowed by jet R)
Definition: AliEmcalJet.h:68
Bool_t fLocked
true if lock is set
const std::vector< fastjet::PseudoJet > & GetInclusiveJets() const
Definition: AliFJWrapper.h:34
void SetJetAcceptanceType(UInt_t type)
Definition: AliEmcalJet.h:366
Double_t fJetPhiMin
minimum phi to keep jet in output
UInt_t FindJetAcceptanceType(Double_t eta, Double_t phi, Double_t r)
int Int_t
Definition: External.C:63
Bool_t fEnableAliBasicParticleCompatibility
Flag to allow compatibility with AliBasicParticle constituents.
Bool_t IsJetInDcal(Double_t eta, Double_t phi, Double_t r)
TPC acceptance.
Definition: AliEmcalJet.h:67
unsigned int UInt_t
Definition: External.C:33
float Float_t
Definition: External.C:68
Double_t GetJetArea(UInt_t idx) const
AliEMCALGeometry * fGeom
!emcal geometry
PHOS fiducial acceptance (each eta, phi edge narrowed by jet R)
Definition: AliEmcalJet.h:76
void AddClusterConstituent(const AliVCluster *const clust, AliVCluster::VCluUserDefEnergy_t endef, Double_t *pvec, Bool_t isFromEmbeddedEvent, UInt_t globalIndex)
Add new cluster constituent to the given jet Note: this will append the constituent. No sorting according to particle is done.
Double_t Phi_0_2pi() const
EMCal acceptance.
Definition: AliEmcalJet.h:69
TString fJetsTag
tag of jet collection (usually = "Jets")
void SetLegacyMode(Bool_t mode)
Definition: AliFJWrapper.h:137
virtual AliVParticle * GetParticle(Int_t i=-1) const
TObjArray * fUtilities
jet utilities (gen subtractor, constituent subtractor etc.)
Double_t phiMax
void SetPtEtaPhiM(Double_t pt, Double_t eta, Double_t phi, Double_t m)
void SetAlgorithm(const fastjet::JetAlgorithm &algor)
Definition: AliFJWrapper.h:121
TF1 * fTrackEfficiencyFunction
Function that describes the artificial tracking efficiency to be applied on top of the nominal tracki...
static const AliEmcalContainerIndexMap< TClonesArray, AliVCluster > & GetEmcalContainerIndexMap()
Get the EMCal container utils associated with particle containers.
AliClusterContainer * GetClusterContainer(Int_t i=0) const
Get cluster container attached to this task.
AliEmcalContainerIndexMap< AliClusterContainer, AliVCluster > fClusterContainerIndexMap
! Mapping between index and cluster containers
Int_t GetNClusters() const
Double_t Phi_0_2pi() const
Definition: AliEmcalJet.h:129
Double_t fJetEtaMax
maximum eta to keep jet in output
Double_t fGhostArea
ghost area
void SetMaxChargedPt(Double32_t t)
Definition: AliEmcalJet.h:263
virtual void Clear(const Option_t *="")
void SetNEF(Double_t nef)
Definition: AliEmcalJet.h:264
Bool_t GetSortedArray(Int_t indexes[], std::vector< fastjet::PseudoJet > array) const
void AddGhost(const Double_t dPx, const Double_t dPy, const Double_t dPz, const Double_t dE)
void SetNEmc(Int_t n)
Definition: AliEmcalJet.h:270
AliVCluster * GetCluster(Int_t i) const
Bool_t IsJetInDcalOnly(Double_t eta, Double_t phi, Double_t r)
virtual void Prepare(AliFJWrapper &fjw)=0
Int_t fMinMCLabel
minimum MC label value for the tracks/clusters being considered MC particles
void SetJetTask(AliEmcalJetTask *jetTask)
void SetMinJetClusE(Double_t min)
Double_t Pt() const
Definition: AliEmcalJet.h:109
void SelectCollisionCandidates(UInt_t offlineTriggerMask=AliVEvent::kMB)
void SetGhostArea(Double_t gharea)
Definition: AliFJWrapper.h:125
void SetGhostArea(Double_t gharea)
EJetAlgo_t fJetAlgo
jet algorithm (kt, akt, etc)
void SetNumberOfCharged(Int_t n)
Definition: AliEmcalJet.h:267
Double_t fJetPhiMax
maximum phi to keep jet in output
std::vector< fastjet::PseudoJet > GetJetConstituents(UInt_t idx) const
void SetAreaEta(Double_t a)
Definition: AliEmcalJet.h:257
static FJJetAlgo ConvertToFJAlgo(EJetAlgo_t algo)
void SetParticleEtaLimits(Double_t min, Double_t max)
const std::vector< fastjet::PseudoJet > & GetInputVectors() const
Definition: AliFJWrapper.h:31
Double_t fMaxBinPt
max pt in histograms
void SetMinJetTrackPt(Double_t min)
Double_t fMinJetArea
min area to keep jet in output
TString fJetsName
!name of jet collection
void SetFillGhost(Bool_t b=kTRUE)
Double_t fMinJetPt
min jet pt to keep jet in output
const AliParticleIterableMomentumContainer accepted_momentum() const
TRandom3 fRandom
! Random number generator for artificial tracking efficiency
TFile * file
TList with histograms for a given trigger.
void CopyMappingFrom(const AliEmcalContainerIndexMap< U2, V > &map, U *cont)
void FillJetConstituents(AliEmcalJet *jet, std::vector< fastjet::PseudoJet > &constituents, std::vector< fastjet::PseudoJet > &constituents_sub, Int_t flag=0, TString particlesSubName="")
Bool_t GetMomentum(TLorentzVector &mom, const AliVCluster *vc, Double_t mass) const
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:51
void SetNumberOfTracks(Int_t n)
Definition: AliEmcalJet.h:266
virtual void ExecOnce()
Perform steps needed to initialize the analysis.
Double_t fRadius
jet radius
Bool_t fLegacyMode
!=true to enable FJ 2.x behavior
void SetClusPtCut(Double_t cut)
Int_t fRunNumber
!run number (triggering RunChanged()
virtual void AddInputVector(Double_t px, Double_t py, Double_t pz, Double_t E, Int_t index=-99999)
void SortConstituents()
void SetMinJetClusPt(Double_t min)
DCal fiducial acceptance (each eta, phi edge narrowed by jet R)
Definition: AliEmcalJet.h:72
bool Bool_t
Definition: External.C:53
void SetPhiRange(Double_t pmi, Double_t pma)
EDataType_t
Switch for the data type.
DCal acceptance – spans ONLY DCal (no PHOS or gap)
Definition: AliEmcalJet.h:73
void SetClusECut(Double_t cut)
void SetDefaultClusterEnergy(Int_t d)
void SetAreaPhi(Double_t a)
Definition: AliEmcalJet.h:258
virtual void InitEvent(AliFJWrapper &fjw)=0
void SetAreaType(const fastjet::AreaType &atype)
Definition: AliFJWrapper.h:123
void SetParticlePhiLimits(Double_t min, Double_t max)
void SetPtEmc(Double_t pt)
Definition: AliEmcalJet.h:271
Container structure for EMCAL clusters.
DCal fiducial acceptance (each eta, phi edge narrowed by jet R)
Definition: AliEmcalJet.h:74
Container for MC-true particles within the EMCAL framework.
EMCal fiducial acceptance (each eta, phi edge narrowed by jet R)
Definition: AliEmcalJet.h:70
static AliEmcalJetTask * AddTaskEmcalJet(const TString nTracks="usedefault", const TString nClusters="usedefault", const AliJetContainer::EJetAlgo_t jetAlgo=AliJetContainer::antikt_algorithm, const Double_t radius=0.4, const AliJetContainer::EJetType_t jetType=AliJetContainer::kFullJet, const Double_t minTrPt=0.15, const Double_t minClPt=0.30, const Double_t ghostArea=0.005, const AliJetContainer::ERecoScheme_t reco=AliJetContainer::pt_scheme, const TString tag="Jet", const Double_t minJetPt=0., const Bool_t lockTask=kTRUE, const Bool_t bFillGhosts=kFALSE)
void SetCharge(EChargeCut_t c)
Container for jet within the EMCAL jet framework.
void SetRadius(Double_t r)
AliFJWrapper fFastJetWrapper
!fastjet wrapper
void SetNumberOfClusters(Int_t n)
Definition: AliEmcalJet.h:265
virtual void Init()=0
Bool_t IsJetInPhos(Double_t eta, Double_t phi, Double_t r)
void SetAxisInEmcal(Bool_t b)
Definition: AliEmcalJet.h:261
static const AliEmcalContainerIndexMap< TClonesArray, AliVParticle > & GetEmcalContainerIndexMap()
Get the EMCal container utils associated with particle containers.
static const Int_t fgkConstIndexShift
!contituent index shift
void SetAreaEmc(Double_t a)
Definition: AliEmcalJet.h:260
void SetClusHadCorrEnergyCut(Double_t cut)
void SetNumberOfNeutrals(Int_t n)
Definition: AliEmcalJet.h:268