AliPhysics  df4bbdf (df4bbdf)
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  fLegacyMode(kFALSE),
86  fFillGhost(kFALSE),
87  fJets(0),
88  fFastJetWrapper("AliEmcalJetTask","AliEmcalJetTask"),
89  fClusterContainerIndexMap(),
90  fParticleContainerIndexMap()
91 {
92 }
93 
100  fJetsTag("Jets"),
101  fJetType(AliJetContainer::kFullJet),
102  fJetAlgo(AliJetContainer::antikt_algorithm),
103  fRecombScheme(AliJetContainer::pt_scheme),
104  fRadius(0.4),
105  fMinJetArea(0.001),
106  fMinJetPt(1.0),
107  fJetPhiMin(-10),
108  fJetPhiMax(+10),
109  fJetEtaMin(-1),
110  fJetEtaMax(+1),
111  fGhostArea(0.005),
112  fTrackEfficiency(1.),
113  fUtilities(0),
117  fRandom(0),
118  fLocked(0),
119  fFillConstituents(kTRUE),
120  fJetsName(),
121  fIsInit(0),
122  fIsPSelSet(0),
123  fIsEmcPart(0),
124  fLegacyMode(kFALSE),
125  fFillGhost(kFALSE),
126  fJets(0),
127  fFastJetWrapper(name,name),
130 {
131 }
132 
137 {
138 }
139 
145 {
146  if (!fUtilities) fUtilities = new TObjArray();
147  if (fUtilities->FindObject(utility)) {
148  Error("AddUtility", "Jet utility %s already connected.", utility->GetName());
149  return utility;
150  }
151  fUtilities->Add(utility);
152  utility->SetJetTask(this);
153 
154  return utility;
155 }
156 
162 {
163  TIter next(fUtilities);
164  AliEmcalJetUtility *utility = 0;
165  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->Init();
166 }
172 {
173  TIter next(fUtilities);
174  AliEmcalJetUtility *utility = 0;
175  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->InitEvent(fFastJetWrapper);
176 }
177 
184 {
185  TIter next(fUtilities);
186  AliEmcalJetUtility *utility = 0;
187  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->Prepare(fFastJetWrapper);
188 }
189 
195 {
196  TIter next(fUtilities);
197  AliEmcalJetUtility *utility = 0;
198  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->ProcessJet(jet, ij, fFastJetWrapper);
199 }
200 
206 {
207  TIter next(fUtilities);
208  AliEmcalJetUtility *utility = 0;
209  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->Terminate(fFastJetWrapper);
210 }
211 
217 {
218  InitEvent();
219  // clear the jet array (normally a null operation)
220  fJets->Delete();
221  Int_t n = FindJets();
222 
223  if (n == 0) return kFALSE;
224 
225  FillJetBranch();
226 
227  return kTRUE;
228 }
229 
238 {
239  if (fParticleCollArray.GetEntriesFast() == 0 && fClusterCollArray.GetEntriesFast() == 0){
240  AliError("No tracks or clusters, returning.");
241  return 0;
242  }
243 
245 
246  AliDebug(2,Form("Jet type = %d", fJetType));
247 
248  Int_t iColl = 1;
249  TIter nextPartColl(&fParticleCollArray);
250  AliParticleContainer* tracks = 0;
251  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
252  AliDebug(2,Form("Tracks from collection %d: '%s'. Embedded: %i, nTracks: %i", iColl-1, tracks->GetName(), tracks->GetIsEmbedding(), tracks->GetNParticles()));
254  for (AliParticleIterableMomentumContainer::iterator it = itcont.begin(); it != itcont.end(); it++) {
255 
256  // Apply artificial track inefficiency, if supplied (either constant or pT-dependent)
258  if (fTrackEfficiencyOnlyForEmbedding == kFALSE || (fTrackEfficiencyOnlyForEmbedding == kTRUE && tracks->GetIsEmbedding())) {
259  Double_t trackEfficiency = fTrackEfficiencyFunction->Eval(it->first.Pt());
260  Double_t rnd = fRandom.Rndm();
261  if (trackEfficiency < rnd) {
262  AliDebug(2,Form("Track %d rejected due to artificial tracking inefficiency", it.current_index()));
263  continue;
264  }
265  }
266  }
267 
268  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()));
269  Int_t uid = it.current_index() + fgkConstIndexShift * iColl;
270  fFastJetWrapper.AddInputVector(it->first.Px(), it->first.Py(), it->first.Pz(), it->first.E(), uid);
271  }
272  iColl++;
273  }
274 
275  iColl = 1;
276  TIter nextClusColl(&fClusterCollArray);
277  AliClusterContainer* clusters = 0;
278  while ((clusters = static_cast<AliClusterContainer*>(nextClusColl()))) {
279  AliDebug(2,Form("Clusters from collection %d: '%s'. Embedded: %i, nClusters: %i", iColl-1, clusters->GetName(), clusters->GetIsEmbedding(), clusters->GetNClusters()));
281  for (AliClusterIterableMomentumContainer::iterator it = itcont.begin(); it != itcont.end(); it++) {
282  AliDebug(2,Form("Cluster %d accepted (label = %d, energy = %.3f)", it.current_index(), it->second->GetLabel(), it->first.E()));
283  Int_t uid = -it.current_index() - fgkConstIndexShift * iColl;
284  fFastJetWrapper.AddInputVector(it->first.Px(), it->first.Py(), it->first.Pz(), it->first.E(), uid);
285  }
286  iColl++;
287  }
288 
289  if (fFastJetWrapper.GetInputVectors().size() == 0) return 0;
290 
291  // run jet finder
293 
294  return fFastJetWrapper.GetInclusiveJets().size();
295 }
296 
303 {
305 
306  // loop over fastjet jets
307  std::vector<fastjet::PseudoJet> jets_incl = fFastJetWrapper.GetInclusiveJets();
308  // sort jets according to jet pt
309  static Int_t indexes[9999] = {-1};
310  GetSortedArray(indexes, jets_incl);
311 
312  AliDebug(1,Form("%d jets found", (Int_t)jets_incl.size()));
313  for (UInt_t ijet = 0, jetCount = 0; ijet < jets_incl.size(); ++ijet) {
314  Int_t ij = indexes[ijet];
315  AliDebug(3,Form("Jet pt = %f, area = %f", jets_incl[ij].perp(), fFastJetWrapper.GetJetArea(ij)));
316 
317  if (jets_incl[ij].perp() < fMinJetPt) continue;
318  if (fFastJetWrapper.GetJetArea(ij) < fMinJetArea) continue;
319  if ((jets_incl[ij].eta() < fJetEtaMin) || (jets_incl[ij].eta() > fJetEtaMax) ||
320  (jets_incl[ij].phi() < fJetPhiMin) || (jets_incl[ij].phi() > fJetPhiMax))
321  continue;
322 
323  AliEmcalJet *jet = new ((*fJets)[jetCount])
324  AliEmcalJet(jets_incl[ij].perp(), jets_incl[ij].eta(), jets_incl[ij].phi(), jets_incl[ij].m());
325  jet->SetLabel(ij);
326 
327  fastjet::PseudoJet area(fFastJetWrapper.GetJetAreaVector(ij));
328  jet->SetArea(area.perp());
329  jet->SetAreaEta(area.eta());
330  jet->SetAreaPhi(area.phi());
331  jet->SetAreaE(area.E());
333 
334  // Fill constituent info
335  std::vector<fastjet::PseudoJet> constituents(fFastJetWrapper.GetJetConstituents(ij));
336  FillJetConstituents(jet, constituents, constituents);
337 
338  if (fGeom) {
339  if ((jet->Phi() > fGeom->GetArm1PhiMin() * TMath::DegToRad()) &&
340  (jet->Phi() < fGeom->GetArm1PhiMax() * TMath::DegToRad()) &&
341  (jet->Eta() > fGeom->GetArm1EtaMin()) &&
342  (jet->Eta() < fGeom->GetArm1EtaMax()))
343  jet->SetAxisInEmcal(kTRUE);
344  }
345 
346  ExecuteUtilities(jet, ij);
347 
348  AliDebug(2,Form("Added jet n. %d, pt = %f, area = %f, constituents = %d", jetCount, jet->Pt(), jet->Area(), jet->GetNumberOfConstituents()));
349  jetCount++;
350  }
351 
353 }
354 
361 Bool_t AliEmcalJetTask::GetSortedArray(Int_t indexes[], std::vector<fastjet::PseudoJet> array) const
362 {
363  static Float_t pt[9999] = {0};
364 
365  const Int_t n = (Int_t)array.size();
366 
367  if (n < 1)
368  return kFALSE;
369 
370  for (Int_t i = 0; i < n; i++)
371  pt[i] = array[i].perp();
372 
373  TMath::Sort(n, pt, indexes);
374 
375  return kTRUE;
376 }
377 
384 {
385 
386  // If a constant artificial track efficiency is supplied, create a TF1 that is constant in pT
387  if (fTrackEfficiency < 1.) {
388  // If a TF1 was already loaded, throw an error
390  AliError(Form("%s: fTrackEfficiencyFunction was already loaded! Do not apply multiple artificial track efficiencies.", GetName()));
391  }
392 
393  fTrackEfficiencyFunction = new TF1("trackEfficiencyFunction", "[0]", 0., fMaxBinPt);
394  fTrackEfficiencyFunction->SetParameter(0, fTrackEfficiency);
396  }
397 
398  // If artificial tracking efficiency is enabled (either constant or pT-depdendent), set up random number generator
400  fRandom.SetSeed(0);
401  }
402 
404  std::cout << GetName() << ": Name of the jet container: " << fJetsName << std::endl;
405  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;
406  if(auto partcont = GetParticleContainer(0)) {
407  std::cout << "Found particle container with name " << partcont->GetName() << std::endl;
408  } else {
409  std::cout << "Not particle container found for task" << std::endl;
410  }
411  if(auto clustcont = GetClusterContainer(0)){
412  std::cout << "Found cluster container with name " << clustcont->GetName() << std::endl;
413  } else {
414  std::cout << "Not cluster container found for task" << std::endl;
415  }
416 
417  // add jets to event if not yet there
418  if (!(InputEvent()->FindListObject(fJetsName))) {
419  fJets = new TClonesArray("AliEmcalJet");
420  fJets->SetName(fJetsName);
421  ::Info("AliEmcalJetTask::ExecOnce", "Jet collection with name '%s' has been added to the event.", fJetsName.Data());
422  InputEvent()->AddObject(fJets);
423  }
424  else {
425  AliError(Form("%s: Object with name %s already in event! Returning", GetName(), fJetsName.Data()));
426  return;
427  }
428 
429  // setup fj wrapper
430  fFastJetWrapper.SetAreaType(fastjet::active_area_explicit_ghosts);
436 
437 
438  // setting legacy mode
439  if (fLegacyMode) {
441  }
442 
443  InitUtilities();
444 
446 
447  // Setup container utils. Must be called after AliAnalysisTaskEmcal::ExecOnce() so that the
448  // containers' arrays are setup.
451 }
452 
462 void AliEmcalJetTask::FillJetConstituents(AliEmcalJet *jet, std::vector<fastjet::PseudoJet>& constituents,
463  std::vector<fastjet::PseudoJet>& constituents_unsub, Int_t flag, TString particlesSubName)
464 {
465  Int_t nt = 0;
466  Int_t nc = 0;
467  Double_t neutralE = 0.;
468  Double_t maxCh = 0.;
469  Double_t maxNe = 0.;
470  Int_t gall = 0;
471  Int_t gemc = 0;
472  Int_t cemc = 0;
473  Int_t ncharged = 0;
474  Int_t nneutral = 0;
475  Double_t mcpt = 0.;
476  Double_t emcpt = 0.;
477  TClonesArray * particles_sub = 0;
478 
479  Int_t uid = -1;
480 
481  jet->SetNumberOfTracks(constituents.size());
482  jet->SetNumberOfClusters(constituents.size());
483 
484  for (UInt_t ic = 0; ic < constituents.size(); ++ic) {
485 
486  if (flag == 0) {
487  uid = constituents[ic].user_index();
488  }
489  else {
490  if (constituents[ic].perp()<1.e-10) {
491  uid=-1;
492  }
493  else {
494  uid = constituents[ic].user_index();
495  }
496  if (uid==0) {
497  AliError("correspondence between un/subtracted constituent not found");
498  continue;
499  }
500  }
501 
502  AliDebug(3,Form("Processing constituent %d", uid));
503  if (uid == -1) { //ghost particle
504  ++gall;
505  if (fGeom) {
506  Double_t gphi = constituents[ic].phi();
507  if (gphi < 0) gphi += TMath::TwoPi();
508  gphi *= TMath::RadToDeg();
509  Double_t geta = constituents[ic].eta();
510  if ((gphi > fGeom->GetArm1PhiMin()) && (gphi < fGeom->GetArm1PhiMax()) &&
511  (geta > fGeom->GetArm1EtaMin()) && (geta < fGeom->GetArm1EtaMax()))
512  ++gemc;
513  }
514 
515  if (fFillGhost) jet->AddGhost(constituents[ic].px(),
516  constituents[ic].py(),
517  constituents[ic].pz(),
518  constituents[ic].e());
519  }
520  else if (uid >= fgkConstIndexShift) { // track constituent
521  Int_t iColl = uid / fgkConstIndexShift;
522  Int_t tid = uid - iColl * fgkConstIndexShift;
523  iColl--;
524  AliDebug(3,Form("Constituent %d is a track from collection %d and with ID %d", uid, iColl, tid));
525  AliParticleContainer* partCont = GetParticleContainer(iColl);
526  if (!partCont) {
527  AliError(Form("Could not find particle container %d",iColl));
528  continue;
529  }
530  AliVParticle *t = partCont->GetParticle(tid);
531  if (!t) {
532  AliError(Form("Could not find track %d",tid));
533  continue;
534  }
535  if(fFillConstituents){
536  jet->AddParticleConstituent(t, partCont->GetIsEmbedding(), fParticleContainerIndexMap.GlobalIndexFromLocalIndex(partCont, tid));
537  }
538 
539  Double_t cEta = t->Eta();
540  Double_t cPhi = t->Phi();
541  Double_t cPt = t->Pt();
542  Double_t cP = t->P();
543  if (t->Charge() == 0) {
544  neutralE += cP;
545  ++nneutral;
546  if (cPt > maxNe) maxNe = cPt;
547  } else {
548  ++ncharged;
549  if (cPt > maxCh) maxCh = cPt;
550  }
551 
552  // check if MC particle
553  if (TMath::Abs(t->GetLabel()) > fMinMCLabel) mcpt += cPt;
554 
555  if (fGeom) {
556  if (cPhi < 0) cPhi += TMath::TwoPi();
557  cPhi *= TMath::RadToDeg();
558  if ((cPhi > fGeom->GetArm1PhiMin()) && (cPhi < fGeom->GetArm1PhiMax()) &&
559  (cEta > fGeom->GetArm1EtaMin()) && (cEta < fGeom->GetArm1EtaMax())) {
560  emcpt += cPt;
561  ++cemc;
562  }
563  }
564 
565  if (flag == 0 || particlesSubName == "") {
567  }
568  else {
569  // Get the particle container and array corresponding to the subtracted particles
570  partCont = GetParticleContainer(particlesSubName);
571  particles_sub = partCont->GetArray();
572  // Create the new particle in the particles_sub array and add it to the jet
573  Int_t part_sub_id = particles_sub->GetEntriesFast();
574  AliEmcalParticle* part_sub = new ((*particles_sub)[part_sub_id]) AliEmcalParticle(dynamic_cast<AliVTrack*>(t)); // SA: probably need to be fixed!!
575  part_sub->SetPtEtaPhiM(constituents[ic].perp(),constituents[ic].eta(),constituents[ic].phi(),constituents[ic].m());
576  jet->AddTrackAt(fParticleContainerIndexMap.GlobalIndexFromLocalIndex(partCont, part_sub_id), nt);
577  }
578 
579  ++nt;
580  }
581  else if (uid <= -fgkConstIndexShift) { // cluster constituent
582  Int_t iColl = -uid / fgkConstIndexShift;
583  Int_t cid = -uid - iColl * fgkConstIndexShift;
584  iColl--;
585  AliDebug(3,Form("Constituent %d is a cluster from collection %d and with ID %d", uid, iColl, cid));
586  AliClusterContainer* clusCont = GetClusterContainer(iColl);
587  AliVCluster *c = clusCont->GetCluster(cid);
588 
589  if (!c) continue;
590 
592  clusCont->GetMomentum(nP, cid);
593 
594  Double_t cEta = nP.Eta();
595  Double_t cPhi = nP.Phi_0_2pi();
596  Double_t cPt = nP.Pt();
597  Double_t cP = nP.P();
598  Double_t pvec[3] = {nP.Px(), nP.Py(), nP.Pz()};
599  if(fFillConstituents) jet->AddClusterConstituent(c, (AliVCluster::VCluUserDefEnergy_t)clusCont->GetDefaultClusterEnergy(), pvec, clusCont->GetIsEmbedding(), fClusterContainerIndexMap.GlobalIndexFromLocalIndex(clusCont, cid));
600 
601  neutralE += cP;
602  if (cPt > maxNe) maxNe = cPt;
603 
604  // MC particle
605  if (TMath::Abs(c->GetLabel()) > fMinMCLabel) mcpt += c->GetMCEnergyFraction() > 1e-6 ? cPt * c->GetMCEnergyFraction() : cPt;
606 
607  if (fGeom) {
608  if (cPhi<0) cPhi += TMath::TwoPi();
609  cPhi *= TMath::RadToDeg();
610  if ((cPhi > fGeom->GetArm1PhiMin()) && (cPhi < fGeom->GetArm1PhiMax()) &&
611  (cEta > fGeom->GetArm1EtaMin()) && (cEta < fGeom->GetArm1EtaMax())) {
612  emcpt += cPt;
613  ++cemc;
614  }
615  }
616 
617  if (flag == 0 || particlesSubName == "") {
619  }
620  else {
621  // Get the cluster container and array corresponding to the subtracted particles
622  clusCont = GetClusterContainer(particlesSubName);
623  particles_sub = clusCont->GetArray();
624  // Create the new particle in the particles_sub array and add it to the jet
625  Int_t part_sub_id = particles_sub->GetEntriesFast();
626  AliEmcalParticle* part_sub = new ((*particles_sub)[part_sub_id]) AliEmcalParticle(c);
627  part_sub->SetPtEtaPhiM(constituents[ic].perp(),constituents[ic].eta(),constituents[ic].phi(),constituents[ic].m());
628  jet->AddClusterAt(fClusterContainerIndexMap.GlobalIndexFromLocalIndex(clusCont, part_sub_id), nc);
629  }
630 
631  ++nc;
632  ++nneutral;
633  }
634  else {
635  AliError(Form("%s: No logical way to end up here (uid = %d).", GetName(), uid));
636  continue;
637  }
638  }
639 
640  jet->SetNumberOfTracks(nt);
641  jet->SetNumberOfClusters(nc);
642  jet->SetNEF(neutralE / jet->E());
643  jet->SetMaxChargedPt(maxCh);
644  jet->SetMaxNeutralPt(maxNe);
645  if (gall > 0) jet->SetAreaEmc(jet->Area() * gemc / gall);
646  else jet->SetAreaEmc(-1);
647  jet->SetNEmc(cemc);
648  jet->SetNumberOfCharged(ncharged);
649  jet->SetNumberOfNeutrals(nneutral);
650  jet->SetMCPt(mcpt);
651  jet->SetPtEmc(emcpt);
652  jet->SortConstituents();
653 }
654 
662 {
663  if (fLocked) {
664  AliFatal("Jet finder task is locked! Changing properties is not allowed.");
665  return kTRUE;
666  }
667  else {
668  return kFALSE;
669  }
670 }
671 
679 {
680  if(!fIsPSelSet) {
681  fIsPSelSet = kTRUE;
682  fOfflineTriggerMask = offlineTriggerMask;
683  }
684  else {
685  AliWarning("Manually setting the event selection for jet finders is not allowed! Using trigger=old_trigger | your_trigger");
686  fOfflineTriggerMask = fOfflineTriggerMask | offlineTriggerMask;
687  }
688 }
689 
696 {
697  if (IsLocked()) return;
698 
699  TIter nextPartColl(&fParticleCollArray);
700  AliParticleContainer* tracks = 0;
701  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
702  tracks->SetParticleEtaLimits(emi, ema);
703  }
704 }
705 
711 {
712  if (IsLocked()) return;
713 
714  TIter nextClusColl(&fClusterCollArray);
715  AliClusterContainer* clusters = 0;
716  while ((clusters = static_cast<AliClusterContainer*>(nextClusColl()))) {
717  clusters->SetClusPtCut(min);
718  }
719 }
720 
726 {
727  if (IsLocked()) return;
728 
729  TIter nextClusColl(&fClusterCollArray);
730  AliClusterContainer* clusters = 0;
731  while ((clusters = static_cast<AliClusterContainer*>(nextClusColl()))) {
732  clusters->SetClusECut(min);
733  }
734 }
735 
741 {
742  if (IsLocked()) return;
743 
744  TIter nextPartColl(&fParticleCollArray);
745  AliParticleContainer* tracks = 0;
746  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
747  tracks->SetParticlePtCut(min);
748  }
749 }
750 
757 {
758  if (IsLocked()) return;
759 
760  TIter nextPartColl(&fParticleCollArray);
761  AliParticleContainer* tracks = 0;
762  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
763  tracks->SetParticlePhiLimits(pmi, pma);
764  }
765 }
766 
773 fastjet::JetAlgorithm AliEmcalJetTask::ConvertToFJAlgo(EJetAlgo_t algo)
774 {
775  switch(algo) {
777  return fastjet::kt_algorithm;
779  return fastjet::antikt_algorithm;
781  return fastjet::cambridge_algorithm;
783  return fastjet::genkt_algorithm;
785  return fastjet::cambridge_for_passive_algorithm;
787  return fastjet::genkt_for_passive_algorithm;
789  return fastjet::plugin_algorithm;
791  return fastjet::undefined_jet_algorithm;
792 
793  default:
794  ::Error("AliEmcalJetTask::ConvertToFJAlgo", "Jet algorithm %d not recognized!!!", algo);
795  return fastjet::undefined_jet_algorithm;
796  }
797 }
798 
805 fastjet::RecombinationScheme AliEmcalJetTask::ConvertToFJRecoScheme(ERecoScheme_t reco)
806 {
807  switch(reco) {
809  return fastjet::E_scheme;
810 
812  return fastjet::pt_scheme;
813 
815  return fastjet::pt2_scheme;
816 
818  return fastjet::Et_scheme;
819 
821  return fastjet::Et2_scheme;
822 
824  return fastjet::BIpt_scheme;
825 
827  return fastjet::BIpt2_scheme;
828 
830  return fastjet::external_scheme;
831 
832  default:
833  ::Error("AliEmcalJetTask::ConvertToFJRecoScheme", "Recombination scheme %d not recognized!!!", reco);
834  return fastjet::external_scheme;
835  }
836 }
837 
843 
844  //This method has to be called after the run number is known because it needs the EMCal geometry object.
845 
846  UInt_t jetAcceptanceType = AliEmcalJet::kUser; // all jets satify the "no acceptance cut" condition
847 
848  // Check if TPC
849  if( eta < 0.9 && eta > -0.9 ) {
850  jetAcceptanceType |= AliEmcalJet::kTPC;
851  // Check if TPCfid
852  if (eta < 0.9 - r && eta > -0.9 + r)
853  jetAcceptanceType |= AliEmcalJet::kTPCfid;
854  }
855 
856  // Check if EMCAL
857  if( IsJetInEmcal(eta, phi, 0) ) {
858  jetAcceptanceType |= AliEmcalJet::kEMCAL;
859  // Check if EMCALfid
860  if( IsJetInEmcal(eta, phi, r) )
861  jetAcceptanceType |= AliEmcalJet::kEMCALfid;
862  }
863 
864  // Check if DCAL (i.e. eta-phi rectangle spanning DCal, which includes most of PHOS)
865  if( IsJetInDcal(eta, phi, 0) ) {
866  jetAcceptanceType |= AliEmcalJet::kDCAL;
867  // Check if DCALfid
868  if( IsJetInDcal(eta, phi, r) )
869  jetAcceptanceType |= AliEmcalJet::kDCALfid;
870  }
871 
872  // Check if DCALonly (i.e. ONLY DCal, does not include any of PHOS region)
873  if( IsJetInDcalOnly(eta, phi, 0) ) {
874  jetAcceptanceType |= AliEmcalJet::kDCALonly;
875  // Check if DCALonlyfid
876  if( IsJetInDcalOnly(eta, phi, r) )
877  jetAcceptanceType |= AliEmcalJet::kDCALonlyfid;
878  }
879 
880  // Check if PHOS
881  if( IsJetInPhos(eta, phi, 0) ) {
882  jetAcceptanceType |= AliEmcalJet::kPHOS;
883  // Check if PHOSfid
884  if( IsJetInPhos(eta, phi, r) )
885  jetAcceptanceType |= AliEmcalJet::kPHOSfid;
886  }
887 
888  return jetAcceptanceType;
889 }
890 
895 {
896  if (!fGeom) return kFALSE;
897 
898  if ( eta < fGeom->GetArm1EtaMax() - r && eta > fGeom->GetArm1EtaMin() + r ) {
899  if(fRunNumber >= 177295 && fRunNumber <= 197470) {//small SM masked in 2012 and 2013
900  if ( phi < 3.135 - r && phi > 1.405 + r )
901  return kTRUE;
902  }
903  else {
904  if ( phi < fGeom->GetEMCALPhiMax() * TMath::DegToRad() - r && phi > fGeom->GetArm1PhiMin() * TMath::DegToRad() + r)
905  return kTRUE;
906  }
907  }
908 
909  return kFALSE;
910 }
911 
916 {
917  if (!fGeom) return kFALSE;
918  if (eta < fGeom->GetArm1EtaMax() - r && eta > fGeom->GetArm1EtaMin() + r ) {
919  if ( phi < fGeom->GetDCALPhiMax() * TMath::DegToRad() - r && phi > fGeom->GetDCALPhiMin() * TMath::DegToRad() + r)
920  return kTRUE;
921  }
922  return kFALSE;
923 }
924 
932 {
933  if (!fGeom) return kFALSE;
934 
935  if (eta < fGeom->GetArm1EtaMax() - r && eta > fGeom->GetArm1EtaMin() + r) {
936  if ( phi < fGeom->GetDCALPhiMax() * TMath::DegToRad() - r && phi > fGeom->GetDCALPhiMin() * TMath::DegToRad() + r) {
937 
938  if (TMath::Abs(eta) > fGeom->GetDCALInnerExtandedEta() + r) {
939  return kTRUE;
940  }
941  if (r < 1e-6) {
942  if (phi > fGeom->GetEMCGeometry()->GetDCALStandardPhiMax() * TMath::DegToRad())
943  return kTRUE;
944  }
945 
946  }
947  }
948 
949  return kFALSE;
950 }
951 
956 {
957  Double_t etaMax = 0.130;
958  Double_t etaMin = -0.130;
959  Double_t phiMax = 320;
960  Double_t phiMin = 260; // Run 1
961  if (fRunNumber > 209121)
962  phiMin = 250; // Run 2
963 
964  if (eta < etaMax - r && eta > etaMin + r ) {
965  if (phi < phiMax * TMath::DegToRad() - r && phi > phiMin * TMath::DegToRad() + r)
966  return kTRUE;
967  }
968  return kFALSE;
969 }
970 
976 void AliEmcalJetTask::LoadTrackEfficiencyFunction(const std::string & path, const std::string & name)
977 {
978  TString fname(path);
979  if (fname.BeginsWith("alien://")) {
980  TGrid::Connect("alien://");
981  }
982 
983  TFile* file = TFile::Open(path.data());
984 
985  if (!file || file->IsZombie()) {
986  AliErrorStream() << "Could not open artificial track efficiency function file\n";
987  return;
988  }
989 
990  TF1* trackEff = dynamic_cast<TF1*>(file->Get(name.data()));
991 
992  if (trackEff) {
993  AliInfoStream() << Form("Artificial track efficiency function %s loaded from file %s.", name.data(), path.data()) << "\n";
994  }
995  else {
996  AliErrorStream() << Form("Artificial track efficiency function %s not found in file %s.", name.data(), path.data()) << "\n";
997  return;
998  }
999 
1000  fTrackEfficiencyFunction = static_cast<TF1*>(trackEff->Clone());
1002 
1003  file->Close();
1004  delete file;
1005 }
1006 
1025  const TString nTracks, const TString nClusters,
1026  const AliJetContainer::EJetAlgo_t jetAlgo, const Double_t radius, const AliJetContainer::EJetType_t jetType,
1027  const Double_t minTrPt, const Double_t minClPt,
1028  const Double_t ghostArea, const AliJetContainer::ERecoScheme_t reco,
1029  const TString tag, const Double_t minJetPt,
1030  const Bool_t lockTask, const Bool_t bFillGhosts
1031 )
1032 {
1033  // Get the pointer to the existing analysis manager via the static access method
1034  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1035  if (!mgr) {
1036  ::Error("AddTaskEmcalJet", "No analysis manager to connect to.");
1037  return 0;
1038  }
1039 
1040  // Check the analysis type using the event handlers connected to the analysis manager
1041  AliVEventHandler* handler = mgr->GetInputEventHandler();
1042  if (!handler) {
1043  ::Error("AddTaskEmcalJet", "This task requires an input event handler");
1044  return 0;
1045  }
1046 
1047  EDataType_t dataType = kUnknownDataType;
1048 
1049  if (handler->InheritsFrom("AliESDInputHandler")) {
1050  dataType = kESD;
1051  }
1052  else if (handler->InheritsFrom("AliAODInputHandler")) {
1053  dataType = kAOD;
1054  }
1055 
1056  //-------------------------------------------------------
1057  // Init the task and do settings
1058  //-------------------------------------------------------
1059 
1060  TString trackName(nTracks);
1061  TString clusName(nClusters);
1062 
1063  if (trackName == "usedefault") {
1064  if (dataType == kESD) {
1065  trackName = "Tracks";
1066  }
1067  else if (dataType == kAOD) {
1068  trackName = "tracks";
1069  }
1070  else {
1071  trackName = "";
1072  }
1073  }
1074 
1075  if (clusName == "usedefault") {
1076  if (dataType == kESD) {
1077  clusName = "CaloClusters";
1078  }
1079  else if (dataType == kAOD) {
1080  clusName = "caloClusters";
1081  }
1082  else {
1083  clusName = "";
1084  }
1085  }
1086 
1087  AliParticleContainer* partCont = 0;
1088  if (trackName == "mcparticles") {
1089  AliMCParticleContainer* mcpartCont = new AliMCParticleContainer(trackName);
1090  partCont = mcpartCont;
1091  }
1092  else if (trackName == "tracks" || trackName == "Tracks") {
1093  AliTrackContainer* trackCont = new AliTrackContainer(trackName);
1094  partCont = trackCont;
1095  }
1096  else if (!trackName.IsNull()) {
1097  partCont = new AliParticleContainer(trackName);
1098  }
1099  if (partCont) partCont->SetParticlePtCut(minTrPt);
1100 
1101  AliClusterContainer* clusCont = 0;
1102  if (!clusName.IsNull()) {
1103  clusCont = new AliClusterContainer(clusName);
1104  clusCont->SetClusECut(0.);
1105  clusCont->SetClusPtCut(0.);
1106  clusCont->SetClusHadCorrEnergyCut(minClPt);
1107  clusCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
1108  }
1109 
1110  switch (jetType) {
1112  if (partCont) partCont->SetCharge(AliParticleContainer::kCharged);
1113  break;
1115  if (partCont) partCont->SetCharge(AliParticleContainer::kNeutral);
1116  break;
1117  default:
1118  break;
1119  }
1120 
1121  TString name = AliJetContainer::GenerateJetName(jetType, jetAlgo, reco, radius, partCont, clusCont, tag);
1122 
1123  Printf("Jet task name: %s", name.Data());
1124 
1125  AliEmcalJetTask* mgrTask = static_cast<AliEmcalJetTask *>(mgr->GetTask(name.Data()));
1126  if (mgrTask) return mgrTask;
1127 
1128  AliEmcalJetTask* jetTask = new AliEmcalJetTask(name);
1129  jetTask->SetJetType(jetType);
1130  jetTask->SetJetAlgo(jetAlgo);
1131  jetTask->SetRecombScheme(reco);
1132  jetTask->SetRadius(radius);
1133  if (partCont) jetTask->AdoptParticleContainer(partCont);
1134  if (clusCont) jetTask->AdoptClusterContainer(clusCont);
1135  jetTask->SetJetsName(tag);
1136  jetTask->SetMinJetPt(minJetPt);
1137  jetTask->SetGhostArea(ghostArea);
1138 
1139  if (bFillGhosts) jetTask->SetFillGhost();
1140  if (lockTask) jetTask->SetLocked();
1141 
1142  // Final settings, pass to manager and set the containers
1143 
1144  mgr->AddTask(jetTask);
1145 
1146  // Create containers for input/output
1147  AliAnalysisDataContainer* cinput = mgr->GetCommonInputContainer();
1148  mgr->ConnectInput(jetTask, 0, cinput);
1149 
1150  return jetTask;
1151 }
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 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