AliPhysics  b555aef (b555aef)
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 
57  fTrackFilterType(AliEmcalTrackSelection::kHybridTracks),
58  fListOfCuts(0),
59  fSelectionModeAny(kFALSE),
60  fITSHybridTrackDistinction(kFALSE),
61  fAODFilterBits(0),
62  fTrackCutsPeriod(),
63  fEmcalTrackSelection(0),
64  fFilteredTracks(),
65  fTrackTypes(5000)
66 {
67  fBaseClassName = "AliVTrack";
68  SetClassName("AliVTrack");
69  fMassHypothesis = 0.139;
70 }
71 
77 AliTrackContainer::AliTrackContainer(const char *name, const char *period):
80  fListOfCuts(0),
81  fSelectionModeAny(kFALSE),
83  fAODFilterBits(0),
84  fTrackCutsPeriod(period),
87  fTrackTypes(5000)
88 {
89  fBaseClassName = "AliVTrack";
90  SetClassName("AliVTrack");
91 
92  if (fTrackCutsPeriod.IsNull() && !AliTrackContainer::fgDefTrackCutsPeriod.IsNull()) {
93  AliInfo(Form("Default track cuts period is %s", AliTrackContainer::fgDefTrackCutsPeriod.Data()));
95  }
96  fMassHypothesis = 0.139;
97 }
98 
105 void AliTrackContainer::SetArray(const AliVEvent *event)
106 {
108 
112  }
113  else {
115 
116  AliInfo("Using custom track cuts");
117 
118  if (fLoadedClass) {
119  if (fLoadedClass->InheritsFrom("AliAODTrack")) {
120  AliInfo(Form("Objects are of type %s: AOD track selection will be done.", fLoadedClass->GetName()));
122  }
123  else if (fLoadedClass->InheritsFrom("AliESDtrack")) {
124  AliInfo(Form("Objects are of type %s: ESD track selection will be done.", fLoadedClass->GetName()));
126  }
127  else {
128  AliWarning(Form("Objects are of type %s: no track filtering will be done!!", fLoadedClass->GetName()));
129  }
130  }
131 
132  if (fEmcalTrackSelection) {
133  if (fSelectionModeAny) {
135  }
136  else {
138  }
139 
141  }
142  }
143  else {
144  if (!fTrackCutsPeriod.IsNull()) {
145  AliInfo(Form("Using track cuts %d for period %s", fTrackFilterType, fTrackCutsPeriod.Data()));
146  }
147  else {
148  AliInfo(Form("Using track cuts %d (no data period was provided!)", fTrackFilterType));
149  }
150 
151  if (fLoadedClass->InheritsFrom("AliAODTrack")) {
152  AliInfo(Form("Objects are of type %s: AOD track selection will be done.", fLoadedClass->GetName()));
154  }
155  else if (fLoadedClass->InheritsFrom("AliESDtrack")) {
156  AliInfo(Form("Objects are of type %s: ESD track selection will be done.", fLoadedClass->GetName()));
158  }
159  else {
160  AliWarning(Form("Objects are of type %s: no track filtering will be done!!", fLoadedClass->GetName()));
161  }
162  }
163  }
164 }
165 
171 void AliTrackContainer::NextEvent(const AliVEvent * event)
172 {
173  AliParticleContainer::NextEvent(event);
174 
175  fTrackTypes.Reset(kUndefined);
176  if (fEmcalTrackSelection) {
177  auto acceptedTracks = fEmcalTrackSelection->GetAcceptedTracks(fClArray);
178 
179  TObjArray *trackarray(fFilteredTracks.GetData());
180  if(!trackarray){
181  trackarray = new TObjArray;
182  trackarray->SetOwner(false);
183  fFilteredTracks.SetObject(trackarray);
185  } else {
186  trackarray->Clear();
187  }
188 
189  int naccepted(0), nrejected(0), nhybridTracks1(0), nhybridTracks2(0), nhybridTracks3(0);
190  Int_t i = 0;
191  for(auto accresult : *acceptedTracks) {
192  if (i >= fTrackTypes.GetSize()) fTrackTypes.Set((i+1)*2);
193  PWG::EMCAL::AliEmcalTrackSelResultPtr *selectionResult = static_cast<PWG::EMCAL::AliEmcalTrackSelResultPtr *>(accresult);
194  AliVTrack *vTrack = selectionResult->GetTrack();
195  trackarray->AddLast(vTrack);
196  if (!(*selectionResult) || !vTrack) {
197  nrejected++;
198  fTrackTypes[i] = kRejected;
199  }
200  else{
201  // track is accepted;
202  naccepted++;
203  if (IsHybridTrackSelection()) {
204  switch(GetHybridDefinition(*selectionResult)) {
207  nhybridTracks1++;
208  break;
211  nhybridTracks2++;
212  break;
215  nhybridTracks3++;
216  break;
218  fTrackTypes[i] = kRejected; // should in principle never happen
219  break;
220  };
221  }
222  }
223  i++;
224  }
225  AliDebugStream(1) << "Accepted: " << naccepted << ", Rejected: " << nrejected << ", hybrid: (" << nhybridTracks1 << " | " << nhybridTracks2 << " | " << nhybridTracks3 << ")" << std::endl;
226  }
227  else {
228  fFilteredTracks.SetOwner(false);
229  fFilteredTracks.SetObject(fClArray);
230  }
231 }
232 
239 {
240  //Get i^th jet in array
241 
242  if (i < 0 || i >= fFilteredTracks.GetData()->GetEntriesFast()) return 0;
243  AliVTrack *vp = static_cast<AliVTrack*>(fFilteredTracks.GetData()->At(i));
244  return vp;
245 }
246 
253 {
254  UInt_t rejectionReason;
255  if (i == -1) i = fCurrentID;
256  if (AcceptTrack(i, rejectionReason)) {
257  return GetTrack(i);
258  }
259  else {
260  AliDebug(2,"Track not accepted.");
261  return 0;
262  }
263 }
264 
271 {
272  const Int_t n = GetNEntries();
273  AliVTrack *p = 0;
274  do {
275  fCurrentID++;
276  if (fCurrentID >= n) break;
277  p = GetAcceptTrack(fCurrentID);
278  } while (!p);
279 
280  return p;
281 }
282 
289 {
290  const Int_t n = GetNEntries();
291  AliVTrack *p = 0;
292  do {
293  fCurrentID++;
294  if (fCurrentID >= n) break;
295  p = GetTrack(fCurrentID);
296  } while (!p);
297 
298  return p;
299 }
300 
307 Char_t AliTrackContainer::GetTrackType(const AliVTrack* track) const
308 {
309  Int_t id = fFilteredTracks.GetData()->IndexOf(track);
310  if (id >= 0) {
311  return fTrackTypes[id];
312  }
313  else {
314  return kUndefined;
315  }
316 }
317 
327 Bool_t AliTrackContainer::GetMomentumFromTrack(TLorentzVector &mom, const AliVTrack* track, Double_t mass) const
328 {
329  if (track) {
330  if (mass < 0) mass = track->M();
331 
332  Bool_t useConstrainedParams = kFALSE;
333  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection()) {
334  Char_t trackType = GetTrackType(track);
335  if (trackType == kHybridConstrained || trackType == kHybridConstrainedNoITSrefit) {
336  AliDebugStream(2) << "Found a constrained track" << std::endl;
337  useConstrainedParams = kTRUE;
338  }
339  }
340 
341  if (useConstrainedParams) {
342  const AliESDtrack *esdtrack = static_cast<const AliESDtrack*>(track);
343  mom.SetPtEtaPhiM(esdtrack->GetConstrainedParam()->Pt(), esdtrack->GetConstrainedParam()->Eta(), esdtrack->GetConstrainedParam()->Phi(), mass);
344  }
345  else {
346  mom.SetPtEtaPhiM(track->Pt(), track->Eta(), track->Phi(), mass);
347  }
348  return kTRUE;
349  }
350  else {
351  mom.SetPtEtaPhiM(0, 0, 0, 0);
352  return kFALSE;
353  }
354 }
355 
363 Bool_t AliTrackContainer::GetMomentumFromTrack(TLorentzVector &mom, const AliVTrack* part) const
364 {
365  return GetMomentumFromTrack(mom,part,fMassHypothesis);
366 }
367 
377 Bool_t AliTrackContainer::GetMomentum(TLorentzVector &mom, Int_t i) const
378 {
379  Double_t mass = fMassHypothesis;
380 
381  if (i == -1) i = fCurrentID;
382  AliVTrack *vp = GetTrack(i);
383  if (vp) {
384  if (mass < 0) mass = vp->M();
385 
386  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
388  AliDebugStream(2) << "Found a constrained track" << std::endl;
389  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
390  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
391  }
392  else {
393  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
394  }
395  return kTRUE;
396  }
397  else {
398  mom.SetPtEtaPhiM(0, 0, 0, 0);
399  return kFALSE;
400  }
401 }
402 
413 {
414  Double_t mass = fMassHypothesis;
415 
416  AliVTrack *vp = GetNextTrack();
417  if (vp) {
418  if (mass < 0) mass = vp->M();
419 
420  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
421  (fTrackTypes[fCurrentID] == kHybridConstrained || fTrackTypes[fCurrentID] == kHybridConstrainedNoITSrefit)) {
422  AliDebugStream(2) << "Found a constrained track" << std::endl;
423  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
424  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
425  }
426  else {
427  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
428  }
429  return kTRUE;
430  }
431  else {
432  mom.SetPtEtaPhiM(0, 0, 0, 0);
433  return kFALSE;
434  }
435 }
436 
447 Bool_t AliTrackContainer::GetAcceptMomentum(TLorentzVector &mom, Int_t i) const
448 {
449 
450  Double_t mass = fMassHypothesis;
451 
452  if (i == -1) i = fCurrentID;
453  AliVTrack *vp = GetAcceptTrack(i);
454  if (vp) {
455  if (mass < 0) mass = vp->M();
456 
457  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
459  AliDebugStream(2) << "Found a constrained track" << std::endl;
460  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
461  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
462  }
463  else {
464  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
465  }
466 
467  return kTRUE;
468  }
469  else {
470  mom.SetPtEtaPhiM(0, 0, 0, 0);
471  return kFALSE;
472  }
473 }
474 
485 {
486  Double_t mass = fMassHypothesis;
487 
488  AliVTrack *vp = GetNextAcceptTrack();
489  if (vp) {
490  if (mass < 0) mass = vp->M();
491 
492  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
493  (fTrackTypes[fCurrentID] == kHybridConstrained || fTrackTypes[fCurrentID] == kHybridConstrainedNoITSrefit)) {
494  AliDebugStream(2) << "Found a constrained track" << std::endl;
495  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
496  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
497  }
498  else {
499  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
500  }
501 
502  return kTRUE;
503  }
504  else {
505  mom.SetPtEtaPhiM(0, 0, 0, 0);
506  return kFALSE;
507  }
508 }
509 
520 Bool_t AliTrackContainer::AcceptTrack(const AliVTrack *vp, UInt_t &rejectionReason) const
521 {
522  Bool_t r = ApplyTrackCuts(vp, rejectionReason);
523  if (!r) return kFALSE;
524 
525  AliTLorentzVector mom;
526  if(!GetMomentumFromTrack(mom, vp)) return false;
527 
528  return ApplyKinematicCuts(mom, rejectionReason);
529 }
530 
543 {
544  if(fTrackTypes[i] == kRejected) return false; // track was rejected by the track selection
545  Bool_t r = ApplyTrackCuts(GetTrack(i), rejectionReason);
546  if (!r) return kFALSE;
547 
548  AliTLorentzVector mom;
549  if(!GetMomentum(mom, i)) return false;
550 
551  return ApplyKinematicCuts(mom, rejectionReason);
552 }
553 
563 Bool_t AliTrackContainer::ApplyTrackCuts(const AliVTrack* vp, UInt_t &rejectionReason) const
564 {
565  return ApplyParticleCuts(vp, rejectionReason);
566 }
567 
573 {
574  if (!fListOfCuts) {
575  fListOfCuts = new TObjArray;
576  fListOfCuts->SetOwner(true);
577  }
578  fListOfCuts->Add(cuts);
579 }
580 
586 {
587  if (!fListOfCuts) return 0;
588  return fListOfCuts->GetEntries();
589 }
590 
597 {
598  if (!fListOfCuts) return NULL;
599  if (icut < fListOfCuts->GetEntries()) {
600  return static_cast<AliVCuts *>(fListOfCuts->At(icut));
601  }
602  return NULL;
603 }
604 
611 }
612 
615  if(auto hybriddata = dynamic_cast<const PWG::EMCAL::AliEmcalTrackSelResultHybrid *>(selectionResult.GetUserInfo())) {
616  hybridDefinition = hybriddata->GetHybridTrackType();
617  } else {
618  if(auto combineddata = dynamic_cast<const PWG::EMCAL::AliEmcalTrackSelResultCombined *>(selectionResult.GetUserInfo())){
619  for(int icut = 0; icut < combineddata->GetNumberOfSelectionResults(); icut++){
620  try{
621  auto cutresult = GetHybridDefinition((*combineddata)[icut]);
622  if(cutresult != PWG::EMCAL::AliEmcalTrackSelResultHybrid::kUndefined) hybridDefinition = cutresult;
624  AliErrorStream() << "Index error: " << e.what() << std::endl;
625  }
626  }
627  }
628  }
629  return hybridDefinition;
630 }
631 
633  bool teststatus = true;
634  auto selected = fFilteredTracks.GetData();
635  if(selected->GetEntries() != fClArray->GetEntries()) {
636  std::cout << "Mismatch array size: selected " << selected->GetEntries() << ", input " << fClArray->GetEntries() << std::endl;
637  teststatus = false;
638  } else {
639  std::cout << "Array size consistent: " << selected->GetEntries() << std::endl;
640  }
641 
642  // Now check whehter tracks are stored in the same indices:
643  if(teststatus){
644  int nmatch(0), nfail(0);
645  for(int i = 0; i < fClArray->GetEntries(); i++) {
646  AliVTrack *trackAll = dynamic_cast<AliVTrack *>(fClArray->At(i));
647  AliVTrack *trackSel = dynamic_cast<AliVTrack *>(selected->At(i));
648  if(trackSel == trackAll) {
649  nmatch++;
650  } else {
651  std::cout << "Mismatch in array position: " << i << std::endl;
652  nfail++;
653  }
654  }
655  if(nfail) {
656  std::cout << "found " << nfail << "mismatches" << std::endl;
657  teststatus = false;
658  }
659  }
660  return teststatus;
661 }
662 
669  return AliTrackIterableContainer(this, false);
670 }
671 
678  return AliTrackIterableContainer(this, true);
679 }
680 
687  return AliTrackIterableMomentumContainer(this, false);
688 }
689 
696  return AliTrackIterableMomentumContainer(this, true);
697 }
698 
705 const char* AliTrackContainer::GetTitle() const
706 {
707  static TString trackString;
708  trackString = TString::Format("%s_pT%04d", GetArrayName().Data(), static_cast<int>(GetMinPt()*1000.0));
709  return trackString.Data();
710 }
711 
712 TString AliTrackContainer::GetDefaultArrayName(const AliVEvent *const ev) const {
713  if(ev->IsA() == AliAODEvent::Class()) return "tracks";
714  else if(ev->IsA() == AliESDEvent::Class()) return "Tracks";
715  else return "";
716 }
717 
719  TObject(),
720  fManagedObject(nullptr),
721  fOwnership(false)
722 {
723 
724 }
725 
727  TObject(),
728  fManagedObject(managedobject),
729  fOwnership(ownership)
730 {
731 
732 }
733 
735  TObject(other),
737  fOwnership(false)
738 {
739 
740 }
741 
743  TObject::operator=(other);
744  if(this != &other) {
747  fOwnership = false;
748  }
749  return *this;
750 }
751 
754 }
755 
758  fManagedObject = obj;
759 }
760 
762  fOwnership = owner;
763 }
764 
766  if(fOwnership) target.SetOwner(fOwnership);
767  fOwnership = false;
768 }
769 
771  if(source.IsOwner()) {
772  fOwnership = true;
773  source.SetOwner(false);
774  }
775 }
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 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
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