AliPhysics  ec7afe5 (ec7afe5)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliEmcalJet.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-1999, 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 #include "AliEmcalJet.h"
16 
17 #include "AliLog.h"
18 #include "Riostream.h"
19 
20 #include "AliParticleContainer.h"
21 #include "AliClusterContainer.h"
22 
26 
31  AliVParticle(),
32  fPt(0),
33  fEta(0),
34  fPhi(0),
35  fM(0),
36  fNEF(0),
37  fArea(0),
38  fAreaEta(0),
39  fAreaPhi(0),
40  fAreaE(0),
41  fAreaEmc(-1),
42  fAxisInEmcal(0),
43  fFlavourTagging(0),
44  fFlavourTracks(0),
45  fMaxCPt(0),
46  fMaxNPt(0),
47  fMCPt(0),
48  fNn(0),
49  fNch(0),
50  fPtEmc(0),
51  fNEmc(0),
52  fClusterIDs(),
53  fTrackIDs(),
54  fMatched(2),
55  fMatchingType(0),
56  fTaggedJet(0x0),
57  fTagStatus(-1),
58  fPtSub(0),
59  fPtSubVect(0),
60  fTriggers(0),
61  fLabel(-1),
62  fHasGhost(kFALSE),
63  fGhosts(),
64  fJetShapeProperties(0),
65  fJetAcceptanceType(0)
66 {
67  fClosestJets[0] = 0;
68  fClosestJets[1] = 0;
69  fClosestJetsDist[0] = 999;
70  fClosestJetsDist[1] = 999;
71 }
72 
81  AliVParticle(),
82  fPt(TMath::Sqrt(px * px + py* py)),
83  fEta(TMath::ASinH(pz / fPt)),
84  fPhi(0),
85  fM(0),
86  fNEF(0),
87  fArea(0),
88  fAreaEta(0),
89  fAreaPhi(0),
90  fAreaE(0),
91  fAreaEmc(-1),
92  fAxisInEmcal(0),
93  fFlavourTagging(0),
94  fFlavourTracks(0),
95  fMaxCPt(0),
96  fMaxNPt(0),
97  fMCPt(0),
98  fNn(0),
99  fNch(0),
100  fPtEmc(0),
101  fNEmc(0),
102  fClusterIDs(),
103  fTrackIDs(),
104  fMatched(2),
105  fMatchingType(0),
106  fTaggedJet(0x0),
107  fTagStatus(-1),
108  fPtSub(0),
109  fPtSubVect(0),
110  fTriggers(0),
111  fLabel(-1),
112  fHasGhost(kFALSE),
113  fGhosts(),
114  fJetShapeProperties(0),
115  fJetAcceptanceType(0)
116 {
117  if (fPt != 0) {
118  fPhi = TVector2::Phi_0_2pi(TMath::ATan2(py, px));
119  }
120 
121  fClosestJets[0] = 0;
122  fClosestJets[1] = 0;
123  fClosestJetsDist[0] = 999;
124  fClosestJetsDist[1] = 999;
125 }
126 
136  AliVParticle(),
137  fPt(pt),
138  fEta(eta),
139  fPhi(phi),
140  fM(m),
141  fNEF(0),
142  fArea(0),
143  fAreaEta(0),
144  fAreaPhi(0),
145  fAreaE(0),
146  fAreaEmc(-1),
147  fAxisInEmcal(0),
148  fFlavourTagging(0),
149  fFlavourTracks(0),
150  fMaxCPt(0),
151  fMaxNPt(0),
152  fMCPt(0),
153  fNn(0),
154  fNch(0),
155  fPtEmc(0),
156  fNEmc(0),
157  fClusterIDs(),
158  fTrackIDs(),
159  fMatched(2),
160  fMatchingType(0),
161  fTaggedJet(0x0),
162  fTagStatus(-1),
163  fPtSub(0),
164  fPtSubVect(0),
165  fTriggers(0),
166  fLabel(-1),
167  fHasGhost(kFALSE),
168  fGhosts(),
169  fJetShapeProperties(0),
170  fJetAcceptanceType(0)
171 {
172  fPhi = TVector2::Phi_0_2pi(fPhi);
173 
174  fClosestJets[0] = 0;
175  fClosestJets[1] = 0;
176  fClosestJetsDist[0] = 999;
177  fClosestJetsDist[1] = 999;
178 }
179 
185  AliVParticle(jet),
186  fPt(jet.fPt),
187  fEta(jet.fEta),
188  fPhi(jet.fPhi),
189  fM(jet.fM),
190  fNEF(jet.fNEF),
191  fArea(jet.fArea),
192  fAreaEta(jet.fAreaEta),
193  fAreaPhi(jet.fAreaPhi),
194  fAreaE(jet.fAreaE),
195  fAreaEmc(jet.fAreaEmc),
196  fAxisInEmcal(jet.fAxisInEmcal),
197  fFlavourTagging(jet.fFlavourTagging),
198  fFlavourTracks((jet.fFlavourTracks) ? new TObjArray(*(jet.fFlavourTracks)) : 0),
199  fMaxCPt(jet.fMaxCPt),
200  fMaxNPt(jet.fMaxNPt),
201  fMCPt(jet.fMCPt),
202  fNn(jet.fNn),
203  fNch(jet.fNch),
204  fPtEmc(jet.fPtEmc),
205  fNEmc(jet.fNEmc),
206  fClusterIDs(jet.fClusterIDs),
207  fTrackIDs(jet.fTrackIDs),
208  fMatched(jet.fMatched),
209  fMatchingType(jet.fMatchingType),
210  fTaggedJet(jet.fTaggedJet),
211  fTagStatus(jet.fTagStatus),
212  fPtSub(jet.fPtSub),
213  fPtSubVect(jet.fPtSubVect),
214  fTriggers(jet.fTriggers),
215  fLabel(jet.fLabel),
216  fHasGhost(jet.fHasGhost),
217  fGhosts(jet.fGhosts),
218  fJetShapeProperties(0),
219  fJetAcceptanceType(jet.fJetAcceptanceType)
220 {
221  // Copy constructor.
222  fClosestJets[0] = jet.fClosestJets[0];
223  fClosestJets[1] = jet.fClosestJets[1];
226 
227  if (jet.fJetShapeProperties) {
229  }
230 }
231 
236 {
238 }
239 
246 {
247  if (this != &jet) {
248  AliVParticle::operator=(jet);
249  fPt = jet.fPt;
250  fEta = jet.fEta;
251  fPhi = jet.fPhi;
252  fM = jet.fM;
253  fNEF = jet.fNEF;
254  fArea = jet.fArea;
255  fAreaEta = jet.fAreaEta;
256  fAreaPhi = jet.fAreaPhi;
257  fAreaE = jet.fAreaE;
258  fAreaEmc = jet.fAreaEmc;
261  fFlavourTracks = (jet.fFlavourTracks) ? new TObjArray(*(jet.fFlavourTracks)) : 0;
262  fMaxCPt = jet.fMaxCPt;
263  fMaxNPt = jet.fMaxNPt;
264  fMCPt = jet.fMCPt;
265  fNn = jet.fNn;
266  fNch = jet.fNch;
267  fPtEmc = jet.fPtEmc;
268  fNEmc = jet.fNEmc;
269  fClusterIDs = jet.fClusterIDs;
270  fTrackIDs = jet.fTrackIDs;
271  fClosestJets[0] = jet.fClosestJets[0];
272  fClosestJets[1] = jet.fClosestJets[1];
275  fMatched = jet.fMatched;
276  fTaggedJet = jet.fTaggedJet;
277  fTagStatus = jet.fTagStatus;
278  fPtSub = jet.fPtSub;
279  fPtSubVect = jet.fPtSubVect;
280  fTriggers = jet.fTriggers;
281  fLabel = jet.fLabel;
282  fHasGhost = jet.fHasGhost;
283  fGhosts = jet.fGhosts;
284  if (jet.fJetShapeProperties) {
286  }
288  }
289 
290  return *this;
291 }
292 
299 {
300  //Return -1 if this is smaller than obj, 0 if objects are equal and 1 if this is larger than obj.
301 
302  if (obj == this) return 0;
303 
304  const AliEmcalJet* jet = dynamic_cast<const AliEmcalJet*>(obj);
305  if (!jet) return 0;
306 
307  if (Pt() > jet->Pt()) return -1;
308  else if (Pt() < jet->Pt()) return 1;
309  else return 0;
310 }
311 
316 void AliEmcalJet::GetMomentum(TLorentzVector& vec) const
317 {
318  vec.SetPtEtaPhiE(fPt, fEta, fPhi, E());
319 }
320 
329 {
330  Double_t ptcorr = fPt - rho * fArea;
331  if (save) fPtSub = ptcorr;
332  return ptcorr;
333 }
334 
343 {
344  Double_t dx = Px() - rho * fArea * TMath::Cos(fAreaPhi);
345  Double_t dy = Py() - rho * fArea * TMath::Sin(fAreaPhi);
346  //Double_t dz = Pz() - rho * fArea * TMath::SinH(fAreaEta);
347  Double_t ptcorr = TMath::Sqrt(dx * dx + dy * dy);
348  if (save) fPtSubVect = ptcorr;
349  return ptcorr;
350 }
351 
360 {
361  TLorentzVector vecCorr;
362  GetMomentum(vecCorr);
363  TLorentzVector vecBg;
364  vecBg.SetPtEtaPhiE(fArea, fAreaEta, fAreaPhi, fAreaE);
365  vecBg *= rho;
366  vecCorr -= vecBg;
367  if (save) {
368  Double_t dPhi = TMath::Abs(TVector2::Phi_mpi_pi(Phi() - vecCorr.Phi()));
369  Int_t signum = dPhi <= TMath::PiOver2() ? 1 : -1;
370  fPtSubVect = signum * vecCorr.Pt();
371  }
372  return vecCorr;
373 }
374 
380 {
381  std::sort(fClusterIDs.GetArray(), fClusterIDs.GetArray() + fClusterIDs.GetSize());
382  std::sort(fTrackIDs.GetArray(), fTrackIDs.GetArray() + fTrackIDs.GetSize());
383 }
384 
390 Double_t AliEmcalJet::DeltaR(const AliVParticle* part) const
391 {
392  Double_t dPhi = Phi() - part->Phi();
393  Double_t dEta = Eta() - part->Eta();
394  dPhi = TVector2::Phi_mpi_pi(dPhi);
395  return TMath::Sqrt(dPhi * dPhi + dEta * dEta);
396 }
397 
413 std::vector<int> AliEmcalJet::GetPtSortedTrackConstituentIndexes(TClonesArray* tracks) const
414 {
415  typedef std::pair<Double_t, Int_t> ptidx_pair;
416 
417  // Create vector for Pt sorting
418  std::vector<ptidx_pair> pair_list;
419 
420  for (Int_t i_entry = 0; i_entry < GetNumberOfTracks(); i_entry++) {
421  AliVParticle* track = TrackAt(i_entry, tracks);
422  if (!track) {
423  AliError(Form("Unable to find jet track %d in collection %s (pos in collection %d, max %d)", i_entry, tracks->GetName(), TrackAt(i_entry), tracks->GetEntriesFast()));
424  continue;
425  }
426  pair_list.push_back(std::make_pair(track->Pt(), i_entry));
427  }
428 
429  std::stable_sort(pair_list.begin() , pair_list.end() , sort_descend());
430 
431  // return a vector of indexes of constituents (sorted descending by pt)
432  std::vector <int> index_sorted_list;
433 
434  // populating the return object with indexes of sorted tracks
435  for (auto it : pair_list) index_sorted_list.push_back(it.second);
436 
437  return index_sorted_list;
438 }
439 
447 Double_t AliEmcalJet::GetZ(const Double_t trkPx, const Double_t trkPy, const Double_t trkPz) const
448 {
449  Double_t pJetSq = P();
450  pJetSq *= pJetSq;
451 
452  if (pJetSq > 1e-6) {
453  return (trkPx * Px() + trkPy * Py() + trkPz * Pz()) / pJetSq;
454  }
455  else {
456  AliWarning(Form("%s: strange, pjet*pjet seems to be zero pJetSq: %f", GetName(), pJetSq));
457  return -1;
458  }
459 }
460 
466 Double_t AliEmcalJet::GetZ(const AliVParticle* trk) const
467 {
468  return GetZ(trk->Px(), trk->Py(), trk->Pz());
469 }
470 
476 AliVParticle* AliEmcalJet::GetLeadingTrack(TClonesArray* tracks) const
477 {
478  AliVParticle* maxTrack = 0;
479  for (Int_t i = 0; i < GetNumberOfTracks(); i++) {
480  AliVParticle* track = TrackAt(i, tracks);
481  if (!track) {
482  AliError(Form("Unable to find jet track %d in collection %s (pos in collection %d, max %d)",
483  i, tracks->GetName(), TrackAt(i), tracks->GetEntriesFast()));
484  continue;
485  }
486  if (!maxTrack || track->Pt() > maxTrack->Pt())
487  maxTrack = track;
488  }
489 
490  return maxTrack;
491 }
492 
498 AliVCluster* AliEmcalJet::GetLeadingCluster(TClonesArray* clusters) const
499 {
500  AliVCluster* maxCluster = 0;
501  for (Int_t i = 0; i < GetNumberOfClusters(); i++) {
502  AliVCluster* cluster = ClusterAt(i, clusters);
503  if (!cluster) {
504  AliError(Form("Unable to find jet cluster %d in collection %s (pos in collection %d, max %d)",
505  i, clusters->GetName(), ClusterAt(i), clusters->GetEntriesFast()));
506  continue;
507  }
508  if (!maxCluster || cluster->E() > maxCluster->E())
509  maxCluster = cluster;
510  }
511 
512  return maxCluster;
513 }
514 
519 {
520  fClosestJets[0] = 0;
521  fClosestJets[1] = 0;
522  fClosestJetsDist[0] = 999;
523  fClosestJetsDist[1] = 999;
524  fMatched = 2;
525 }
526 
533 {
534  for (Int_t i = 0; i < fTrackIDs.GetSize(); i++) {
535  if (it == fTrackIDs[i]) return i;
536  }
537  return -1;
538 }
539 
546 {
547  for (Int_t i = 0; i < fClusterIDs.GetSize(); i++) {
548  if (ic == fClusterIDs[i]) return i;
549  }
550  return -1;
551 }
552 
566  return TString::Format("Jet pT = %.2f, eta = %.2f, phi = %.2f, max charged pT = %.2f, max neutral pT = %.2f, N tracks = %d, N clusters = %d, Area = %.2f, NEF = %.2f",
568 }
569 
576 void AliEmcalJet::Print(Option_t* /*opt*/) const
577 {
578  Printf("%s\n", toString().Data());
579 }
580 
587 std::ostream &AliEmcalJet::Print(std::ostream &in) const {
588  in << toString().Data();
589  return in;
590 }
591 
597 void AliEmcalJet::PrintConstituents(TClonesArray* tracks, TClonesArray* clusters) const
598 {
599  if (tracks) {
600  for (Int_t i = 0; i < GetNumberOfTracks(); i++) {
601  AliVParticle* part = TrackAt(i, tracks);
602  if (part) {
603  Printf("Track %d (index = %d) pT = %.2f, eta = %.2f, phi = %.2f, PDG code = %d", i, TrackAt(i), part->Pt(), part->Eta(), part->Phi(), part->PdgCode());
604  }
605  }
606  }
607 
608  if (clusters) {
609  for (Int_t i = 0; i < GetNumberOfClusters(); i++) {
610  AliVCluster* clus = ClusterAt(i, clusters);
611  if (clus) {
612  Printf("Cluster %d (index = %d) E = %.2f", i, ClusterAt(i), clus->E());
613  }
614  }
615  }
616 }
617 
624 {
625  if (P() < 1e-6) return 0.;
626  AliVParticle* hftrack = GetFlavourTrack(i);
627  return hftrack != 0 ? hftrack->P() / P() : 0.;
628 }
629 
637 std::ostream &operator<<(std::ostream &in, const AliEmcalJet &myjet) {
638  std::ostream &result = myjet.Print(in);
639  return result;
640 }
641 
650 void AliEmcalJet::AddGhost(const Double_t dPx, const Double_t dPy, const Double_t dPz, const Double_t dE)
651 {
652  TLorentzVector ghost(dPx, dPy, dPz, dE);
653  fGhosts.push_back(ghost);
654  if (!fHasGhost) fHasGhost = kTRUE;
655  return;
656 }
657 
661 void AliEmcalJet::Clear(Option_t */*option*/)
662 {
663  fClusterIDs.Set(0);
664  fTrackIDs.Set(0);
665  fClosestJets[0] = 0;
666  fClosestJets[1] = 0;
667  fClosestJetsDist[0] = 0;
668  fClosestJetsDist[1] = 0;
669  fMatched = 0;
670  fPtSub = 0;
671  fGhosts.clear();
672  fHasGhost = kFALSE;
673 }
674 
683 AliVParticle* AliEmcalJet::Track(Int_t idx) const
684 {
686 }
687 
694 AliVParticle* AliEmcalJet::TrackAt(Int_t idx, TClonesArray *ta) const
695 {
696  if (!ta) return 0;
698  if (res.second != ta) {
699  AliWarning(Form("TClonesArray %s that was passed does not correspond to the passed index! The index belongs to a different TClonesArray named %s! Returning the object corresponding to the index (not the passed TClonesArray)! Consider fixing by updating to jet->Track(index).", ta->GetName(), res.second->GetName()));
700  }
701  return dynamic_cast<AliVParticle*>(res.second->At(res.first));
702 }
703 
710 Int_t AliEmcalJet::ContainsTrack(AliVParticle* track, TClonesArray* tracks) const
711 {
712  if (!tracks || !track) return 0;
713  return ContainsTrack(tracks->IndexOf(track));
714 }
715 
724 AliVCluster* AliEmcalJet::Cluster(Int_t idx) const
725 {
727 }
728 
735 AliVCluster* AliEmcalJet::ClusterAt(Int_t idx, TClonesArray *ca) const
736 {
737  if (!ca) return 0;
738 
740  if (res.second != ca) {
741  AliWarning(Form("TClonesArray %s that was passed does not correspond to the passed index! The index belongs to a different TClonesArray named %s! Returning the object corresponding to the index (not the passed TClonesArray)! Consider fixing by updating to jet->Cluster(index).", ca->GetName(), res.second->GetName()));
742  }
743  return dynamic_cast<AliVCluster*>(res.second->At(res.first));
744 }
745 
752 Int_t AliEmcalJet::ContainsCluster(AliVCluster* cluster, TClonesArray* clusters) const
753 {
754  if (!clusters || !cluster) return 0;
755  return ContainsCluster(clusters->IndexOf(cluster));
756 }
757 
763 Double_t AliEmcalJet::GetXi(const AliVParticle* trk) const
764 {
765  return TMath::Log(1 / GetZ(trk));
766 }
767 
775 Double_t AliEmcalJet::GetXi( const Double_t trkPx, const Double_t trkPy, const Double_t trkPz ) const
776 {
777  return TMath::Log(1 / GetZ(trkPx, trkPy, trkPz));
778 }
779 
784 void AliEmcalJet::AddFlavourTrack(AliVParticle* hftrack)
785 {
787  fFlavourTracks->Add(hftrack);
788 }
789 
795 AliVParticle* AliEmcalJet::GetFlavourTrack(Int_t i) const
796 {
797  if (!fFlavourTracks || i < 0 || i >= fFlavourTracks->GetEntriesFast()) return 0;
798 
799  return static_cast<AliVParticle*>(fFlavourTracks->At(i));
800 }
801 
808 {
809  if (!fFlavourTracks || i < 0 || i >= fFlavourTracks->GetEntriesFast()) return 0;
810 
811  return static_cast<AliVParticle*>(fFlavourTracks->RemoveAt(i));
812 }
TArrayI fTrackIDs
Array containing ids of track constituents.
Definition: AliEmcalJet.h:298
Double_t fPtSubVect
! Background vector subtracted pt (not stored set from outside)
Definition: AliEmcalJet.h:306
Double_t Area() const
Definition: AliEmcalJet.h:123
std::pair< Double_t, Int_t > ptidx_pair
(pt,index) pair
double Double_t
Definition: External.C:58
Int_t fTagStatus
! Status of tagging -1: NA 0: not tagged 1: tagged
Definition: AliEmcalJet.h:304
Double_t GetXi(const AliVParticle *trk) const
Simple C structure to allow sorting in descending order.
Definition: AliEmcalJet.h:321
Double32_t fAreaE
Jet temporal area component.
Definition: AliEmcalJet.h:281
TArrayI fClusterIDs
Array containing ids of cluster constituents.
Definition: AliEmcalJet.h:297
Double_t Eta() const
Definition: AliEmcalJet.h:114
Int_t fLabel
! Label to inclusive jet for constituent subtracted jet
Definition: AliEmcalJet.h:308
Double_t fPtSub
! Background subtracted pt (not stored set from outside)
Definition: AliEmcalJet.h:305
Double_t Py() const
Definition: AliEmcalJet.h:100
void Clear(Option_t *="")
std::pair< int, U * > LocalIndexFromGlobalIndex(const int globalIndex) const
Double_t Phi() const
Definition: AliEmcalJet.h:110
Bool_t fHasGhost
! Whether ghost particle are included within the constituents
Definition: AliEmcalJet.h:310
Int_t ClusterAt(Int_t idx) const
Definition: AliEmcalJet.h:130
AliEmcalJetShapeProperties * fJetShapeProperties
! Pointer to the jet shape properties
Definition: AliEmcalJet.h:313
AliVParticle * Track(Int_t idx) const
Double_t MaxChargedPt() const
Definition: AliEmcalJet.h:140
AliEmcalJet & operator=(const AliEmcalJet &jet)
Double_t GetFlavourTrackZ(Int_t i=0) const
Double_t E() const
Definition: AliEmcalJet.h:112
AliVParticle * GetFlavourTrack(Int_t i=0) const
AliVParticle * RemoveFlavourTrack(Int_t i=0)
Int_t ContainsCluster(AliVCluster *cluster, TClonesArray *clusters) const
Int_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:153
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:132
Double_t Px() const
Definition: AliEmcalJet.h:99
std::ostream & Print(std::ostream &in) const
void ResetMatching()
void GetMomentum(TLorentzVector &vec) const
Double32_t fMCPt
Pt from MC particles contributing to the jet.
Definition: AliEmcalJet.h:291
Double32_t fMaxNPt
Pt of maximum neutral constituent.
Definition: AliEmcalJet.h:290
Double32_t fM
Jet mass.
Definition: AliEmcalJet.h:271
int Int_t
Definition: External.C:63
UShort_t GetNumberOfClusters() const
Definition: AliEmcalJet.h:131
AliVParticle * GetLeadingTrack(TClonesArray *tracks) const
Double32_t fAreaPhi
Jet phi area.
Definition: AliEmcalJet.h:279
void AddFlavourTrack(AliVParticle *hftrack)
UShort_t fMatched
! 0 or 1 if it is matched with one of the closest jets; 2 if it is not matched
Definition: AliEmcalJet.h:301
std::vector< TLorentzVector > fGhosts
! Vector containing the ghost particles
Definition: AliEmcalJet.h:311
TString toString() const
Double_t PtSubVect() const
Definition: AliEmcalJet.h:152
static const AliEmcalContainerIndexMap< TClonesArray, AliVCluster > & GetEmcalContainerIndexMap()
Get the EMCal container utils associated with particle containers.
Double32_t fArea
Jet transverse area.
Definition: AliEmcalJet.h:275
AliVCluster * GetLeadingCluster(TClonesArray *clusters) const
AliEmcalJet * fTaggedJet
! Jet tagged to this jet
Definition: AliEmcalJet.h:303
Int_t ContainsTrack(AliVParticle *track, TClonesArray *tracks) const
TLorentzVector SubtractRhoVect(Double_t rho, Bool_t save=kFALSE)
std::ostream & operator<<(std::ostream &in, const AliEmcalJet &myjet)
virtual ~AliEmcalJet()
Double_t PtSub() const
Definition: AliEmcalJet.h:151
V * GetObjectFromGlobalIndex(const int globalIndex) const
Double32_t fAreaEta
Jet eta area.
Definition: AliEmcalJet.h:277
Double_t MaxNeutralPt() const
Definition: AliEmcalJet.h:139
void AddGhost(const Double_t dPx, const Double_t dPy, const Double_t dPz, const Double_t dE)
Double_t GetZ(const Double_t trkPx, const Double_t trkPy, const Double_t trkPz) const
Int_t fFlavourTagging
Tag jet with a flavor (use bits defined in enum EFlavourTag)
Definition: AliEmcalJet.h:285
Double_t DeltaR(const AliVParticle *part) const
Bool_t Data(TH1F *h, Double_t *rangefit, Bool_t writefit, Double_t &sgn, Double_t &errsgn, Double_t &bkg, Double_t &errbkg, Double_t &sgnf, Double_t &errsgnf, Double_t &sigmafit, Int_t &status)
UInt_t fJetAcceptanceType
! Jet acceptance type (stored bitwise)
Definition: AliEmcalJet.h:314
Double_t Pt() const
Definition: AliEmcalJet.h:102
Double32_t fPtEmc
Pt in EMCAL acceptance.
Definition: AliEmcalJet.h:295
This class contains the derivative subtraction operators for jet shapes.
Double32_t fPt
Jet transverse momentum.
Definition: AliEmcalJet.h:265
Double_t P() const
Definition: AliEmcalJet.h:103
Double32_t fEta
Jet pseudo-rapidity.
Definition: AliEmcalJet.h:267
Double32_t fMaxCPt
Pt of maximum charged constituent.
Definition: AliEmcalJet.h:288
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Double32_t fAreaEmc
Area on EMCAL surface (determined by ghosts in EMCal acceptance)
Definition: AliEmcalJet.h:283
AliVCluster * Cluster(Int_t idx) const
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
Int_t fNn
Number of neutral constituents.
Definition: AliEmcalJet.h:292
Double_t Pz() const
Definition: AliEmcalJet.h:101
const char Option_t
Definition: External.C:48
UInt_t fTriggers
! Triggers that the jet might have fired (AliVEvent::EOfflineTriggerTypes)
Definition: AliEmcalJet.h:307
Bool_t fAxisInEmcal
Whether the jet axis is inside the EMCAL acceptance.
Definition: AliEmcalJet.h:284
void SortConstituents()
Int_t fNEmc
Number of constituents in EMCAL acceptance.
Definition: AliEmcalJet.h:296
Double32_t fPhi
Jet axis azimuthal angle.
Definition: AliEmcalJet.h:269
AliEmcalJet * fClosestJets[2]
! If this is MC it contains the two closest detector level jets in order of distance and viceversa ...
Definition: AliEmcalJet.h:299
bool Bool_t
Definition: External.C:53
Double_t NEF() const
Definition: AliEmcalJet.h:141
Double32_t fNEF
Jet Neutral Energy Fraction.
Definition: AliEmcalJet.h:273
Double32_t fClosestJetsDist[2]
! Distance from the two closest jets
Definition: AliEmcalJet.h:300
Int_t Compare(const TObject *obj) const
std::vector< int > GetPtSortedTrackConstituentIndexes(TClonesArray *tracks) const
TObjArray * fFlavourTracks
Definition: AliEmcalJet.h:286
static const AliEmcalContainerIndexMap< TClonesArray, AliVParticle > & GetEmcalContainerIndexMap()
Get the EMCal container utils associated with particle containers.
void PrintConstituents(TClonesArray *tracks, TClonesArray *clusters) const