AliPhysics  9e28f8c (9e28f8c)
 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 
23 
28  AliVParticle(),
29  fPt(0),
30  fEta(0),
31  fPhi(0),
32  fM(0),
33  fNEF(0),
34  fArea(0),
35  fAreaEta(0),
36  fAreaPhi(0),
37  fAreaE(0),
38  fAreaEmc(-1),
39  fAxisInEmcal(0),
40  fFlavourTagging(0),
41  fFlavourTracks(0),
42  fMaxCPt(0),
43  fMaxNPt(0),
44  fMCPt(0),
45  fNn(0),
46  fNch(0),
47  fPtEmc(0),
48  fNEmc(0),
49  fClusterIDs(),
50  fTrackIDs(),
51  fMatched(2),
52  fMatchingType(0),
53  fTaggedJet(0x0),
54  fTagStatus(-1),
55  fPtSub(0),
56  fPtSubVect(0),
57  fTriggers(0),
58  fLabel(-1),
59  fHasGhost(kFALSE),
60  fGhosts(),
61  fJetShapeProperties(0)
62 {
63  fClosestJets[0] = 0;
64  fClosestJets[1] = 0;
65  fClosestJetsDist[0] = 999;
66  fClosestJetsDist[1] = 999;
67 }
68 
76 AliEmcalJet::AliEmcalJet(Double_t px, Double_t py, Double_t pz) :
77  AliVParticle(),
78  fPt(TMath::Sqrt(px * px + py* py)),
79  fEta(TMath::ASinH(pz / fPt)),
80  fPhi(0),
81  fM(0),
82  fNEF(0),
83  fArea(0),
84  fAreaEta(0),
85  fAreaPhi(0),
86  fAreaE(0),
87  fAreaEmc(-1),
88  fAxisInEmcal(0),
89  fFlavourTagging(0),
90  fFlavourTracks(0),
91  fMaxCPt(0),
92  fMaxNPt(0),
93  fMCPt(0),
94  fNn(0),
95  fNch(0),
96  fPtEmc(0),
97  fNEmc(0),
98  fClusterIDs(),
99  fTrackIDs(),
100  fMatched(2),
101  fMatchingType(0),
102  fTaggedJet(0x0),
103  fTagStatus(-1),
104  fPtSub(0),
105  fPtSubVect(0),
106  fTriggers(0),
107  fLabel(-1),
108  fHasGhost(kFALSE),
109  fGhosts(),
110  fJetShapeProperties(0)
111 {
112  if (fPt != 0) {
113  fPhi = TVector2::Phi_0_2pi(TMath::ATan2(py, px));
114  }
115 
116  fClosestJets[0] = 0;
117  fClosestJets[1] = 0;
118  fClosestJetsDist[0] = 999;
119  fClosestJetsDist[1] = 999;
120 }
121 
130 AliEmcalJet::AliEmcalJet(Double_t pt, Double_t eta, Double_t phi, Double_t m) :
131  AliVParticle(),
132  fPt(pt),
133  fEta(eta),
134  fPhi(phi),
135  fM(m),
136  fNEF(0),
137  fArea(0),
138  fAreaEta(0),
139  fAreaPhi(0),
140  fAreaE(0),
141  fAreaEmc(-1),
142  fAxisInEmcal(0),
143  fFlavourTagging(0),
144  fFlavourTracks(0),
145  fMaxCPt(0),
146  fMaxNPt(0),
147  fMCPt(0),
148  fNn(0),
149  fNch(0),
150  fPtEmc(0),
151  fNEmc(0),
152  fClusterIDs(),
153  fTrackIDs(),
154  fMatched(2),
155  fMatchingType(0),
156  fTaggedJet(0x0),
157  fTagStatus(-1),
158  fPtSub(0),
159  fPtSubVect(0),
160  fTriggers(0),
161  fLabel(-1),
162  fHasGhost(kFALSE),
163  fGhosts(),
164  fJetShapeProperties(0),
165  fJetAcceptanceType(0)
166 {
167  fPhi = TVector2::Phi_0_2pi(fPhi);
168 
169  fClosestJets[0] = 0;
170  fClosestJets[1] = 0;
171  fClosestJetsDist[0] = 999;
172  fClosestJetsDist[1] = 999;
173 }
174 
180  AliVParticle(jet),
181  fPt(jet.fPt),
182  fEta(jet.fEta),
183  fPhi(jet.fPhi),
184  fM(jet.fM),
185  fNEF(jet.fNEF),
186  fArea(jet.fArea),
187  fAreaEta(jet.fAreaEta),
188  fAreaPhi(jet.fAreaPhi),
189  fAreaE(jet.fAreaE),
190  fAreaEmc(jet.fAreaEmc),
191  fAxisInEmcal(jet.fAxisInEmcal),
192  fFlavourTagging(jet.fFlavourTagging),
193  fFlavourTracks((jet.fFlavourTracks) ? new TObjArray(*(jet.fFlavourTracks)) : 0),
194  fMaxCPt(jet.fMaxCPt),
195  fMaxNPt(jet.fMaxNPt),
196  fMCPt(jet.fMCPt),
197  fNn(jet.fNn),
198  fNch(jet.fNch),
199  fPtEmc(jet.fPtEmc),
200  fNEmc(jet.fNEmc),
201  fClusterIDs(jet.fClusterIDs),
202  fTrackIDs(jet.fTrackIDs),
203  fMatched(jet.fMatched),
204  fMatchingType(jet.fMatchingType),
205  fTaggedJet(jet.fTaggedJet),
206  fTagStatus(jet.fTagStatus),
207  fPtSub(jet.fPtSub),
208  fPtSubVect(jet.fPtSubVect),
209  fTriggers(jet.fTriggers),
210  fLabel(jet.fLabel),
211  fHasGhost(jet.fHasGhost),
212  fGhosts(jet.fGhosts),
213  fJetShapeProperties(0),
214  fJetAcceptanceType(0)
215 {
216  // Copy constructor.
217  fClosestJets[0] = jet.fClosestJets[0];
218  fClosestJets[1] = jet.fClosestJets[1];
221 
222  if (jet.fJetShapeProperties) {
224  }
225 }
226 
231 {
233 }
234 
241 {
242  if (this != &jet) {
243  AliVParticle::operator=(jet);
244  fPt = jet.fPt;
245  fEta = jet.fEta;
246  fPhi = jet.fPhi;
247  fM = jet.fM;
248  fNEF = jet.fNEF;
249  fArea = jet.fArea;
250  fAreaEta = jet.fAreaEta;
251  fAreaPhi = jet.fAreaPhi;
252  fAreaE = jet.fAreaE;
253  fAreaEmc = jet.fAreaEmc;
256  fFlavourTracks = (jet.fFlavourTracks) ? new TObjArray(*(jet.fFlavourTracks)) : 0;
257  fMaxCPt = jet.fMaxCPt;
258  fMaxNPt = jet.fMaxNPt;
259  fMCPt = jet.fMCPt;
260  fNn = jet.fNn;
261  fNch = jet.fNch;
262  fPtEmc = jet.fPtEmc;
263  fNEmc = jet.fNEmc;
264  fClusterIDs = jet.fClusterIDs;
265  fTrackIDs = jet.fTrackIDs;
266  fClosestJets[0] = jet.fClosestJets[0];
267  fClosestJets[1] = jet.fClosestJets[1];
270  fMatched = jet.fMatched;
271  fTaggedJet = jet.fTaggedJet;
272  fTagStatus = jet.fTagStatus;
273  fPtSub = jet.fPtSub;
274  fPtSubVect = jet.fPtSubVect;
275  fTriggers = jet.fTriggers;
276  fLabel = jet.fLabel;
277  fHasGhost = jet.fHasGhost;
278  fGhosts = jet.fGhosts;
279  if (jet.fJetShapeProperties) {
281  }
283  }
284 
285  return *this;
286 }
287 
293 Int_t AliEmcalJet::Compare(const TObject* obj) const
294 {
295  //Return -1 if this is smaller than obj, 0 if objects are equal and 1 if this is larger than obj.
296 
297  if (obj == this) return 0;
298 
299  const AliEmcalJet* jet = dynamic_cast<const AliEmcalJet*>(obj);
300  if (!jet) return 0;
301 
302  if (Pt() > jet->Pt()) return -1;
303  else if (Pt() < jet->Pt()) return 1;
304  else return 0;
305 }
306 
311 void AliEmcalJet::GetMomentum(TLorentzVector& vec) const
312 {
313  vec.SetPtEtaPhiE(fPt, fEta, fPhi, E());
314 }
315 
323 Double_t AliEmcalJet::PtSub(Double_t rho, Bool_t save)
324 {
325  Double_t ptcorr = fPt - rho * fArea;
326  if (save) fPtSub = ptcorr;
327  return ptcorr;
328 }
329 
337 Double_t AliEmcalJet::PtSubVect(Double_t rho, Bool_t save)
338 {
339  Double_t dx = Px() - rho * fArea * TMath::Cos(fAreaPhi);
340  Double_t dy = Py() - rho * fArea * TMath::Sin(fAreaPhi);
341  //Double_t dz = Pz() - rho * fArea * TMath::SinH(fAreaEta);
342  Double_t ptcorr = TMath::Sqrt(dx * dx + dy * dy);
343  if (save) fPtSubVect = ptcorr;
344  return ptcorr;
345 }
346 
354 TLorentzVector AliEmcalJet::SubtractRhoVect(Double_t rho, Bool_t save)
355 {
356  TLorentzVector vecCorr;
357  GetMomentum(vecCorr);
358  TLorentzVector vecBg;
359  vecBg.SetPtEtaPhiE(fArea, fAreaEta, fAreaPhi, fAreaE);
360  vecBg *= rho;
361  vecCorr -= vecBg;
362  if (save) {
363  Double_t dPhi = TMath::Abs(TVector2::Phi_mpi_pi(Phi() - vecCorr.Phi()));
364  Int_t signum = dPhi <= TMath::PiOver2() ? 1 : -1;
365  fPtSubVect = signum * vecCorr.Pt();
366  }
367  return vecCorr;
368 }
369 
375 {
376  std::sort(fClusterIDs.GetArray(), fClusterIDs.GetArray() + fClusterIDs.GetSize());
377  std::sort(fTrackIDs.GetArray(), fTrackIDs.GetArray() + fTrackIDs.GetSize());
378 }
379 
385 Double_t AliEmcalJet::DeltaR(const AliVParticle* part) const
386 {
387  Double_t dPhi = Phi() - part->Phi();
388  Double_t dEta = Eta() - part->Eta();
389  dPhi = TVector2::Phi_mpi_pi(dPhi);
390  return TMath::Sqrt(dPhi * dPhi + dEta * dEta);
391 }
392 
398 std::vector<int> AliEmcalJet::SortConstituentsPt(TClonesArray* tracks) const
399 {
400  typedef std::pair<Double_t, Int_t> ptidx_pair;
401 
402  // Create vector for Pt sorting
403  std::vector<ptidx_pair> pair_list;
404 
405  for (Int_t i_entry = 0; i_entry < GetNumberOfTracks(); i_entry++) {
406  AliVParticle* track = TrackAt(i_entry, tracks);
407  if (!track) {
408  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()));
409  continue;
410  }
411  pair_list.push_back(std::make_pair(track->Pt(), i_entry));
412  }
413 
414  std::stable_sort(pair_list.begin() , pair_list.end() , sort_descend());
415 
416  // return a vector of indexes of constituents (sorted descending by pt)
417  std::vector <int> index_sorted_list;
418 
419  // populating the return object with indexes of sorted tracks
420  for (auto it : pair_list) index_sorted_list.push_back(it.second);
421 
422  return index_sorted_list;
423 }
424 
432 Double_t AliEmcalJet::GetZ(const Double_t trkPx, const Double_t trkPy, const Double_t trkPz) const
433 {
434  Double_t pJetSq = P();
435  pJetSq *= pJetSq;
436 
437  if (pJetSq > 1e-6) {
438  return (trkPx * Px() + trkPy * Py() + trkPz * Pz()) / pJetSq;
439  }
440  else {
441  AliWarning(Form("%s: strange, pjet*pjet seems to be zero pJetSq: %f", GetName(), pJetSq));
442  return -1;
443  }
444 }
445 
451 Double_t AliEmcalJet::GetZ(const AliVParticle* trk) const
452 {
453  return GetZ(trk->Px(), trk->Py(), trk->Pz());
454 }
455 
461 AliVParticle* AliEmcalJet::GetLeadingTrack(TClonesArray* tracks) const
462 {
463  AliVParticle* maxTrack = 0;
464  for (Int_t i = 0; i < GetNumberOfTracks(); i++) {
465  AliVParticle* track = TrackAt(i, tracks);
466  if (!track) {
467  AliError(Form("Unable to find jet track %d in collection %s (pos in collection %d, max %d)",
468  i, tracks->GetName(), TrackAt(i), tracks->GetEntriesFast()));
469  continue;
470  }
471  if (!maxTrack || track->Pt() > maxTrack->Pt())
472  maxTrack = track;
473  }
474 
475  return maxTrack;
476 }
477 
483 AliVCluster* AliEmcalJet::GetLeadingCluster(TClonesArray* clusters) const
484 {
485  AliVCluster* maxCluster = 0;
486  for (Int_t i = 0; i < GetNumberOfClusters(); i++) {
487  AliVCluster* cluster = ClusterAt(i, clusters);
488  if (!cluster) {
489  AliError(Form("Unable to find jet cluster %d in collection %s (pos in collection %d, max %d)",
490  i, clusters->GetName(), ClusterAt(i), clusters->GetEntriesFast()));
491  continue;
492  }
493  if (!maxCluster || cluster->E() > maxCluster->E())
494  maxCluster = cluster;
495  }
496 
497  return maxCluster;
498 }
499 
504 {
505  fClosestJets[0] = 0;
506  fClosestJets[1] = 0;
507  fClosestJetsDist[0] = 999;
508  fClosestJetsDist[1] = 999;
509  fMatched = 2;
510 }
511 
517 Int_t AliEmcalJet::ContainsTrack(Int_t it) const
518 {
519  for (Int_t i = 0; i < fTrackIDs.GetSize(); i++) {
520  if (it == fTrackIDs[i]) return i;
521  }
522  return -1;
523 }
524 
530 Int_t AliEmcalJet::ContainsCluster(Int_t ic) const
531 {
532  for (Int_t i = 0; i < fClusterIDs.GetSize(); i++) {
533  if (ic == fClusterIDs[i]) return i;
534  }
535  return -1;
536 }
537 
550 TString AliEmcalJet::toString() const {
551  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",
553 }
554 
561 void AliEmcalJet::Print(Option_t* /*opt*/) const
562 {
563  Printf("%s\n", toString().Data());
564 }
565 
572 std::ostream &AliEmcalJet::Print(std::ostream &in) const {
573  in << toString().Data();
574  return in;
575 }
576 
582 void AliEmcalJet::PrintConstituents(TClonesArray* tracks, TClonesArray* clusters) const
583 {
584  if (tracks) {
585  for (Int_t i = 0; i < GetNumberOfTracks(); i++) {
586  AliVParticle* part = TrackAt(i, tracks);
587  if (part) {
588  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());
589  }
590  }
591  }
592 
593  if (clusters) {
594  for (Int_t i = 0; i < GetNumberOfClusters(); i++) {
595  AliVCluster* clus = ClusterAt(i, clusters);
596  if (clus) {
597  Printf("Cluster %d (index = %d) E = %.2f", i, ClusterAt(i), clus->E());
598  }
599  }
600  }
601 }
602 
608 Double_t AliEmcalJet::GetFlavourTrackZ(Int_t i) const
609 {
610  if (P() < 1e-6) return 0.;
611  AliVParticle* hftrack = GetFlavourTrack(i);
612  return hftrack != 0 ? hftrack->P() / P() : 0.;
613 }
614 
622 std::ostream &operator<<(std::ostream &in, const AliEmcalJet &myjet) {
623  std::ostream &result = myjet.Print(in);
624  return result;
625 }
626 
635 void AliEmcalJet::AddGhost(const Double_t dPx, const Double_t dPy, const Double_t dPz, const Double_t dE)
636 {
637  TLorentzVector ghost(dPx, dPy, dPz, dE);
638  fGhosts.push_back(ghost);
639  if (!fHasGhost) fHasGhost = kTRUE;
640  return;
641 }
642 
646 void AliEmcalJet::Clear(Option_t */*option*/)
647 {
648  fClusterIDs.Set(0);
649  fTrackIDs.Set(0);
650  fClosestJets[0] = 0;
651  fClosestJets[1] = 0;
652  fClosestJetsDist[0] = 0;
653  fClosestJetsDist[1] = 0;
654  fMatched = 0;
655  fPtSub = 0;
656  fGhosts.clear();
657  fHasGhost = kFALSE;
658 }
659 
666 AliVParticle* AliEmcalJet::TrackAt(Int_t idx, TClonesArray *ta) const
667 {
668  if (!ta) return 0;
669  return dynamic_cast<AliVParticle*>(ta->At(TrackAt(idx)));
670 }
671 
678 Int_t AliEmcalJet::ContainsTrack(AliVParticle* track, TClonesArray* tracks) const
679 {
680  if (!tracks || !track) return 0;
681  return ContainsTrack(tracks->IndexOf(track));
682 }
683 
690 AliVCluster* AliEmcalJet::ClusterAt(Int_t idx, TClonesArray *ca) const
691 {
692  if (!ca) return 0;
693  return dynamic_cast<AliVCluster*>(ca->At(ClusterAt(idx)));
694 }
695 
702 Int_t AliEmcalJet::ContainsCluster(AliVCluster* cluster, TClonesArray* clusters) const
703 {
704  if (!clusters || !cluster) return 0;
705  return ContainsCluster(clusters->IndexOf(cluster));
706 }
707 
713 Double_t AliEmcalJet::GetXi(const AliVParticle* trk) const
714 {
715  return TMath::Log(1 / GetZ(trk));
716 }
717 
725 Double_t AliEmcalJet::GetXi( const Double_t trkPx, const Double_t trkPy, const Double_t trkPz ) const
726 {
727  return TMath::Log(1 / GetZ(trkPx, trkPy, trkPz));
728 }
729 
734 void AliEmcalJet::AddFlavourTrack(AliVParticle* hftrack)
735 {
736  if (!fFlavourTracks) fFlavourTracks = new TObjArray();
737  fFlavourTracks->Add(hftrack);
738 }
739 
745 AliVParticle* AliEmcalJet::GetFlavourTrack(Int_t i) const
746 {
747  if (!fFlavourTracks || i < 0 || i >= fFlavourTracks->GetEntriesFast()) return 0;
748 
749  return static_cast<AliVParticle*>(fFlavourTracks->At(i));
750 }
751 
757 AliVParticle* AliEmcalJet::RemoveFlavourTrack(Int_t i)
758 {
759  if (!fFlavourTracks || i < 0 || i >= fFlavourTracks->GetEntriesFast()) return 0;
760 
761  return static_cast<AliVParticle*>(fFlavourTracks->RemoveAt(i));
762 }
TArrayI fTrackIDs
Array containing ids of track constituents.
Definition: AliEmcalJet.h:287
Double_t fPtSubVect
! Background vector subtracted pt (not stored set from outside)
Definition: AliEmcalJet.h:295
Double_t Area() const
Definition: AliEmcalJet.h:114
std::pair< Double_t, Int_t > ptidx_pair
(pt,index) pair
Int_t fTagStatus
! Status of tagging -1: NA 0: not tagged 1: tagged
Definition: AliEmcalJet.h:293
Double_t GetXi(const AliVParticle *trk) const
Simple C structure to allow sorting in descending order.
Definition: AliEmcalJet.h:310
Double32_t fAreaE
Jet temporal area component.
Definition: AliEmcalJet.h:270
TArrayI fClusterIDs
Array containing ids of cluster constituents.
Definition: AliEmcalJet.h:286
Double_t Eta() const
Definition: AliEmcalJet.h:105
Int_t fLabel
! Label to inclusive jet for constituent subtracted jet
Definition: AliEmcalJet.h:297
Double_t fPtSub
! Background subtracted pt (not stored set from outside)
Definition: AliEmcalJet.h:294
Double_t Py() const
Definition: AliEmcalJet.h:91
void Clear(Option_t *="")
Double_t Phi() const
Definition: AliEmcalJet.h:101
Bool_t fHasGhost
! Whether ghost particle are included within the constituents
Definition: AliEmcalJet.h:299
AliEmcalJetShapeProperties * fJetShapeProperties
! Pointer to the jet shape properties
Definition: AliEmcalJet.h:302
Double_t MaxChargedPt() const
Definition: AliEmcalJet.h:131
AliEmcalJet & operator=(const AliEmcalJet &jet)
Double_t GetFlavourTrackZ(Int_t i=0) const
Double_t E() const
Definition: AliEmcalJet.h:103
AliVParticle * GetFlavourTrack(Int_t i=0) const
AliVParticle * RemoveFlavourTrack(Int_t i=0)
Int_t ContainsCluster(AliVCluster *cluster, TClonesArray *clusters) const
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:123
Double_t Px() const
Definition: AliEmcalJet.h:90
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:280
Double32_t fMaxNPt
Pt of maximum neutral constituent.
Definition: AliEmcalJet.h:279
Double32_t fM
Jet mass.
Definition: AliEmcalJet.h:260
Short_t ClusterAt(Int_t idx) const
Definition: AliEmcalJet.h:121
UShort_t GetNumberOfClusters() const
Definition: AliEmcalJet.h:122
AliVParticle * GetLeadingTrack(TClonesArray *tracks) const
Double32_t fAreaPhi
Jet phi area.
Definition: AliEmcalJet.h:268
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:290
std::vector< int > SortConstituentsPt(TClonesArray *tracks) const
std::vector< TLorentzVector > fGhosts
! Vector containing the ghost particles
Definition: AliEmcalJet.h:300
TString toString() const
Double_t PtSubVect() const
Definition: AliEmcalJet.h:143
Double32_t fArea
Jet transverse area.
Definition: AliEmcalJet.h:264
AliVCluster * GetLeadingCluster(TClonesArray *clusters) const
AliEmcalJet * fTaggedJet
! Jet tagged to this jet
Definition: AliEmcalJet.h:292
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:142
Double32_t fAreaEta
Jet eta area.
Definition: AliEmcalJet.h:266
Double_t MaxNeutralPt() const
Definition: AliEmcalJet.h:130
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:274
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:303
Double_t Pt() const
Definition: AliEmcalJet.h:93
Double32_t fPtEmc
Pt in EMCAL acceptance.
Definition: AliEmcalJet.h:284
This class contains the derivative subtraction operators for jet shapes.
Double32_t fPt
Jet transverse momentum.
Definition: AliEmcalJet.h:254
Double_t P() const
Definition: AliEmcalJet.h:94
Double32_t fEta
Jet pseudo-rapidity.
Definition: AliEmcalJet.h:256
Double32_t fMaxCPt
Pt of maximum charged constituent.
Definition: AliEmcalJet.h:277
Short_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:144
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Double32_t fAreaEmc
Area on EMCAL surface (determined by ghosts in EMCal acceptance)
Definition: AliEmcalJet.h:272
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
Int_t fNn
Number of neutral constituents.
Definition: AliEmcalJet.h:281
Double_t Pz() const
Definition: AliEmcalJet.h:92
UInt_t fTriggers
! Triggers that the jet might have fired (AliVEvent::EOfflineTriggerTypes)
Definition: AliEmcalJet.h:296
Bool_t fAxisInEmcal
Whether the jet axis is inside the EMCAL acceptance.
Definition: AliEmcalJet.h:273
void SortConstituents()
Int_t fNEmc
Number of constituents in EMCAL acceptance.
Definition: AliEmcalJet.h:285
Double32_t fPhi
Jet axis azimuthal angle.
Definition: AliEmcalJet.h:258
AliEmcalJet * fClosestJets[2]
! If this is MC it contains the two closest detector level jets in order of distance and viceversa ...
Definition: AliEmcalJet.h:288
Double_t NEF() const
Definition: AliEmcalJet.h:132
Double32_t fNEF
Jet Neutral Energy Fraction.
Definition: AliEmcalJet.h:262
Double32_t fClosestJetsDist[2]
! Distance from the two closest jets
Definition: AliEmcalJet.h:289
Int_t Compare(const TObject *obj) const
TObjArray * fFlavourTracks
Definition: AliEmcalJet.h:275
void PrintConstituents(TClonesArray *tracks, TClonesArray *clusters) const