AliPhysics  d565ceb (d565ceb)
AliEmcalTrackSelectionAOD.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 <iostream>
28 
29 #include <TClonesArray.h>
30 #include <TBits.h>
31 #include <TObjArray.h>
32 
33 #include "AliAODEvent.h"
34 #include "AliAODTrack.h"
38 #include "AliEmcalCutBase.h"
42 #include "AliEmcalVCutsWrapper.h"
43 #include "AliESDtrackCuts.h"
44 #include "AliLog.h"
45 #include "AliPicoTrack.h"
46 
51 
52 using namespace PWG::EMCAL;
53 
56 {
57 }
58 
61 {
62  if(cuts) AddTrackCuts(cuts);
63  if(filterbits) {
64  auto filterbitcuts = new PWG::EMCAL::AliEmcalAODFilterBitCuts("filterbitcuts", "AOD filter bit cuts");
65  filterbitcuts->SetFilterBits(filterbits, true);
66  AddTrackCuts(filterbitcuts);
67  }
68 }
69 
72 {
73  GenerateTrackCuts(type, period);
74 }
75 
77 {
78  switch (type) {
79  case kHybridTracks:
80  {
81  auto hybridcuts = new PWG::EMCAL::AliEmcalAODHybridTrackCuts("hybridcuts");
82  Char_t hybridbits[2];
83  GetHybridFilterBits(hybridbits, period);
84  hybridcuts->SetHybridFilterBits(hybridbits[0], hybridbits[1]);
85  AddTrackCuts(hybridcuts);
86  break;
87  }
88 
89  case kTPCOnlyTracks:
90  {
91  AddTrackCuts(new PWG::EMCAL::AliEmcalAODTPCOnlyTrackCuts("tpconlycuts", "hybrid track cuts for TPC only tracks"));
92  break;
93  }
94 
96  {
97  if (fListOfCuts) fListOfCuts->Clear();
98  AddTrackCuts(AliESDtrackCuts::GetStandardITSSATrackCuts2010());
99  break;
100  }
101 
103  {
104  auto trackcuts = new PWG::EMCAL::AliEmcalAODHybridTrackCuts("hybridcuts2010_wNoRefit");
105  Char_t hybridbits[2];
106  GetHybridFilterBits(hybridbits, period);
107  trackcuts->SetHybridFilterBits(hybridbits[0], hybridbits[1]);
108  AddTrackCuts(trackcuts);
109  break;
110  }
111 
113  {
114  auto trackcuts = new PWG::EMCAL::AliEmcalAODHybridTrackCuts("hybridcuts2010_woNoRefit");
115  Char_t hybridbits[2];
116  GetHybridFilterBits(hybridbits, period);
117  trackcuts->SetHybridFilterBits(hybridbits[0], hybridbits[1]);
118  trackcuts->SetSelectNonITSrefitTracks(kFALSE);
119  AddTrackCuts(trackcuts);
120  break;
121  }
122 
124  {
125  auto trackcuts = new PWG::EMCAL::AliEmcalAODHybridTrackCuts("hybridcuts2011_wNoRefit");
126  Char_t hybridbits[2];
127  GetHybridFilterBits(hybridbits, period);
128  trackcuts->SetHybridFilterBits(hybridbits[0], hybridbits[1]);
129  AddTrackCuts(trackcuts);
130  break;
131  }
132 
134  {
135  auto trackcuts = new PWG::EMCAL::AliEmcalAODHybridTrackCuts("hybridcuts2011_woNoRefit");
136  Char_t hybridbits[2];
137  GetHybridFilterBits(hybridbits, period);
138  trackcuts->SetHybridFilterBits(hybridbits[0], hybridbits[1]);
139  trackcuts->SetSelectNonITSrefitTracks(kFALSE);
140  AddTrackCuts(trackcuts);
141  break;
142  }
143 
144  default:
145  break;
146  }
147 }
148 
150 {
151  AliAODTrack *aodt = dynamic_cast<AliAODTrack*>(trk);
152  if (!aodt){
153  AliPicoTrack *picotrack = dynamic_cast<AliPicoTrack*>(trk);
154  if(picotrack) {
155  aodt = dynamic_cast<AliAODTrack *>(picotrack->GetTrack());
156  }
157  else {
158  AliError("Track neither AOD track nor pico track");
159  return PWG::EMCAL::AliEmcalTrackSelResultPtr(nullptr, kFALSE);
160  }
161  }
162  if(!aodt){
163  AliError("Failed getting AOD track");
164  return PWG::EMCAL::AliEmcalTrackSelResultPtr(nullptr, kFALSE);
165  }
166 
167  TBits trackbitmap(64);
168  trackbitmap.ResetAllBits();
169  UInt_t cutcounter(0);
170  TClonesArray selectionStatus("PWG::EMCAL::AliEmcalTrackSelResultPtr", fListOfCuts->GetEntries());
171  selectionStatus.SetOwner(kTRUE);
172  if (fListOfCuts) {
173  for (auto cutIter : *fListOfCuts){
174  PWG::EMCAL::AliEmcalCutBase *trackCuts = static_cast<PWG::EMCAL::AliEmcalCutBase*>(static_cast<AliEmcalManagedObject *>(cutIter)->GetObject());
175  PWG::EMCAL::AliEmcalTrackSelResultPtr cutresults = trackCuts->IsSelected(aodt);
176  if (cutresults) trackbitmap.SetBitNumber(cutcounter);
177  new(selectionStatus[selectionStatus.GetEntries()]) PWG::EMCAL::AliEmcalTrackSelResultPtr(cutresults);
178  cutcounter++;
179  }
180  }
181 
182  PWG::EMCAL::AliEmcalTrackSelResultPtr result(aodt, kFALSE, new PWG::EMCAL::AliEmcalTrackSelResultCombined(&selectionStatus));
183  if (fSelectionModeAny){
184  // In case of ANY one of the cuts need to be fulfilled (equivalent to one but set)
185  result.SetSelectionResult(trackbitmap.CountBits() > 0 || cutcounter == 0);
186  }
187  else {
188  // In case of ALL all of the cuts need to be fulfilled (equivalent to all bits set)
189  result.SetSelectionResult(trackbitmap.CountBits() == cutcounter);
190  }
191  return result;
192 }
193 
195  PWG::EMCAL::AliEmcalAODFilterBitCuts *filtercuts = nullptr;
196  // Find existing filter bit cuts
197  for(auto c : *fListOfCuts) {
198  if(auto vcutswrapper = dynamic_cast<PWG::EMCAL::AliEmcalVCutsWrapper*>(c)) {
199  if(auto aodcuts = dynamic_cast<PWG::EMCAL::AliEmcalAODFilterBitCuts *>(vcutswrapper->GetCutObject())){
200  filtercuts = aodcuts;
201  break;
202  }
203  }
204  }
205  if(filtercuts) filtercuts->SetFilterBits(filterbits, false);
206  else {
207  filtercuts = new PWG::EMCAL::AliEmcalAODFilterBitCuts("filterbitcuts", "AOD filter bit cuts");
208  filtercuts->SetFilterBits(filterbits, kTRUE);
209  AddTrackCuts(filtercuts);
210  }
211 }
212 
214 {
215  period.ToLower();
216  if (period == "lhc10b" || period == "lhc10c" || period == "lhc10d" ||
217  period == "lhc10e" || period == "lhc10h" ||
218  period == "lhc11h" || period == "lhc12a" || period == "lhc12b" ||
219  period == "lhc12c" || period == "lhc12d" || period == "lhc12e" ||
220  period == "lhc12f" || period == "lhc12g" || period == "lhc12h" ||
221  period == "lhc12i" || period == "lhc13b" || period == "lhc13c" ||
222  period == "lhc13d" || period == "lhc13e" || period == "lhc13f" ||
223  period == "lhc13g" ||
224  (period.Length() == 6 && (period.BeginsWith("lhc15") || period.BeginsWith("lhc16") || period.BeginsWith("lhc17"))) // all Run-2 data, excluding MC productions
225  ) {
226  bits[0] = 8;
227  bits[1] = 9;
228  }
229 
230  else if (period == "lhc10f7a" || period == "lhc12a15e" || period.BeginsWith("lhc12a17") ||
231  period == "lhc13b4" || period == "lhc13b4_fix" || period == "lhc13b4_plus" || period == "lhc14k1a" || period == "lhc14k1b" || period == "lhc13e4" ||
232  period.BeginsWith("lhc14a1") || period.BeginsWith("lhc13b2_efix") ||
233  period.BeginsWith("lhc15g6") || period.BeginsWith("lhc16e1") || period.BeginsWith("lhc17f8")) {
234  bits[0] = 8;
235  bits[1] = 9;
236  }
237 
238  else if (period == "lhc11a" || period == "lhc10hold" || period == "lhc11c" || period == "lhc11d") {
239  bits[0] = 8;
240  bits[1] = 4;
241  }
242 
243  else if (period.Contains("lhc12a15a") || period == "lhc12a15f" ||
244  period == "lhc12a15g" || period.BeginsWith("lhc11a1")) {
245  bits[0] = 8;
246  bits[1] = 4;
247  }
248 
249  else {
250  ::Error("AliEmcalTrackSelectionAOD::GetHybridFilterBits", "Could not find period %s! Hybrid tracks will be selected, but will not be able to distinguish between global and constrained.", period.Data());
251  bits[0] = -1;
252  bits[1] = -1;
253  return kFALSE;
254  }
255 
256  return kTRUE;
257 }
258 
259 namespace PWG {
260 
261 namespace EMCAL {
262 
263 TestAliEmcalTrackSelectionAOD::TestAliEmcalTrackSelectionAOD() :
264  TObject(),
265  fTrackSelHybrid2010wRefit(nullptr),
266  fTrackSelHybrid2010woRefit(nullptr),
267  fTrackSelHybrid2011(nullptr),
268  fTrackSelTPConly(nullptr)
269 {
270 
271 }
272 
278 }
279 
285 }
286 
289 }
290 
292  AliInfoStream() << "Running test for 2010 Definition with non-refit tracks" << std::endl;
293  AliAODTrack testCat1WithRefit, testCat2WithRefit, testCat2WithoutRefit, testNoHybrid;
294  testCat1WithRefit.SetIsHybridGlobalConstrainedGlobal();
295  testCat2WithRefit.SetIsHybridGlobalConstrainedGlobal();
296  testCat2WithoutRefit.SetIsHybridGlobalConstrainedGlobal();
297  testCat1WithRefit.SetStatus(AliVTrack::kITSrefit);
298  testCat2WithRefit.SetStatus(AliVTrack::kITSrefit);
299  testCat1WithRefit.SetFilterMap(BIT(8));
300  testCat2WithRefit.SetFilterMap(BIT(4));
301  testCat2WithoutRefit.SetFilterMap(BIT(4));
302 
303  int nfailure = 0;
304  auto result_cat1_wrefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat1WithRefit);
305  if(!result_cat1_wrefit){
306  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
307  nfailure++;
308  } else {
309  auto hybridcat = FindHybridSelectionResult(result_cat1_wrefit);
310  if(!hybridcat){
311  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
312  nfailure++;
313  } else {
314  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
315  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
316  nfailure++;
317  }
318  }
319  }
320 
321  auto result_cat2_wrefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat2WithRefit);
322  if(!result_cat2_wrefit){
323  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
324  nfailure++;
325  } else {
326  auto hybridcat = FindHybridSelectionResult(result_cat2_wrefit);
327  if(!hybridcat){
328  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
329  nfailure++;
330  } else {
331  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridConstrained) {
332  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
333  nfailure++;
334  }
335  }
336  }
337 
338  auto result_cat2_worefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat2WithoutRefit);
339  if(!result_cat2_worefit){
340  AliErrorStream() << "Hybrid track CAT3 not selected" << std::endl;
341  nfailure++;
342  } else {
343  auto hybridcat = FindHybridSelectionResult(result_cat2_worefit);
344  if(!hybridcat){
345  AliErrorStream() << "No hybrid selection result found for CAT3 hybrid track" << std::endl;
346  nfailure++;
347  } else {
348  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridConstrainedNoITSrefit) {
349  AliErrorStream() << "Incorrect hybrid track type for CAT3 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
350  nfailure++;
351  }
352  }
353  }
354 
355  auto result_nohybrid = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testNoHybrid);
356  if(result_nohybrid){
357  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
358  nfailure++;
359  }
360 
361  return nfailure == 0;
362 }
363 
365  AliInfoStream() << "Running test for 2010 Definition without non-refit tracks" << std::endl;
366  AliAODTrack testCat1WithRefit, testCat2WithRefit, testCat2WithoutRefit, testNoHybrid;
367  testCat1WithRefit.SetIsHybridGlobalConstrainedGlobal();
368  testCat2WithRefit.SetIsHybridGlobalConstrainedGlobal();
369  testCat2WithoutRefit.SetIsHybridGlobalConstrainedGlobal();
370  testCat1WithRefit.SetStatus(AliVTrack::kITSrefit);
371  testCat2WithRefit.SetStatus(AliVTrack::kITSrefit);
372  testCat1WithRefit.SetFilterMap(BIT(8));
373  testCat2WithRefit.SetFilterMap(BIT(4));
374  testCat2WithoutRefit.SetFilterMap(BIT(4));
375 
376  int nfailure = 0;
377  auto result_cat1_wrefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat1WithRefit);
378  if(!result_cat1_wrefit){
379  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
380  nfailure++;
381  } else {
382  auto hybridcat = FindHybridSelectionResult(result_cat1_wrefit);
383  if(!hybridcat){
384  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
385  nfailure++;
386  } else {
387  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
388  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
389  nfailure++;
390  }
391  }
392  }
393 
394  auto result_cat2_wrefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat2WithRefit);
395  if(!result_cat2_wrefit){
396  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
397  nfailure++;
398  } else {
399  auto hybridcat = FindHybridSelectionResult(result_cat2_wrefit);
400  if(!hybridcat){
401  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
402  nfailure++;
403  } else {
404  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridConstrained) {
405  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
406  nfailure++;
407  }
408  }
409  }
410 
411  auto result_cat2_worefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat2WithoutRefit);
412  if(result_cat2_worefit){
413  AliErrorStream() << "CAT2 track without refit selected as hybrid track in track selection excluding non-refit tracks" << std::endl;
414  nfailure++;
415  }
416 
417  auto result_nohybrid = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testNoHybrid);
418  if(result_nohybrid){
419  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
420  nfailure++;
421  }
422 
423  return nfailure == 0;
424 }
425 
427  AliInfoStream() << "Running test for 2011 Definition" << std::endl;
428  AliAODTrack testCat1, testCat2, testNoHybrid;
429  testCat1.SetIsHybridGlobalConstrainedGlobal();
430  testCat2.SetIsHybridGlobalConstrainedGlobal();
431  testCat1.SetStatus(AliVTrack::kITSrefit);
432  testCat2.SetStatus(AliVTrack::kITSrefit);
433  testCat1.SetFilterMap(BIT(8));
434  testCat2.SetFilterMap(BIT(9));
435 
436  int nfailure = 0;
437 
438  auto result_cat1 = fTrackSelHybrid2011->IsTrackAccepted(&testCat1);
439  if(!result_cat1){
440  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
441  nfailure++;
442  } else {
443  auto hybridcat = FindHybridSelectionResult(result_cat1);
444  if(!hybridcat){
445  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
446  nfailure++;
447  } else {
448  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
449  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
450  nfailure++;
451  }
452  }
453  }
454 
455  auto result_cat2 = fTrackSelHybrid2011->IsTrackAccepted(&testCat2);
456  if(!result_cat2){
457  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
458  nfailure++;
459  } else {
460  auto hybridcat = FindHybridSelectionResult(result_cat2);
461  if(!hybridcat){
462  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
463  nfailure++;
464  } else {
465  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridConstrained) {
466  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
467  nfailure++;
468  }
469  }
470  }
471 
472  auto result_nohybrid = fTrackSelHybrid2011->IsTrackAccepted(&testNoHybrid);
473  if(result_nohybrid){
474  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
475  nfailure++;
476  }
477  return nfailure == 0;
478 }
479 
481  AliInfoStream() << "Running test for TPC-only tracks" << std::endl;
482  AliAODTrack testtrackTrue, testtrackFalse;
483  testtrackTrue.SetIsHybridTPCConstrainedGlobal(true);
484 
485  int nfailure = 0;
486  auto result_true = fTrackSelTPConly->IsTrackAccepted(&testtrackTrue);
487  if(!result_true) {
488  AliErrorStream() << "TPC-only constrained track rejected" << std::endl;
489  nfailure++;
490  }
491 
492  auto result_false = fTrackSelTPConly->IsTrackAccepted(&testtrackFalse);
493  if(result_false) {
494  AliErrorStream() << "Non-TPC-only track selected as constrained track" << std::endl;
495  nfailure++;
496  }
497 
498  return nfailure == 0;
499 }
500 
502  if(!data.GetUserInfo()) return nullptr;
503  if(auto hybridinfo = dynamic_cast<const AliEmcalTrackSelResultHybrid *>(data.GetUserInfo())) return hybridinfo;
504  if(auto combinedinfo = dynamic_cast<const AliEmcalTrackSelResultCombined *>(data.GetUserInfo())) {
505  for(int i = 0; i < combinedinfo->GetNumberOfSelectionResults(); i++) {
506  try{
507  auto res = FindHybridSelectionResult((*combinedinfo)[i]);
508  if(res) return res;
510  // just go on
511  }
512  }
513  }
514  return nullptr;
515 }
516 
517 }
518 
519 }
Interface for virtual track selection.
void SetFilterBits(ULong_t filterbits, Bool_t doReset=false)
Set the filter bits to be checked.
TObject * GetObject(const TCollection *parent, const TString &name, const TClass *cls=0, Bool_t verbose=true)
AliEmcalTrackSelectionAOD * fTrackSelHybrid2010wRefit
Hybrid tracks from 2010 including non-refit tracks.
char Char_t
Definition: External.C:18
TObjArray * fListOfCuts
List of track cut objects.
TCanvas * c
Definition: TestFitELoss.C:172
Structure containing the result of a given track selection step.
void AddFilterBit(UInt_t filterbits)
Add a new filter bit to the track selection.
virtual AliEmcalTrackSelResultPtr IsSelected(TObject *o)=0
void SetSelectionResult(Bool_t selectionResult)
Namespace for EMCAL framework classes and task.
Hybrid tracks using the 2011 definition including NoITSrefit tracks (ESD-only)
Hybrid tracks using the 2010 definition including NoITSrefit tracks (ESD-only)
virtual PWG::EMCAL::AliEmcalTrackSelResultPtr IsTrackAccepted(AliVTrack *const trk)
Performing track selection.
unsigned int UInt_t
Definition: External.C:33
Hybrid tracks using the 2010 definition excluding NoITSrefit tracks (ESD-only)
Virtual track selection for TPC-only tracks at AOD level.
Hybrid tracks using the 2011 definition excluding NoITSrefit tracks (ESD-only)
Namespace for PWG framework classes.
void AddTrackCuts(AliVCuts *cuts)
Add new track cuts to the list of cuts.
Implement virtual track selection for AOD analysis.
Cut class selecting hybrid tracks using the IsHybrid function.
AliVTrack * GetTrack() const
Definition: AliPicoTrack.h:60
AliEmcalTrackSelectionAOD * fTrackSelHybrid2010woRefit
Hybrid tracks from 2010 excluding non-refit tracks.
Bool_t fSelectionModeAny
Accept track if any of the cuts is fulfilled.
Implementation of the AOD filter bit selection as virtual cut class.
ETrackFilterType_t
Pre-defined track filters.
virtual void GenerateTrackCuts(ETrackFilterType_t type, const char *="")
Automatically generates track cuts depending on the requested type of filtering.
static Bool_t GetHybridFilterBits(Char_t bits[], TString period)
Returns the hybrid filter bits according to a hard-coded look-up table.
AliEmcalTrackSelectionAOD * fTrackSelTPConly
TPConly tracks.
AliEmcalTrackSelectionAOD()
Main constructor.
Smart pointer implementation for objects inheriting from TObject.
Interface for a cut class returning selection status and user information.
bool Bool_t
Definition: External.C:53
AliEmcalTrackSelectionAOD * fTrackSelHybrid2011
Hybrid tracks from 2011.
const AliEmcalTrackSelResultHybrid * FindHybridSelectionResult(const AliEmcalTrackSelResultPtr &data) const
Extract hybrid track user object from a track selection result ptr.
Unit test for the class AliEmcalTrackSelectionAOD.