AliPhysics  a6017e1 (a6017e1)
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), nhybridTracks2a(0), nhybridTracks2b(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  nhybridTracks2a++;
225  break;
228  nhybridTracks2b++;
229  break;
232  nhybridTracks3++;
233  break;
235  fTrackTypes[i] = kRejected; // should in principle never happen
236  break;
237  };
238  }
239  }
240  i++;
241  }
242  AliDebugStream(1) << "Accepted: " << naccepted << ", Rejected: " << nrejected << ", hybrid: (" << nhybridTracks1 << " | [" << nhybridTracks2a << " | " << nhybridTracks2b << "] | " << nhybridTracks3 << ")" << std::endl;
243  }
244  else {
245  fFilteredTracks.SetOwner(false);
246  fFilteredTracks.SetObject(fClArray);
247  }
248 }
249 
256 {
257  //Get i^th jet in array
258 
259  if (i < 0 || i >= fFilteredTracks.GetData()->GetEntriesFast()) return 0;
260  AliVTrack *vp = static_cast<AliVTrack*>(fFilteredTracks.GetData()->At(i));
261  return vp;
262 }
263 
270 {
271  UInt_t rejectionReason;
272  if (i == -1) i = fCurrentID;
273  if (AcceptTrack(i, rejectionReason)) {
274  return GetTrack(i);
275  }
276  else {
277  AliDebug(2,"Track not accepted.");
278  return 0;
279  }
280 }
281 
288 {
289  const Int_t n = GetNEntries();
290  AliVTrack *p = 0;
291  do {
292  fCurrentID++;
293  if (fCurrentID >= n) break;
294  p = GetAcceptTrack(fCurrentID);
295  } while (!p);
296 
297  return p;
298 }
299 
306 {
307  const Int_t n = GetNEntries();
308  AliVTrack *p = 0;
309  do {
310  fCurrentID++;
311  if (fCurrentID >= n) break;
312  p = GetTrack(fCurrentID);
313  } while (!p);
314 
315  return p;
316 }
317 
324 Char_t AliTrackContainer::GetTrackType(const AliVTrack* track) const
325 {
326  Int_t id = fFilteredTracks.GetData()->IndexOf(track);
327  if (id >= 0) {
328  return fTrackTypes[id];
329  }
330  else {
331  return kUndefined;
332  }
333 }
334 
344 Bool_t AliTrackContainer::GetMomentumFromTrack(TLorentzVector &mom, const AliVTrack* track, Double_t mass) const
345 {
346  if (track) {
347  if (mass < 0) mass = track->M();
348 
349  Bool_t useConstrainedParams = kFALSE;
350  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection()) {
351  Char_t trackType = GetTrackType(track);
352  if (trackType == kHybridConstrainedTrue || trackType == kHybridConstrainedNoITSrefit) {
353  AliDebugStream(2) << "Found a constrained track" << std::endl;
354  useConstrainedParams = kTRUE;
355  }
356  }
357 
358  if (useConstrainedParams) {
359  const AliESDtrack *esdtrack = static_cast<const AliESDtrack*>(track);
360  mom.SetPtEtaPhiM(esdtrack->GetConstrainedParam()->Pt(), esdtrack->GetConstrainedParam()->Eta(), esdtrack->GetConstrainedParam()->Phi(), mass);
361  }
362  else {
363  mom.SetPtEtaPhiM(track->Pt(), track->Eta(), track->Phi(), mass);
364  }
365  return kTRUE;
366  }
367  else {
368  mom.SetPtEtaPhiM(0, 0, 0, 0);
369  return kFALSE;
370  }
371 }
372 
380 Bool_t AliTrackContainer::GetMomentumFromTrack(TLorentzVector &mom, const AliVTrack* part) const
381 {
382  return GetMomentumFromTrack(mom,part,fMassHypothesis);
383 }
384 
394 Bool_t AliTrackContainer::GetMomentum(TLorentzVector &mom, Int_t i) const
395 {
396  Double_t mass = fMassHypothesis;
397 
398  if (i == -1) i = fCurrentID;
399  AliVTrack *vp = GetTrack(i);
400  if (vp) {
401  if (mass < 0) mass = vp->M();
402 
403  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
405  AliDebugStream(2) << "Found a constrained track" << std::endl;
406  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
407  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
408  }
409  else {
410  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
411  }
412  return kTRUE;
413  }
414  else {
415  mom.SetPtEtaPhiM(0, 0, 0, 0);
416  return kFALSE;
417  }
418 }
419 
430 {
431  Double_t mass = fMassHypothesis;
432 
433  AliVTrack *vp = GetNextTrack();
434  if (vp) {
435  if (mass < 0) mass = vp->M();
436 
437  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
438  (fTrackTypes[fCurrentID] == kHybridConstrainedTrue || fTrackTypes[fCurrentID] == kHybridConstrainedNoITSrefit)) {
439  AliDebugStream(2) << "Found a constrained track" << std::endl;
440  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
441  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
442  }
443  else {
444  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
445  }
446  return kTRUE;
447  }
448  else {
449  mom.SetPtEtaPhiM(0, 0, 0, 0);
450  return kFALSE;
451  }
452 }
453 
464 Bool_t AliTrackContainer::GetAcceptMomentum(TLorentzVector &mom, Int_t i) const
465 {
466 
467  Double_t mass = fMassHypothesis;
468 
469  if (i == -1) i = fCurrentID;
470  AliVTrack *vp = GetAcceptTrack(i);
471  if (vp) {
472  if (mass < 0) mass = vp->M();
473 
474  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
476  AliDebugStream(2) << "Found a constrained track" << std::endl;
477  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
478  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
479  }
480  else {
481  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
482  }
483 
484  return kTRUE;
485  }
486  else {
487  mom.SetPtEtaPhiM(0, 0, 0, 0);
488  return kFALSE;
489  }
490 }
491 
502 {
503  Double_t mass = fMassHypothesis;
504 
505  AliVTrack *vp = GetNextAcceptTrack();
506  if (vp) {
507  if (mass < 0) mass = vp->M();
508 
509  if (fLoadedClass->InheritsFrom("AliESDtrack") && IsHybridTrackSelection() &&
510  (fTrackTypes[fCurrentID] == kHybridConstrainedTrue || fTrackTypes[fCurrentID] == kHybridConstrainedNoITSrefit)) {
511  AliDebugStream(2) << "Found a constrained track" << std::endl;
512  AliESDtrack *track = static_cast<AliESDtrack*>(vp);
513  mom.SetPtEtaPhiM(track->GetConstrainedParam()->Pt(), track->GetConstrainedParam()->Eta(), track->GetConstrainedParam()->Phi(), mass);
514  }
515  else {
516  mom.SetPtEtaPhiM(vp->Pt(), vp->Eta(), vp->Phi(), mass);
517  }
518 
519  return kTRUE;
520  }
521  else {
522  mom.SetPtEtaPhiM(0, 0, 0, 0);
523  return kFALSE;
524  }
525 }
526 
537 Bool_t AliTrackContainer::AcceptTrack(const AliVTrack *vp, UInt_t &rejectionReason) const
538 {
539  Bool_t r = ApplyTrackCuts(vp, rejectionReason);
540  if (!r) return kFALSE;
541 
542  AliTLorentzVector mom;
543  if(!GetMomentumFromTrack(mom, vp)) return false;
544 
545  return ApplyKinematicCuts(mom, rejectionReason);
546 }
547 
560 {
561  if(fTrackTypes[i] == kRejected) return false; // track was rejected by the track selection
562  Bool_t r = ApplyTrackCuts(GetTrack(i), rejectionReason);
563  if (!r) return kFALSE;
564 
565  AliTLorentzVector mom;
566  if(!GetMomentum(mom, i)) return false;
567 
568  return ApplyKinematicCuts(mom, rejectionReason);
569 }
570 
580 Bool_t AliTrackContainer::ApplyTrackCuts(const AliVTrack* vp, UInt_t &rejectionReason) const
581 {
582  return ApplyParticleCuts(vp, rejectionReason);
583 }
584 
590 {
591  if (!fListOfCuts) {
592  fListOfCuts = new TObjArray;
593  fListOfCuts->SetOwner(true);
594  }
595  fListOfCuts->Add(cuts);
596 }
597 
603 {
604  if (!fListOfCuts) return 0;
605  return fListOfCuts->GetEntries();
606 }
607 
614 {
615  if (!fListOfCuts) return NULL;
616  if (icut < fListOfCuts->GetEntries()) {
617  return static_cast<AliVCuts *>(fListOfCuts->At(icut));
618  }
619  return NULL;
620 }
621 
629 }
630 
633  if(auto hybriddata = dynamic_cast<const PWG::EMCAL::AliEmcalTrackSelResultHybrid *>(selectionResult.GetUserInfo())) {
634  hybridDefinition = hybriddata->GetHybridTrackType();
635  } else {
636  if(auto combineddata = dynamic_cast<const PWG::EMCAL::AliEmcalTrackSelResultCombined *>(selectionResult.GetUserInfo())){
637  for(int icut = 0; icut < combineddata->GetNumberOfSelectionResults(); icut++){
638  try{
639  auto cutresult = GetHybridDefinition((*combineddata)[icut]);
640  if(cutresult != PWG::EMCAL::AliEmcalTrackSelResultHybrid::kUndefined) hybridDefinition = cutresult;
642  AliErrorStream() << "Index error: " << e.what() << std::endl;
643  }
644  }
645  }
646  }
647  return hybridDefinition;
648 }
649 
651  bool teststatus = true;
652  auto selected = fFilteredTracks.GetData();
653  if(selected->GetEntries() != fClArray->GetEntries()) {
654  std::cout << "Mismatch array size: selected " << selected->GetEntries() << ", input " << fClArray->GetEntries() << std::endl;
655  teststatus = false;
656  } else {
657  std::cout << "Array size consistent: " << selected->GetEntries() << std::endl;
658  }
659 
660  // Now check whehter tracks are stored in the same indices:
661  if(teststatus){
662  int nmatch(0), nfail(0);
663  for(int i = 0; i < fClArray->GetEntries(); i++) {
664  AliVTrack *trackAll = dynamic_cast<AliVTrack *>(fClArray->At(i));
665  AliVTrack *trackSel = dynamic_cast<AliVTrack *>(selected->At(i));
666  if(trackSel == trackAll) {
667  nmatch++;
668  } else {
669  std::cout << "Mismatch in array position: " << i << std::endl;
670  nfail++;
671  }
672  }
673  if(nfail) {
674  std::cout << "found " << nfail << "mismatches" << std::endl;
675  teststatus = false;
676  }
677  }
678  return teststatus;
679 }
680 
687  return AliTrackIterableContainer(this, false);
688 }
689 
696  return AliTrackIterableContainer(this, true);
697 }
698 
705  return AliTrackIterableMomentumContainer(this, false);
706 }
707 
714  return AliTrackIterableMomentumContainer(this, true);
715 }
716 
723 const char* AliTrackContainer::GetTitle() const
724 {
725  static TString trackString;
726  trackString = TString::Format("%s_pT%04d", GetArrayName().Data(), static_cast<int>(GetMinPt()*1000.0));
727  return trackString.Data();
728 }
729 
730 TString AliTrackContainer::GetDefaultArrayName(const AliVEvent *const ev) const {
731  if(ev->IsA() == AliAODEvent::Class()) return "tracks";
732  else if(ev->IsA() == AliESDEvent::Class()) return "Tracks";
733  else return "";
734 }
735 
737  TObject(),
738  fManagedObject(nullptr),
739  fOwnership(false)
740 {
741 
742 }
743 
745  TObject(),
746  fManagedObject(managedobject),
747  fOwnership(ownership)
748 {
749 
750 }
751 
753  TObject(other),
755  fOwnership(false)
756 {
757 
758 }
759 
761  TObject::operator=(other);
762  if(this != &other) {
765  fOwnership = false;
766  }
767  return *this;
768 }
769 
772 }
773 
776  fManagedObject = obj;
777 }
778 
780  fOwnership = owner;
781 }
782 
784  if(fOwnership) target.SetOwner(fOwnership);
785  fOwnership = false;
786 }
787 
789  if(source.IsOwner()) {
790  fOwnership = true;
791  source.SetOwner(false);
792  }
793 }
Interface for virtual track selection.
Complementary hybrid track with alive SPD module (type IIb)
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
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
Hybrid tracks using the 2018 TRD test definition.
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.
Complementary hybrid track without alive SPD module (type IIa)
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)
Track selected under the constrained hybrid track cuts (true constrained)
virtual AliVTrack * GetAcceptTrack(Int_t i=-1) const
Track selected under the constrained hybrid track cuts (fake constrained)
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