AliPhysics  9c7580a (9c7580a)
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(),
77  fApplyArtificialTrackingEfficiency(kFALSE),
78  fLocked(0),
79  fFillConstituents(kTRUE),
80  fJetsName(),
81  fIsInit(0),
82  fIsPSelSet(0),
83  fIsEmcPart(0),
84  fLegacyMode(kFALSE),
85  fFillGhost(kFALSE),
86  fJets(0),
87  fFastJetWrapper("AliEmcalJetTask","AliEmcalJetTask"),
88  fClusterContainerIndexMap(),
89  fParticleContainerIndexMap()
90 {
91 }
92 
99  fJetsTag("Jets"),
100  fJetType(AliJetContainer::kFullJet),
101  fJetAlgo(AliJetContainer::antikt_algorithm),
102  fRecombScheme(AliJetContainer::pt_scheme),
103  fRadius(0.4),
104  fMinJetArea(0.001),
105  fMinJetPt(1.0),
106  fJetPhiMin(-10),
107  fJetPhiMax(+10),
108  fJetEtaMin(-1),
109  fJetEtaMax(+1),
110  fGhostArea(0.005),
111  fTrackEfficiency(1.),
112  fUtilities(0),
116  fLocked(0),
117  fFillConstituents(kTRUE),
118  fJetsName(),
119  fIsInit(0),
120  fIsPSelSet(0),
121  fIsEmcPart(0),
122  fLegacyMode(kFALSE),
123  fFillGhost(kFALSE),
124  fJets(0),
125  fFastJetWrapper(name,name),
128 {
129 }
130 
135 {
136 }
137 
143 {
144  if (!fUtilities) fUtilities = new TObjArray();
145  if (fUtilities->FindObject(utility)) {
146  Error("AddUtility", "Jet utility %s already connected.", utility->GetName());
147  return utility;
148  }
149  fUtilities->Add(utility);
150  utility->SetJetTask(this);
151 
152  return utility;
153 }
154 
160 {
161  TIter next(fUtilities);
162  AliEmcalJetUtility *utility = 0;
163  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->Init();
164 }
170 {
171  TIter next(fUtilities);
172  AliEmcalJetUtility *utility = 0;
173  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->InitEvent(fFastJetWrapper);
174 }
175 
182 {
183  TIter next(fUtilities);
184  AliEmcalJetUtility *utility = 0;
185  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->Prepare(fFastJetWrapper);
186 }
187 
193 {
194  TIter next(fUtilities);
195  AliEmcalJetUtility *utility = 0;
196  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->ProcessJet(jet, ij, fFastJetWrapper);
197 }
198 
204 {
205  TIter next(fUtilities);
206  AliEmcalJetUtility *utility = 0;
207  while ((utility=static_cast<AliEmcalJetUtility*>(next()))) utility->Terminate(fFastJetWrapper);
208 }
209 
215 {
216  InitEvent();
217  // clear the jet array (normally a null operation)
218  fJets->Delete();
219  Int_t n = FindJets();
220 
221  if (n == 0) return kFALSE;
222 
223  FillJetBranch();
224 
225  return kTRUE;
226 }
227 
236 {
237  if (fParticleCollArray.GetEntriesFast() == 0 && fClusterCollArray.GetEntriesFast() == 0){
238  AliError("No tracks or clusters, returning.");
239  return 0;
240  }
241 
243 
244  AliDebug(2,Form("Jet type = %d", fJetType));
245 
246  Int_t iColl = 1;
247  TIter nextPartColl(&fParticleCollArray);
248  AliParticleContainer* tracks = 0;
249  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
250  AliDebug(2,Form("Tracks from collection %d: '%s'. Embedded: %i, nTracks: %i", iColl-1, tracks->GetName(), tracks->GetIsEmbedding(), tracks->GetNParticles()));
252  for (AliParticleIterableMomentumContainer::iterator it = itcont.begin(); it != itcont.end(); it++) {
253 
254  // Apply artificial track inefficiency, if supplied (either constant or pT-dependent)
256  if (fTrackEfficiencyOnlyForEmbedding == kFALSE || (fTrackEfficiencyOnlyForEmbedding == kTRUE && tracks->GetIsEmbedding())) {
257 
258  Double_t trackEfficiency = fTrackEfficiencyFunction.Eval(it->first.Pt());
259  Double_t rnd = gRandom->Rndm();
260  if (trackEfficiency < rnd) {
261  AliDebug(2,Form("Track %d rejected due to artificial tracking inefficiency", it.current_index()));
262  continue;
263  }
264  }
265  }
266 
267  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()));
268  Int_t uid = it.current_index() + fgkConstIndexShift * iColl;
269  fFastJetWrapper.AddInputVector(it->first.Px(), it->first.Py(), it->first.Pz(), it->first.E(), uid);
270  }
271  iColl++;
272  }
273 
274  iColl = 1;
275  TIter nextClusColl(&fClusterCollArray);
276  AliClusterContainer* clusters = 0;
277  while ((clusters = static_cast<AliClusterContainer*>(nextClusColl()))) {
278  AliDebug(2,Form("Clusters from collection %d: '%s'. Embedded: %i, nClusters: %i", iColl-1, clusters->GetName(), clusters->GetIsEmbedding(), clusters->GetNClusters()));
280  for (AliClusterIterableMomentumContainer::iterator it = itcont.begin(); it != itcont.end(); it++) {
281  AliDebug(2,Form("Cluster %d accepted (label = %d, energy = %.3f)", it.current_index(), it->second->GetLabel(), it->first.E()));
282  Int_t uid = -it.current_index() - fgkConstIndexShift * iColl;
283  fFastJetWrapper.AddInputVector(it->first.Px(), it->first.Py(), it->first.Pz(), it->first.E(), uid);
284  }
285  iColl++;
286  }
287 
288  if (fFastJetWrapper.GetInputVectors().size() == 0) return 0;
289 
290  // run jet finder
292 
293  return fFastJetWrapper.GetInclusiveJets().size();
294 }
295 
302 {
304 
305  // loop over fastjet jets
306  std::vector<fastjet::PseudoJet> jets_incl = fFastJetWrapper.GetInclusiveJets();
307  // sort jets according to jet pt
308  static Int_t indexes[9999] = {-1};
309  GetSortedArray(indexes, jets_incl);
310 
311  AliDebug(1,Form("%d jets found", (Int_t)jets_incl.size()));
312  for (UInt_t ijet = 0, jetCount = 0; ijet < jets_incl.size(); ++ijet) {
313  Int_t ij = indexes[ijet];
314  AliDebug(3,Form("Jet pt = %f, area = %f", jets_incl[ij].perp(), fFastJetWrapper.GetJetArea(ij)));
315 
316  if (jets_incl[ij].perp() < fMinJetPt) continue;
317  if (fFastJetWrapper.GetJetArea(ij) < fMinJetArea) continue;
318  if ((jets_incl[ij].eta() < fJetEtaMin) || (jets_incl[ij].eta() > fJetEtaMax) ||
319  (jets_incl[ij].phi() < fJetPhiMin) || (jets_incl[ij].phi() > fJetPhiMax))
320  continue;
321 
322  AliEmcalJet *jet = new ((*fJets)[jetCount])
323  AliEmcalJet(jets_incl[ij].perp(), jets_incl[ij].eta(), jets_incl[ij].phi(), jets_incl[ij].m());
324  jet->SetLabel(ij);
325 
326  fastjet::PseudoJet area(fFastJetWrapper.GetJetAreaVector(ij));
327  jet->SetArea(area.perp());
328  jet->SetAreaEta(area.eta());
329  jet->SetAreaPhi(area.phi());
330  jet->SetAreaE(area.E());
332 
333  // Fill constituent info
334  std::vector<fastjet::PseudoJet> constituents(fFastJetWrapper.GetJetConstituents(ij));
335  FillJetConstituents(jet, constituents, constituents);
336 
337  if (fGeom) {
338  if ((jet->Phi() > fGeom->GetArm1PhiMin() * TMath::DegToRad()) &&
339  (jet->Phi() < fGeom->GetArm1PhiMax() * TMath::DegToRad()) &&
340  (jet->Eta() > fGeom->GetArm1EtaMin()) &&
341  (jet->Eta() < fGeom->GetArm1EtaMax()))
342  jet->SetAxisInEmcal(kTRUE);
343  }
344 
345  ExecuteUtilities(jet, ij);
346 
347  AliDebug(2,Form("Added jet n. %d, pt = %f, area = %f, constituents = %d", jetCount, jet->Pt(), jet->Area(), jet->GetNumberOfConstituents()));
348  jetCount++;
349  }
350 
352 }
353 
360 Bool_t AliEmcalJetTask::GetSortedArray(Int_t indexes[], std::vector<fastjet::PseudoJet> array) const
361 {
362  static Float_t pt[9999] = {0};
363 
364  const Int_t n = (Int_t)array.size();
365 
366  if (n < 1)
367  return kFALSE;
368 
369  for (Int_t i = 0; i < n; i++)
370  pt[i] = array[i].perp();
371 
372  TMath::Sort(n, pt, indexes);
373 
374  return kTRUE;
375 }
376 
383 {
384 
385  // If a constant artificial track efficiency is supplied, create a TF1 that is constant in pT
386  if (fTrackEfficiency < 1.) {
387  // If a TF1 was already loaded, throw an error
389  AliError(Form("%s: fTrackEfficiencyFunction was already loaded! Do not apply multiple artificial track efficiencies.", GetName()));
390  }
391 
392  fTrackEfficiencyFunction = TF1("trackEfficiencyFunction", "[0]", 0., fMaxBinPt);
395  }
396 
397  // If artificial tracking efficiency is enabled (either constant or pT-depdendent), set up random number generator
399  if (gRandom) {
400  delete gRandom;
401  }
402  gRandom = new TRandom3(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  Double_t cP = t->P();
545  if (t->Charge() == 0) {
546  neutralE += cP;
547  ++nneutral;
548  if (cPt > maxNe) maxNe = cPt;
549  } else {
550  ++ncharged;
551  if (cPt > maxCh) maxCh = cPt;
552  }
553 
554  // check if MC particle
555  if (TMath::Abs(t->GetLabel()) > fMinMCLabel) mcpt += cPt;
556 
557  if (fGeom) {
558  if (cPhi < 0) cPhi += TMath::TwoPi();
559  cPhi *= TMath::RadToDeg();
560  if ((cPhi > fGeom->GetArm1PhiMin()) && (cPhi < fGeom->GetArm1PhiMax()) &&
561  (cEta > fGeom->GetArm1EtaMin()) && (cEta < fGeom->GetArm1EtaMax())) {
562  emcpt += cPt;
563  ++cemc;
564  }
565  }
566 
567  if (flag == 0 || particlesSubName == "") {
569  }
570  else {
571  // Get the particle container and array corresponding to the subtracted particles
572  partCont = GetParticleContainer(particlesSubName);
573  particles_sub = partCont->GetArray();
574  // Create the new particle in the particles_sub array and add it to the jet
575  Int_t part_sub_id = particles_sub->GetEntriesFast();
576  AliEmcalParticle* part_sub = new ((*particles_sub)[part_sub_id]) AliEmcalParticle(dynamic_cast<AliVTrack*>(t)); // SA: probably need to be fixed!!
577  part_sub->SetPtEtaPhiM(constituents[ic].perp(),constituents[ic].eta(),constituents[ic].phi(),constituents[ic].m());
578  jet->AddTrackAt(fParticleContainerIndexMap.GlobalIndexFromLocalIndex(partCont, part_sub_id), nt);
579  }
580 
581  ++nt;
582  }
583  else if (uid <= -fgkConstIndexShift) { // cluster constituent
584  Int_t iColl = -uid / fgkConstIndexShift;
585  Int_t cid = -uid - iColl * fgkConstIndexShift;
586  iColl--;
587  AliDebug(3,Form("Constituent %d is a cluster from collection %d and with ID %d", uid, iColl, cid));
588  AliClusterContainer* clusCont = GetClusterContainer(iColl);
589  AliVCluster *c = clusCont->GetCluster(cid);
590 
591  if (!c) continue;
592 
594  clusCont->GetMomentum(nP, cid);
595 
596  Double_t cEta = nP.Eta();
597  Double_t cPhi = nP.Phi_0_2pi();
598  Double_t cPt = nP.Pt();
599  Double_t cP = nP.P();
600  Double_t pvec[3] = {nP.Px(), nP.Py(), nP.Pz()};
601  if(fFillConstituents) jet->AddClusterConstituent(c, (AliVCluster::VCluUserDefEnergy_t)clusCont->GetDefaultClusterEnergy(), pvec, clusCont->GetIsEmbedding(), fClusterContainerIndexMap.GlobalIndexFromLocalIndex(clusCont, cid));
602 
603  neutralE += cP;
604  if (cPt > maxNe) maxNe = cPt;
605 
606  // MC particle
607  if (TMath::Abs(c->GetLabel()) > fMinMCLabel) mcpt += c->GetMCEnergyFraction() > 1e-6 ? cPt * c->GetMCEnergyFraction() : cPt;
608 
609  if (fGeom) {
610  if (cPhi<0) cPhi += TMath::TwoPi();
611  cPhi *= TMath::RadToDeg();
612  if ((cPhi > fGeom->GetArm1PhiMin()) && (cPhi < fGeom->GetArm1PhiMax()) &&
613  (cEta > fGeom->GetArm1EtaMin()) && (cEta < fGeom->GetArm1EtaMax())) {
614  emcpt += cPt;
615  ++cemc;
616  }
617  }
618 
619  if (flag == 0 || particlesSubName == "") {
621  }
622  else {
623  // Get the cluster container and array corresponding to the subtracted particles
624  clusCont = GetClusterContainer(particlesSubName);
625  particles_sub = clusCont->GetArray();
626  // Create the new particle in the particles_sub array and add it to the jet
627  Int_t part_sub_id = particles_sub->GetEntriesFast();
628  AliEmcalParticle* part_sub = new ((*particles_sub)[part_sub_id]) AliEmcalParticle(c);
629  part_sub->SetPtEtaPhiM(constituents[ic].perp(),constituents[ic].eta(),constituents[ic].phi(),constituents[ic].m());
630  jet->AddClusterAt(fClusterContainerIndexMap.GlobalIndexFromLocalIndex(clusCont, part_sub_id), nc);
631  }
632 
633  ++nc;
634  ++nneutral;
635  }
636  else {
637  AliError(Form("%s: No logical way to end up here (uid = %d).", GetName(), uid));
638  continue;
639  }
640  }
641 
642  jet->SetNumberOfTracks(nt);
643  jet->SetNumberOfClusters(nc);
644  jet->SetNEF(neutralE / jet->E());
645  jet->SetMaxChargedPt(maxCh);
646  jet->SetMaxNeutralPt(maxNe);
647  if (gall > 0) jet->SetAreaEmc(jet->Area() * gemc / gall);
648  else jet->SetAreaEmc(-1);
649  jet->SetNEmc(cemc);
650  jet->SetNumberOfCharged(ncharged);
651  jet->SetNumberOfNeutrals(nneutral);
652  jet->SetMCPt(mcpt);
653  jet->SetPtEmc(emcpt);
654  jet->SortConstituents();
655 }
656 
664 {
665  if (fLocked) {
666  AliFatal("Jet finder task is locked! Changing properties is not allowed.");
667  return kTRUE;
668  }
669  else {
670  return kFALSE;
671  }
672 }
673 
681 {
682  if(!fIsPSelSet) {
683  fIsPSelSet = kTRUE;
684  fOfflineTriggerMask = offlineTriggerMask;
685  }
686  else {
687  AliWarning("Manually setting the event selection for jet finders is not allowed! Using trigger=old_trigger | your_trigger");
688  fOfflineTriggerMask = fOfflineTriggerMask | offlineTriggerMask;
689  }
690 }
691 
698 {
699  if (IsLocked()) return;
700 
701  TIter nextPartColl(&fParticleCollArray);
702  AliParticleContainer* tracks = 0;
703  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
704  tracks->SetParticleEtaLimits(emi, ema);
705  }
706 }
707 
713 {
714  if (IsLocked()) return;
715 
716  TIter nextClusColl(&fClusterCollArray);
717  AliClusterContainer* clusters = 0;
718  while ((clusters = static_cast<AliClusterContainer*>(nextClusColl()))) {
719  clusters->SetClusPtCut(min);
720  }
721 }
722 
728 {
729  if (IsLocked()) return;
730 
731  TIter nextClusColl(&fClusterCollArray);
732  AliClusterContainer* clusters = 0;
733  while ((clusters = static_cast<AliClusterContainer*>(nextClusColl()))) {
734  clusters->SetClusECut(min);
735  }
736 }
737 
743 {
744  if (IsLocked()) return;
745 
746  TIter nextPartColl(&fParticleCollArray);
747  AliParticleContainer* tracks = 0;
748  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
749  tracks->SetParticlePtCut(min);
750  }
751 }
752 
759 {
760  if (IsLocked()) return;
761 
762  TIter nextPartColl(&fParticleCollArray);
763  AliParticleContainer* tracks = 0;
764  while ((tracks = static_cast<AliParticleContainer*>(nextPartColl()))) {
765  tracks->SetParticlePhiLimits(pmi, pma);
766  }
767 }
768 
775 fastjet::JetAlgorithm AliEmcalJetTask::ConvertToFJAlgo(EJetAlgo_t algo)
776 {
777  switch(algo) {
779  return fastjet::kt_algorithm;
781  return fastjet::antikt_algorithm;
783  return fastjet::cambridge_algorithm;
785  return fastjet::genkt_algorithm;
787  return fastjet::cambridge_for_passive_algorithm;
789  return fastjet::genkt_for_passive_algorithm;
791  return fastjet::plugin_algorithm;
793  return fastjet::undefined_jet_algorithm;
794 
795  default:
796  ::Error("AliEmcalJetTask::ConvertToFJAlgo", "Jet algorithm %d not recognized!!!", algo);
797  return fastjet::undefined_jet_algorithm;
798  }
799 }
800 
807 fastjet::RecombinationScheme AliEmcalJetTask::ConvertToFJRecoScheme(ERecoScheme_t reco)
808 {
809  switch(reco) {
811  return fastjet::E_scheme;
812 
814  return fastjet::pt_scheme;
815 
817  return fastjet::pt2_scheme;
818 
820  return fastjet::Et_scheme;
821 
823  return fastjet::Et2_scheme;
824 
826  return fastjet::BIpt_scheme;
827 
829  return fastjet::BIpt2_scheme;
830 
832  return fastjet::external_scheme;
833 
834  default:
835  ::Error("AliEmcalJetTask::ConvertToFJRecoScheme", "Recombination scheme %d not recognized!!!", reco);
836  return fastjet::external_scheme;
837  }
838 }
839 
845 
846  //This method has to be called after the run number is known because it needs the EMCal geometry object.
847 
848  UInt_t jetAcceptanceType = AliEmcalJet::kUser; // all jets satify the "no acceptance cut" condition
849 
850  // Check if TPC
851  if( eta < 0.9 && eta > -0.9 ) {
852  jetAcceptanceType |= AliEmcalJet::kTPC;
853  // Check if TPCfid
854  if (eta < 0.9 - r && eta > -0.9 + r)
855  jetAcceptanceType |= AliEmcalJet::kTPCfid;
856  }
857 
858  // Check if EMCAL
859  if( IsJetInEmcal(eta, phi, 0) ) {
860  jetAcceptanceType |= AliEmcalJet::kEMCAL;
861  // Check if EMCALfid
862  if( IsJetInEmcal(eta, phi, r) )
863  jetAcceptanceType |= AliEmcalJet::kEMCALfid;
864  }
865 
866  // Check if DCAL (i.e. eta-phi rectangle spanning DCal, which includes most of PHOS)
867  if( IsJetInDcal(eta, phi, 0) ) {
868  jetAcceptanceType |= AliEmcalJet::kDCAL;
869  // Check if DCALfid
870  if( IsJetInDcal(eta, phi, r) )
871  jetAcceptanceType |= AliEmcalJet::kDCALfid;
872  }
873 
874  // Check if DCALonly (i.e. ONLY DCal, does not include any of PHOS region)
875  if( IsJetInDcalOnly(eta, phi, 0) ) {
876  jetAcceptanceType |= AliEmcalJet::kDCALonly;
877  // Check if DCALonlyfid
878  if( IsJetInDcalOnly(eta, phi, r) )
879  jetAcceptanceType |= AliEmcalJet::kDCALonlyfid;
880  }
881 
882  // Check if PHOS
883  if( IsJetInPhos(eta, phi, 0) ) {
884  jetAcceptanceType |= AliEmcalJet::kPHOS;
885  // Check if PHOSfid
886  if( IsJetInPhos(eta, phi, r) )
887  jetAcceptanceType |= AliEmcalJet::kPHOSfid;
888  }
889 
890  return jetAcceptanceType;
891 }
892 
897 {
898  if (!fGeom) return kFALSE;
899 
900  if ( eta < fGeom->GetArm1EtaMax() - r && eta > fGeom->GetArm1EtaMin() + r ) {
901  if(fRunNumber >= 177295 && fRunNumber <= 197470) {//small SM masked in 2012 and 2013
902  if ( phi < 3.135 - r && phi > 1.405 + r )
903  return kTRUE;
904  }
905  else {
906  if ( phi < fGeom->GetEMCALPhiMax() * TMath::DegToRad() - r && phi > fGeom->GetArm1PhiMin() * TMath::DegToRad() + r)
907  return kTRUE;
908  }
909  }
910 
911  return kFALSE;
912 }
913 
918 {
919  if (!fGeom) return kFALSE;
920  if (eta < fGeom->GetArm1EtaMax() - r && eta > fGeom->GetArm1EtaMin() + r ) {
921  if ( phi < fGeom->GetDCALPhiMax() * TMath::DegToRad() - r && phi > fGeom->GetDCALPhiMin() * TMath::DegToRad() + r)
922  return kTRUE;
923  }
924  return kFALSE;
925 }
926 
934 {
935  if (!fGeom) return kFALSE;
936 
937  if (eta < fGeom->GetArm1EtaMax() - r && eta > fGeom->GetArm1EtaMin() + r) {
938  if ( phi < fGeom->GetDCALPhiMax() * TMath::DegToRad() - r && phi > fGeom->GetDCALPhiMin() * TMath::DegToRad() + r) {
939 
940  if (TMath::Abs(eta) > fGeom->GetDCALInnerExtandedEta() + r) {
941  return kTRUE;
942  }
943  if (r < 1e-6) {
944  if (phi > fGeom->GetEMCGeometry()->GetDCALStandardPhiMax() * TMath::DegToRad())
945  return kTRUE;
946  }
947 
948  }
949  }
950 
951  return kFALSE;
952 }
953 
958 {
959  Double_t etaMax = 0.130;
960  Double_t etaMin = -0.130;
961  Double_t phiMax = 320;
962  Double_t phiMin = 260; // Run 1
963  if (fRunNumber > 209121)
964  phiMin = 250; // Run 2
965 
966  if (eta < etaMax - r && eta > etaMin + r ) {
967  if (phi < phiMax * TMath::DegToRad() - r && phi > phiMin * TMath::DegToRad() + r)
968  return kTRUE;
969  }
970  return kFALSE;
971 }
972 
978 void AliEmcalJetTask::LoadTrackEfficiencyFunction(const std::string & path, const std::string & name)
979 {
980  TString fname(path);
981  if (fname.BeginsWith("alien://")) {
982  TGrid::Connect("alien://");
983  }
984 
985  TFile* file = TFile::Open(path.data());
986 
987  if (!file || file->IsZombie()) {
988  AliErrorStream() << "Could not open artificial track efficiency function file\n";
989  return;
990  }
991 
992  TF1* trackEff = dynamic_cast<TF1*>(file->Get(name.data()));
993 
994  if (trackEff) {
995  AliInfoStream() << Form("Artificial track efficiency function %s loaded from file %s.", name.data(), path.data()) << "\n";
996  }
997  else {
998  AliErrorStream() << Form("Artificial track efficiency function %s not found in file %s.", name.data(), path.data()) << "\n";
999  return;
1000  }
1001 
1002  TF1* trackEffClone = static_cast<TF1*>(trackEff->Clone());
1003  fTrackEfficiencyFunction = *trackEffClone;
1005 
1006  file->Close();
1007  delete file;
1008 }
1009 
1028  const TString nTracks, const TString nClusters,
1029  const AliJetContainer::EJetAlgo_t jetAlgo, const Double_t radius, const AliJetContainer::EJetType_t jetType,
1030  const Double_t minTrPt, const Double_t minClPt,
1031  const Double_t ghostArea, const AliJetContainer::ERecoScheme_t reco,
1032  const TString tag, const Double_t minJetPt,
1033  const Bool_t lockTask, const Bool_t bFillGhosts
1034 )
1035 {
1036  // Get the pointer to the existing analysis manager via the static access method
1037  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1038  if (!mgr) {
1039  ::Error("AddTaskEmcalJet", "No analysis manager to connect to.");
1040  return 0;
1041  }
1042 
1043  // Check the analysis type using the event handlers connected to the analysis manager
1044  AliVEventHandler* handler = mgr->GetInputEventHandler();
1045  if (!handler) {
1046  ::Error("AddTaskEmcalJet", "This task requires an input event handler");
1047  return 0;
1048  }
1049 
1050  EDataType_t dataType = kUnknownDataType;
1051 
1052  if (handler->InheritsFrom("AliESDInputHandler")) {
1053  dataType = kESD;
1054  }
1055  else if (handler->InheritsFrom("AliAODInputHandler")) {
1056  dataType = kAOD;
1057  }
1058 
1059  //-------------------------------------------------------
1060  // Init the task and do settings
1061  //-------------------------------------------------------
1062 
1063  TString trackName(nTracks);
1064  TString clusName(nClusters);
1065 
1066  if (trackName == "usedefault") {
1067  if (dataType == kESD) {
1068  trackName = "Tracks";
1069  }
1070  else if (dataType == kAOD) {
1071  trackName = "tracks";
1072  }
1073  else {
1074  trackName = "";
1075  }
1076  }
1077 
1078  if (clusName == "usedefault") {
1079  if (dataType == kESD) {
1080  clusName = "CaloClusters";
1081  }
1082  else if (dataType == kAOD) {
1083  clusName = "caloClusters";
1084  }
1085  else {
1086  clusName = "";
1087  }
1088  }
1089 
1090  AliParticleContainer* partCont = 0;
1091  if (trackName == "mcparticles") {
1092  AliMCParticleContainer* mcpartCont = new AliMCParticleContainer(trackName);
1093  partCont = mcpartCont;
1094  }
1095  else if (trackName == "tracks" || trackName == "Tracks") {
1096  AliTrackContainer* trackCont = new AliTrackContainer(trackName);
1097  partCont = trackCont;
1098  }
1099  else if (!trackName.IsNull()) {
1100  partCont = new AliParticleContainer(trackName);
1101  }
1102  if (partCont) partCont->SetParticlePtCut(minTrPt);
1103 
1104  AliClusterContainer* clusCont = 0;
1105  if (!clusName.IsNull()) {
1106  clusCont = new AliClusterContainer(clusName);
1107  clusCont->SetClusECut(0.);
1108  clusCont->SetClusPtCut(0.);
1109  clusCont->SetClusHadCorrEnergyCut(minClPt);
1110  clusCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
1111  }
1112 
1113  switch (jetType) {
1115  if (partCont) partCont->SetCharge(AliParticleContainer::kCharged);
1116  break;
1118  if (partCont) partCont->SetCharge(AliParticleContainer::kNeutral);
1119  break;
1120  default:
1121  break;
1122  }
1123 
1124  TString name = AliJetContainer::GenerateJetName(jetType, jetAlgo, reco, radius, partCont, clusCont, tag);
1125 
1126  Printf("Jet task name: %s", name.Data());
1127 
1128  AliEmcalJetTask* mgrTask = static_cast<AliEmcalJetTask *>(mgr->GetTask(name.Data()));
1129  if (mgrTask) return mgrTask;
1130 
1131  AliEmcalJetTask* jetTask = new AliEmcalJetTask(name);
1132  jetTask->SetJetType(jetType);
1133  jetTask->SetJetAlgo(jetAlgo);
1134  jetTask->SetRecombScheme(reco);
1135  jetTask->SetRadius(radius);
1136  if (partCont) jetTask->AdoptParticleContainer(partCont);
1137  if (clusCont) jetTask->AdoptClusterContainer(clusCont);
1138  jetTask->SetJetsName(tag);
1139  jetTask->SetMinJetPt(minJetPt);
1140  jetTask->SetGhostArea(ghostArea);
1141 
1142  if (bFillGhosts) jetTask->SetFillGhost();
1143  if (lockTask) jetTask->SetLocked();
1144 
1145  // Final settings, pass to manager and set the containers
1146 
1147  mgr->AddTask(jetTask);
1148 
1149  // Create containers for input/output
1150  AliAnalysisDataContainer* cinput = mgr->GetCommonInputContainer();
1151  mgr->ConnectInput(jetTask, 0, cinput);
1152 
1153  return jetTask;
1154 }
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
TF1 fTrackEfficiencyFunction
Function that describes the artificial tracking efficiency to be applied on top of the nominal tracki...
void SetJetAlgo(EJetAlgo_t a)
virtual ~AliEmcalJetTask()
TRandom * gRandom
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
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
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