AliPhysics  1811c8f (1811c8f)
AliTrackContainer.cxx
Go to the documentation of this file.
1 /************************************************************************************
2  * Copyright (C) 2017, Copyright Holders of the ALICE Collaboration *
3  * All rights reserved. *
4  * *
5  * Redistribution and use in source and binary forms, with or without *
6  * modification, are permitted provided that the following conditions are met: *
7  * * Redistributions of source code must retain the above copyright *
8  * notice, this list of conditions and the following disclaimer. *
9  * * Redistributions in binary form must reproduce the above copyright *
10  * notice, this list of conditions and the following disclaimer in the *
11  * documentation and/or other materials provided with the distribution. *
12  * * Neither the name of the <organization> nor the *
13  * names of its contributors may be used to endorse or promote products *
14  * derived from this software without specific prior written permission. *
15  * *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND *
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED *
18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
19  * DISCLAIMED. IN NO EVENT SHALL ALICE COLLABORATION BE LIABLE FOR ANY *
20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES *
21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; *
22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND *
23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
26  ************************************************************************************/
27 #include <bitset>
28 #include <iostream>
29 #include <TClonesArray.h>
30 
31 #include "AliAODEvent.h"
32 #include "AliESDEvent.h"
33 #include "AliVEvent.h"
34 #include "AliLog.h"
35 #include "AliVCuts.h"
36 #include "AliESDtrack.h"
37 
38 #include "AliTLorentzVector.h"
44 #include "AliTrackContainer.h"
45 
47 ClassImp(AliTrackContainer);
49 
51 
52 // string to enum map for use with the %YAML config
53 const std::map <std::string, AliEmcalTrackSelection::ETrackFilterType_t> AliTrackContainer::fgkTrackFilterTypeMap = {
54  {"kNoTrackFilter", AliEmcalTrackSelection::kNoTrackFilter },
55  {"kCustomTrackFilter", AliEmcalTrackSelection::kCustomTrackFilter },
56  {"kHybridTracks", AliEmcalTrackSelection::kHybridTracks },
57  {"kTPCOnlyTracks", AliEmcalTrackSelection::kTPCOnlyTracks },
58  {"kITSPureTracks", AliEmcalTrackSelection::kITSPureTracks },
59  {"kHybridTracks2010wNoRefit", AliEmcalTrackSelection::kHybridTracks2010wNoRefit },
60  {"kHybridTracks2010woNoRefit", AliEmcalTrackSelection::kHybridTracks2010woNoRefit },
61  {"kHybridTracks2011wNoRefit", AliEmcalTrackSelection::kHybridTracks2011wNoRefit },
62  {"kHybridTracks2011woNoRefit", AliEmcalTrackSelection::kHybridTracks2011woNoRefit }
63 };
64 
70  fTrackFilterType(AliEmcalTrackSelection::kHybridTracks),
71  fListOfCuts(0),
72  fSelectionModeAny(kFALSE),
73  fITSHybridTrackDistinction(kFALSE),
74  fAODFilterBits(0),
75  fTrackCutsPeriod(),
76  fEmcalTrackSelection(0),
77  fFilteredTracks(),
78  fTrackTypes(5000)
79 {
80  fBaseClassName = "AliVTrack";
81  SetClassName("AliVTrack");
82  fMassHypothesis = 0.139;
83 }
84 
90 AliTrackContainer::AliTrackContainer(const char *name, const char *period):
93  fListOfCuts(0),
94  fSelectionModeAny(kFALSE),
96  fAODFilterBits(0),
97  fTrackCutsPeriod(period),
100  fTrackTypes(5000)
101 {
102  fBaseClassName = "AliVTrack";
103  SetClassName("AliVTrack");
104 
105  if (fTrackCutsPeriod.IsNull() && !AliTrackContainer::fgDefTrackCutsPeriod.IsNull()) {
106  AliInfo(Form("Default track cuts period is %s", AliTrackContainer::fgDefTrackCutsPeriod.Data()));
108  }
109  fMassHypothesis = 0.139;
110 }
111 
118 void AliTrackContainer::SetArray(const AliVEvent *event)
119 {
121 
125  }
126  else {
128 
129  AliInfo("Using custom track cuts");
130 
131  if (fLoadedClass) {
132  if (fLoadedClass->InheritsFrom("AliAODTrack")) {
133  AliInfo(Form("Objects are of type %s: AOD track selection will be done.", fLoadedClass->GetName()));
135  }
136  else if (fLoadedClass->InheritsFrom("AliESDtrack")) {
137  AliInfo(Form("Objects are of type %s: ESD track selection will be done.", fLoadedClass->GetName()));
139  }
140  else {
141  AliWarning(Form("Objects are of type %s: no track filtering will be done!!", fLoadedClass->GetName()));
142  }
143  }
144 
145  if (fEmcalTrackSelection) {
146  if (fSelectionModeAny) {
148  }
149  else {
151  }
152 
154  }
155  }
156  else {
157  if (!fTrackCutsPeriod.IsNull()) {
158  AliInfo(Form("Using track cuts %d for period %s", fTrackFilterType, fTrackCutsPeriod.Data()));
159  }
160  else {
161  AliInfo(Form("Using track cuts %d (no data period was provided!)", fTrackFilterType));
162  }
163 
164  if (fLoadedClass->InheritsFrom("AliAODTrack")) {
165  AliInfo(Form("Objects are of type %s: AOD track selection will be done.", fLoadedClass->GetName()));
167  }
168  else if (fLoadedClass->InheritsFrom("AliESDtrack")) {
169  AliInfo(Form("Objects are of type %s: ESD track selection will be done.", fLoadedClass->GetName()));
171  }
172  else {
173  AliWarning(Form("Objects are of type %s: no track filtering will be done!!", fLoadedClass->GetName()));
174  }
175  }
176  }
177 }
178 
184 void AliTrackContainer::NextEvent(const AliVEvent * event)
185 {
186  AliParticleContainer::NextEvent(event);
187 
188  fTrackTypes.Reset(kUndefined);
189  if (fEmcalTrackSelection) {
190  auto acceptedTracks = fEmcalTrackSelection->GetAcceptedTracks(fClArray);
191 
192  TObjArray *trackarray(fFilteredTracks.GetData());
193  if(!trackarray){
194  trackarray = new TObjArray;
195  trackarray->SetOwner(false);
196  fFilteredTracks.SetObject(trackarray);
198  } else {
199  trackarray->Clear();
200  }
201 
202  int naccepted(0), nrejected(0), nhybridTracks1(0), nhybridTracks2(0), nhybridTracks3(0);
203  Int_t i = 0;
204  for(auto accresult : *acceptedTracks) {
205  if (i >= fTrackTypes.GetSize()) fTrackTypes.Set((i+1)*2);
206  PWG::EMCAL::AliEmcalTrackSelResultPtr *selectionResult = static_cast<PWG::EMCAL::AliEmcalTrackSelResultPtr *>(accresult);
207  AliVTrack *vTrack = selectionResult->GetTrack();
208  trackarray->AddLast(vTrack);
209  if (!(*selectionResult) || !vTrack) {
210  nrejected++;
211  fTrackTypes[i] = kRejected;
212  }
213  else{
214  // track is accepted;
215  naccepted++;
216  if (IsHybridTrackSelection()) {
217  switch(GetHybridDefinition(*selectionResult)) {
220  nhybridTracks1++;
221  break;
224  nhybridTracks2++;
225  break;
228  nhybridTracks3++;
229  break;
231  fTrackTypes[i] = kRejected; // should in principle never happen
232  break;
233  };
234  }
235  }
236  i++;
237  }
238  AliDebugStream(1) << "Accepted: " << naccepted << ", Rejected: " << nrejected << ", hybrid: (" << nhybridTracks1 << " | " << nhybridTracks2 << " | " << nhybridTracks3 << ")" << std::endl;
239  }
240  else {
241  fFilteredTracks.SetOwner(false);
242  fFilteredTracks.SetObject(fClArray);
243  }
244 }
245 
252 {
253  //Get i^th jet in array
254 
255  if (i < 0 || i >= fFilteredTracks.GetData()->GetEntriesFast()) return 0;
256  AliVTrack *vp = static_cast<AliVTrack*>(fFilteredTracks.GetData()->At(i));
257  return vp;
258 }
259 
266 {
267  UInt_t rejectionReason;
268  if (i == -1) i = fCurrentID;
269  if (AcceptTrack(i, rejectionReason)) {
270  return GetTrack(i);
271  }
272  else {
273  AliDebug(2,"Track not accepted.");
274  return 0;
275  }
276 }
277 
284 {
285  const Int_t n = GetNEntries();
286  AliVTrack *p = 0;
287  do {
288  fCurrentID++;
289  if (fCurrentID >= n) break;
290  p = GetAcceptTrack(fCurrentID);
291  } while (!p);
292 
293  return p;
294 }
295 
302 {
303  const Int_t n = GetNEntries();
304  AliVTrack *p = 0;
305  do {
306  fCurrentID++;
307  if (fCurrentID >= n) break;
308  p = GetTrack(fCurrentID);
309  } while (!p);
310 
311  return p;
312 }
313 
320 Char_t AliTrackContainer::GetTrackType(const AliVTrack* track) const
321 {
322  Int_t id = fFilteredTracks.GetData()->IndexOf(track);
323  if (id >= 0) {
324  return fTrackTypes[id];
325  }
326  else {
327  return kUndefined;
328  }
329 }
330 
340 Bool_t AliTrackContainer::GetMomentumFromTrack(TLorentzVector &mom, const AliVTrack* track, Double_t mass) const
341 {
342  if (track) {
343  if (mass < 0) mass = track->M();
344 
345  Bool_t useConstrainedParams = kFALSE;
346  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection()) {
347  Char_t trackType = GetTrackType(track);
348  if (trackType == kHybridConstrained || trackType == kHybridConstrainedNoITSrefit) {
349  AliDebugStream(2) << "Found a constrained track" << std::endl;
350  useConstrainedParams = kTRUE;
351  }
352  }
353 
354  if (useConstrainedParams) {
355  const AliESDtrack *esdtrack = static_cast<const AliESDtrack*>(track);
356  mom.SetPtEtaPhiM(esdtrack->GetConstrainedParam()->Pt(), esdtrack->GetConstrainedParam()->Eta(), esdtrack->GetConstrainedParam()->Phi(), mass);
357  }
358  else {
359  mom.SetPtEtaPhiM(track->Pt(), track->Eta(), track->Phi(), mass);
360  }
361  return kTRUE;
362  }
363  else {
364  mom.SetPtEtaPhiM(0, 0, 0, 0);
365  return kFALSE;
366  }
367 }
368 
376 Bool_t AliTrackContainer::GetMomentumFromTrack(TLorentzVector &mom, const AliVTrack* part) const
377 {
378  return GetMomentumFromTrack(mom,part,fMassHypothesis);
379 }
380 
390 Bool_t AliTrackContainer::GetMomentum(TLorentzVector &mom, Int_t i) const
391 {
392  Double_t mass = fMassHypothesis;
393 
394  if (i == -1) i = fCurrentID;
395  AliVTrack *vp = GetTrack(i);
396  if (vp) {
397  if (mass < 0) mass = vp->M();
398 
399  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
401  AliDebugStream(2) << "Found a constrained track" << std::endl;
402  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
403  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
404  }
405  else {
406  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
407  }
408  return kTRUE;
409  }
410  else {
411  mom.SetPtEtaPhiM(0, 0, 0, 0);
412  return kFALSE;
413  }
414 }
415 
426 {
427  Double_t mass = fMassHypothesis;
428 
429  AliVTrack *vp = GetNextTrack();
430  if (vp) {
431  if (mass < 0) mass = vp->M();
432 
433  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
434  (fTrackTypes[fCurrentID] == kHybridConstrained || fTrackTypes[fCurrentID] == kHybridConstrainedNoITSrefit)) {
435  AliDebugStream(2) << "Found a constrained track" << std::endl;
436  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
437  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
438  }
439  else {
440  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
441  }
442  return kTRUE;
443  }
444  else {
445  mom.SetPtEtaPhiM(0, 0, 0, 0);
446  return kFALSE;
447  }
448 }
449 
460 Bool_t AliTrackContainer::GetAcceptMomentum(TLorentzVector &mom, Int_t i) const
461 {
462 
463  Double_t mass = fMassHypothesis;
464 
465  if (i == -1) i = fCurrentID;
466  AliVTrack *vp = GetAcceptTrack(i);
467  if (vp) {
468  if (mass < 0) mass = vp->M();
469 
470  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
472  AliDebugStream(2) << "Found a constrained track" << std::endl;
473  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
474  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
475  }
476  else {
477  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
478  }
479 
480  return kTRUE;
481  }
482  else {
483  mom.SetPtEtaPhiM(0, 0, 0, 0);
484  return kFALSE;
485  }
486 }
487 
498 {
499  Double_t mass = fMassHypothesis;
500 
501  AliVTrack *vp = GetNextAcceptTrack();
502  if (vp) {
503  if (mass < 0) mass = vp->M();
504 
505  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
506  (fTrackTypes[fCurrentID] == kHybridConstrained || fTrackTypes[fCurrentID] == kHybridConstrainedNoITSrefit)) {
507  AliDebugStream(2) << "Found a constrained track" << std::endl;
508  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
509  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
510  }
511  else {
512  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
513  }
514 
515  return kTRUE;
516  }
517  else {
518  mom.SetPtEtaPhiM(0, 0, 0, 0);
519  return kFALSE;
520  }
521 }
522 
533 Bool_t AliTrackContainer::AcceptTrack(const AliVTrack *vp, UInt_t &rejectionReason) const
534 {
535  Bool_t r = ApplyTrackCuts(vp, rejectionReason);
536  if (!r) return kFALSE;
537 
538  AliTLorentzVector mom;
539  if(!GetMomentumFromTrack(mom, vp)) return false;
540 
541  return ApplyKinematicCuts(mom, rejectionReason);
542 }
543 
556 {
557  if(fTrackTypes[i] == kRejected) return false; // track was rejected by the track selection
558  Bool_t r = ApplyTrackCuts(GetTrack(i), rejectionReason);
559  if (!r) return kFALSE;
560 
561  AliTLorentzVector mom;
562  if(!GetMomentum(mom, i)) return false;
563 
564  return ApplyKinematicCuts(mom, rejectionReason);
565 }
566 
576 Bool_t AliTrackContainer::ApplyTrackCuts(const AliVTrack* vp, UInt_t &rejectionReason) const
577 {
578  return ApplyParticleCuts(vp, rejectionReason);
579 }
580 
586 {
587  if (!fListOfCuts) {
588  fListOfCuts = new TObjArray;
589  fListOfCuts->SetOwner(true);
590  }
591  fListOfCuts->Add(cuts);
592 }
593 
599 {
600  if (!fListOfCuts) return 0;
601  return fListOfCuts->GetEntries();
602 }
603 
610 {
611  if (!fListOfCuts) return NULL;
612  if (icut < fListOfCuts->GetEntries()) {
613  return static_cast<AliVCuts *>(fListOfCuts->At(icut));
614  }
615  return NULL;
616 }
617 
624 }
625 
628  if(auto hybriddata = dynamic_cast<const PWG::EMCAL::AliEmcalTrackSelResultHybrid *>(selectionResult.GetUserInfo())) {
629  hybridDefinition = hybriddata->GetHybridTrackType();
630  } else {
631  if(auto combineddata = dynamic_cast<const PWG::EMCAL::AliEmcalTrackSelResultCombined *>(selectionResult.GetUserInfo())){
632  for(int icut = 0; icut < combineddata->GetNumberOfSelectionResults(); icut++){
633  try{
634  auto cutresult = GetHybridDefinition((*combineddata)[icut]);
635  if(cutresult != PWG::EMCAL::AliEmcalTrackSelResultHybrid::kUndefined) hybridDefinition = cutresult;
637  AliErrorStream() << "Index error: " << e.what() << std::endl;
638  }
639  }
640  }
641  }
642  return hybridDefinition;
643 }
644 
646  bool teststatus = true;
647  auto selected = fFilteredTracks.GetData();
648  if(selected->GetEntries() != fClArray->GetEntries()) {
649  std::cout << "Mismatch array size: selected " << selected->GetEntries() << ", input " << fClArray->GetEntries() << std::endl;
650  teststatus = false;
651  } else {
652  std::cout << "Array size consistent: " << selected->GetEntries() << std::endl;
653  }
654 
655  // Now check whehter tracks are stored in the same indices:
656  if(teststatus){
657  int nmatch(0), nfail(0);
658  for(int i = 0; i < fClArray->GetEntries(); i++) {
659  AliVTrack *trackAll = dynamic_cast<AliVTrack *>(fClArray->At(i));
660  AliVTrack *trackSel = dynamic_cast<AliVTrack *>(selected->At(i));
661  if(trackSel == trackAll) {
662  nmatch++;
663  } else {
664  std::cout << "Mismatch in array position: " << i << std::endl;
665  nfail++;
666  }
667  }
668  if(nfail) {
669  std::cout << "found " << nfail << "mismatches" << std::endl;
670  teststatus = false;
671  }
672  }
673  return teststatus;
674 }
675 
682  return AliTrackIterableContainer(this, false);
683 }
684 
691  return AliTrackIterableContainer(this, true);
692 }
693 
700  return AliTrackIterableMomentumContainer(this, false);
701 }
702 
709  return AliTrackIterableMomentumContainer(this, true);
710 }
711 
718 const char* AliTrackContainer::GetTitle() const
719 {
720  static TString trackString;
721  trackString = TString::Format("%s_pT%04d", GetArrayName().Data(), static_cast<int>(GetMinPt()*1000.0));
722  return trackString.Data();
723 }
724 
725 TString AliTrackContainer::GetDefaultArrayName(const AliVEvent *const ev) const {
726  if(ev->IsA() == AliAODEvent::Class()) return "tracks";
727  else if(ev->IsA() == AliESDEvent::Class()) return "Tracks";
728  else return "";
729 }
730 
732  TObject(),
733  fManagedObject(nullptr),
734  fOwnership(false)
735 {
736 
737 }
738 
740  TObject(),
741  fManagedObject(managedobject),
742  fOwnership(ownership)
743 {
744 
745 }
746 
748  TObject(other),
750  fOwnership(false)
751 {
752 
753 }
754 
756  TObject::operator=(other);
757  if(this != &other) {
760  fOwnership = false;
761  }
762  return *this;
763 }
764 
767 }
768 
771  fManagedObject = obj;
772 }
773 
775  fOwnership = owner;
776 }
777 
779  if(fOwnership) target.SetOwner(fOwnership);
780  fOwnership = false;
781 }
782 
784  if(source.IsOwner()) {
785  fOwnership = true;
786  source.SetOwner(false);
787  }
788 }
Interface for virtual track selection.
double Double_t
Definition: External.C:58
void SetArray(const AliVEvent *event)
static TString fgDefTrackCutsPeriod
! default period string used to generate track cuts
const AliTrackIterableContainer accepted() const
Double_t mass
TrackOwnerHandler & operator=(const TrackOwnerHandler &other)
Container with name, TClonesArray and cuts for particles.
EMCALIterableContainer::AliEmcalIterableContainerT< AliVTrack, EMCALIterableContainer::operator_star_object< AliVTrack > > AliTrackIterableContainer
Declaration of class AliTLorentzVector.
char Char_t
Definition: External.C:18
Track selected under the constrained hybrid track cuts.
virtual Bool_t ApplyParticleCuts(const AliVParticle *vp, UInt_t &rejectionReason) const
UInt_t fAODFilterBits
track filter bits
void NextEvent(const AliVEvent *event)
Structure containing the result of a given track selection step.
const AliTrackIterableContainer all() const
void ReceiveOwnershipFrom(TrackOwnerHandler &source)
void SetSelectionModeAny()
Set selection mode to any.
AliVCuts * GetTrackCuts(Int_t icut)
Bool_t CheckArrayConsistency() const
Test function checking whether the entries in the track array are the same as in the input array...
virtual Bool_t GetNextMomentum(TLorentzVector &mom)
AliEmcalTrackSelection * fEmcalTrackSelection
! track selection object
virtual Bool_t GetMomentum(TLorentzVector &mom, Int_t i) const
ETrackFilterType_t fTrackFilterType
track filter type
TString part
use mixed event to constrain combinatorial background
Definition: InvMassFit.C:52
TString fTrackCutsPeriod
period string used to generate track cuts
Container for particles within the EMCAL framework.
Track selected under the constrained hybrid track cuts without ITS refit.
PWG::EMCAL::AliEmcalTrackSelResultHybrid::HybridType_t GetHybridDefinition(const PWG::EMCAL::AliEmcalTrackSelResultPtr &selectionResult) const
Bool_t fITSHybridTrackDistinction
Distinct hybrid tracks via SPD information.
Hybrid tracks using the 2011 definition including NoITSrefit tracks (ESD-only)
virtual Bool_t GetAcceptMomentum(TLorentzVector &mom, Int_t i) const
virtual Bool_t GetMomentumFromTrack(TLorentzVector &mom, const AliVTrack *track, Double_t mass) const
Hybrid tracks using the 2010 definition including NoITSrefit tracks (ESD-only)
TrackOwnerHandler fFilteredTracks
! tracks filtered using fEmcalTrackSelection
virtual Bool_t ApplyTrackCuts(const AliVTrack *vp, UInt_t &rejectionReason) const
int Int_t
Definition: External.C:63
TObjArray * fManagedObject
Object managed by the handler.
unsigned int UInt_t
Definition: External.C:33
EMCALIterableContainer::AliEmcalIterableContainerT< AliVTrack, EMCALIterableContainer::operator_star_pair< AliVTrack > > AliTrackIterableMomentumContainer
virtual Bool_t AcceptTrack(const AliVTrack *vp, UInt_t &rejectionReason) const
Hybrid tracks using the 2010 definition excluding NoITSrefit tracks (ESD-only)
Int_t GetNumberOfCutObjects() const
TArrayC fTrackTypes
! track types
Hybrid tracks using the 2011 definition excluding NoITSrefit tracks (ESD-only)
TObjArray * fListOfCuts
list of track cut objects
static const std::map< std::string, AliEmcalTrackSelection::ETrackFilterType_t > fgkTrackFilterTypeMap
Relates string to the track filter enumeration for YAML configuration.
void AddTrackCuts(AliVCuts *cuts)
Add new track cuts to the list of cuts.
Implement virtual track selection for AOD analysis.
virtual AliVTrack * GetNextTrack()
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)
Bool_t fSelectionModeAny
accept track if any of the cuts is fulfilled
virtual AliVTrack * GetTrack(Int_t i=-1) const
Track selected under the global hybrid track cuts.
Bool_t fOwnership
Ownership implementation.
TObjArray * GetAcceptedTracks(const TClonesArray *const tracks)
Select tracks from a TClonesArray of input tracks.
virtual AliVTrack * GetNextAcceptTrack()
Char_t GetTrackType(const AliVTrack *track) const
void AddTrackCuts(AliVCuts *cuts)
virtual TString GetDefaultArrayName(const AliVEvent *const ev) const
void SetArray(const AliVEvent *event)
virtual AliVTrack * GetAcceptTrack(Int_t i=-1) const
virtual Bool_t GetNextAcceptMomentum(TLorentzVector &mom)
void SetSelectionModeAll()
Set selection mode to all.
const AliTrackIterableMomentumContainer accepted_momentum() const
const char * GetTitle() const
virtual Bool_t ApplyKinematicCuts(const AliTLorentzVector &mom, UInt_t &rejectionReason) const
bool Bool_t
Definition: External.C:53
void TransferOwnershipTo(TrackOwnerHandler &target)
Unique_ptr implementation for ROOT5 compatibility.
Implementation of virtual track selection for ESDs.
Track status undefined.
const AliTrackIterableMomentumContainer all_momentum() const
Bool_t IsHybridTrackSelection() const