AliPhysics  b555aef (b555aef)
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 
49 ClassImp(PWG::EMCAL::TestAliEmcalTrackSelectionAOD)
51 
54 {
55 }
56 
59 {
60  if(cuts) AddTrackCuts(cuts);
61  if(filterbits) {
62  auto filterbitcuts = new PWG::EMCAL::AliEmcalAODFilterBitCuts("filterbitcuts", "AOD filter bit cuts");
63  filterbitcuts->SetFilterBits(filterbits, true);
64  AddTrackCuts(filterbitcuts);
65  }
66 }
67 
70 {
71  GenerateTrackCuts(type, period);
72 }
73 
75 {
76  switch (type) {
77  case kHybridTracks:
78  {
79  auto hybridcuts = new PWG::EMCAL::AliEmcalAODHybridTrackCuts("hybridcuts");
80  Char_t hybridbits[2];
81  GetHybridFilterBits(hybridbits, period);
82  hybridcuts->SetHybridFilterBits(hybridbits[0], hybridbits[1]);
83  AddTrackCuts(hybridcuts);
84  break;
85  }
86 
87  case kTPCOnlyTracks:
88  {
89  AddTrackCuts(new PWG::EMCAL::AliEmcalAODTPCOnlyTrackCuts("tpconlycuts", "hybrid track cuts for TPC only tracks"));
90  break;
91  }
92 
94  {
95  if (fListOfCuts) fListOfCuts->Clear();
96  AddTrackCuts(AliESDtrackCuts::GetStandardITSSATrackCuts2010());
97  break;
98  }
99 
101  {
102  auto trackcuts = new PWG::EMCAL::AliEmcalAODHybridTrackCuts("hybridcuts2010_wNoRefit");
103  Char_t hybridbits[2];
104  GetHybridFilterBits(hybridbits, period);
105  trackcuts->SetHybridFilterBits(hybridbits[0], hybridbits[1]);
106  AddTrackCuts(trackcuts);
107  break;
108  }
109 
111  {
112  auto trackcuts = new PWG::EMCAL::AliEmcalAODHybridTrackCuts("hybridcuts2010_woNoRefit");
113  Char_t hybridbits[2];
114  GetHybridFilterBits(hybridbits, period);
115  trackcuts->SetHybridFilterBits(hybridbits[0], hybridbits[1]);
116  trackcuts->SetSelectNonITSrefitTracks(kFALSE);
117  AddTrackCuts(trackcuts);
118  break;
119  }
120 
122  {
123  auto trackcuts = new PWG::EMCAL::AliEmcalAODHybridTrackCuts("hybridcuts2011_wNoRefit");
124  Char_t hybridbits[2];
125  GetHybridFilterBits(hybridbits, period);
126  trackcuts->SetHybridFilterBits(hybridbits[0], hybridbits[1]);
127  AddTrackCuts(trackcuts);
128  break;
129  }
130 
132  {
133  auto trackcuts = new PWG::EMCAL::AliEmcalAODHybridTrackCuts("hybridcuts2011_woNoRefit");
134  Char_t hybridbits[2];
135  GetHybridFilterBits(hybridbits, period);
136  trackcuts->SetHybridFilterBits(hybridbits[0], hybridbits[1]);
137  trackcuts->SetSelectNonITSrefitTracks(kFALSE);
138  AddTrackCuts(trackcuts);
139  break;
140  }
141 
142  default:
143  break;
144  }
145 }
146 
148 {
149  AliAODTrack *aodt = dynamic_cast<AliAODTrack*>(trk);
150  if (!aodt){
151  AliPicoTrack *picotrack = dynamic_cast<AliPicoTrack*>(trk);
152  if(picotrack) {
153  aodt = dynamic_cast<AliAODTrack *>(picotrack->GetTrack());
154  }
155  else {
156  AliError("Track neither AOD track nor pico track");
157  return PWG::EMCAL::AliEmcalTrackSelResultPtr(nullptr, kFALSE);
158  }
159  }
160  if(!aodt){
161  AliError("Failed getting AOD track");
162  return PWG::EMCAL::AliEmcalTrackSelResultPtr(nullptr, kFALSE);
163  }
164 
165  TBits trackbitmap(64);
166  trackbitmap.ResetAllBits();
167  UInt_t cutcounter(0);
168  TClonesArray selectionStatus("PWG::EMCAL::AliEmcalTrackSelResultPtr", fListOfCuts->GetEntries());
169  selectionStatus.SetOwner(kTRUE);
170  if (fListOfCuts) {
171  for (auto cutIter : *fListOfCuts){
172  PWG::EMCAL::AliEmcalCutBase *trackCuts = static_cast<PWG::EMCAL::AliEmcalCutBase*>(static_cast<AliEmcalManagedObject *>(cutIter)->GetObject());
173  PWG::EMCAL::AliEmcalTrackSelResultPtr cutresults = trackCuts->IsSelected(aodt);
174  if (cutresults) trackbitmap.SetBitNumber(cutcounter);
175  new(selectionStatus[selectionStatus.GetEntries()]) PWG::EMCAL::AliEmcalTrackSelResultPtr(cutresults);
176  cutcounter++;
177  }
178  }
179 
180  PWG::EMCAL::AliEmcalTrackSelResultPtr result(aodt, kFALSE, new PWG::EMCAL::AliEmcalTrackSelResultCombined(&selectionStatus));
181  if (fSelectionModeAny){
182  // In case of ANY one of the cuts need to be fulfilled (equivalent to one but set)
183  result.SetSelectionResult(trackbitmap.CountBits() > 0 || cutcounter == 0);
184  }
185  else {
186  // In case of ALL all of the cuts need to be fulfilled (equivalent to all bits set)
187  result.SetSelectionResult(trackbitmap.CountBits() == cutcounter);
188  }
189  return result;
190 }
191 
193  PWG::EMCAL::AliEmcalAODFilterBitCuts *filtercuts = nullptr;
194  // Find existing filter bit cuts
195  for(auto c : *fListOfCuts) {
196  if(auto vcutswrapper = dynamic_cast<PWG::EMCAL::AliEmcalVCutsWrapper*>(c)) {
197  if(auto aodcuts = dynamic_cast<PWG::EMCAL::AliEmcalAODFilterBitCuts *>(vcutswrapper->GetCutObject())){
198  filtercuts = aodcuts;
199  break;
200  }
201  }
202  }
203  if(filtercuts) filtercuts->SetFilterBits(filterbits, false);
204  else {
205  filtercuts = new PWG::EMCAL::AliEmcalAODFilterBitCuts("filterbitcuts", "AOD filter bit cuts");
206  filtercuts->SetFilterBits(filterbits, kTRUE);
207  AddTrackCuts(filtercuts);
208  }
209 }
210 
212 {
213  period.ToLower();
214  if (period == "lhc10b" || period == "lhc10c" || period == "lhc10d" ||
215  period == "lhc10e" || period == "lhc10h" ||
216  period == "lhc11h" || period == "lhc12a" || period == "lhc12b" ||
217  period == "lhc12c" || period == "lhc12d" || period == "lhc12e" ||
218  period == "lhc12f" || period == "lhc12g" || period == "lhc12h" ||
219  period == "lhc12i" || period == "lhc13b" || period == "lhc13c" ||
220  period == "lhc13d" || period == "lhc13e" || period == "lhc13f" ||
221  period == "lhc13g" ||
222  (period.Length() == 6 && (period.BeginsWith("lhc15") || period.BeginsWith("lhc16") || period.BeginsWith("lhc17"))) // all Run-2 data, excluding MC productions
223  ) {
224  bits[0] = 8;
225  bits[1] = 9;
226  }
227 
228  else if (period == "lhc10f7a" || period == "lhc12a15e" || period.BeginsWith("lhc12a17") ||
229  period == "lhc13b4" || period == "lhc13b4_fix" || period == "lhc13b4_plus" || period == "lhc14k1a" || period == "lhc14k1b" || period == "lhc13e4" ||
230  period.BeginsWith("lhc14a1") || period.BeginsWith("lhc13b2_efix") ||
231  period.BeginsWith("lhc15g6") || period.BeginsWith("lhc16e1") || period.BeginsWith("lhc17f8")) {
232  bits[0] = 8;
233  bits[1] = 9;
234  }
235 
236  else if (period == "lhc11a" || period == "lhc10hold" || period == "lhc11c" || period == "lhc11d") {
237  bits[0] = 8;
238  bits[1] = 4;
239  }
240 
241  else if (period.Contains("lhc12a15a") || period == "lhc12a15f" ||
242  period == "lhc12a15g" || period.BeginsWith("lhc11a1")) {
243  bits[0] = 8;
244  bits[1] = 4;
245  }
246 
247  else {
248  ::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());
249  bits[0] = -1;
250  bits[1] = -1;
251  return kFALSE;
252  }
253 
254  return kTRUE;
255 }
256 
257 namespace PWG {
258 
259 namespace EMCAL {
260 
261 TestAliEmcalTrackSelectionAOD::TestAliEmcalTrackSelectionAOD() :
262  TObject(),
263  fTrackSelHybrid2010wRefit(nullptr),
264  fTrackSelHybrid2010woRefit(nullptr),
265  fTrackSelHybrid2011(nullptr),
266  fTrackSelTPConly(nullptr)
267 {
268 
269 }
270 
276 }
277 
283 }
284 
287 }
288 
290  AliInfoStream() << "Running test for 2010 Definition with non-refit tracks" << std::endl;
291  AliAODTrack testCat1WithRefit, testCat2WithRefit, testCat2WithoutRefit, testNoHybrid;
292  testCat1WithRefit.SetIsHybridGlobalConstrainedGlobal();
293  testCat2WithRefit.SetIsHybridGlobalConstrainedGlobal();
294  testCat2WithoutRefit.SetIsHybridGlobalConstrainedGlobal();
295  testCat1WithRefit.SetStatus(AliVTrack::kITSrefit);
296  testCat2WithRefit.SetStatus(AliVTrack::kITSrefit);
297  testCat1WithRefit.SetFilterMap(BIT(8));
298  testCat2WithRefit.SetFilterMap(BIT(4));
299  testCat2WithoutRefit.SetFilterMap(BIT(4));
300 
301  int nfailure = 0;
302  auto result_cat1_wrefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat1WithRefit);
303  if(!result_cat1_wrefit){
304  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
305  nfailure++;
306  } else {
307  auto hybridcat = FindHybridSelectionResult(result_cat1_wrefit);
308  if(!hybridcat){
309  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
310  nfailure++;
311  } else {
312  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
313  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
314  nfailure++;
315  }
316  }
317  }
318 
319  auto result_cat2_wrefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat2WithRefit);
320  if(!result_cat2_wrefit){
321  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
322  nfailure++;
323  } else {
324  auto hybridcat = FindHybridSelectionResult(result_cat2_wrefit);
325  if(!hybridcat){
326  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
327  nfailure++;
328  } else {
329  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridConstrained) {
330  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
331  nfailure++;
332  }
333  }
334  }
335 
336  auto result_cat2_worefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat2WithoutRefit);
337  if(!result_cat2_worefit){
338  AliErrorStream() << "Hybrid track CAT3 not selected" << std::endl;
339  nfailure++;
340  } else {
341  auto hybridcat = FindHybridSelectionResult(result_cat2_worefit);
342  if(!hybridcat){
343  AliErrorStream() << "No hybrid selection result found for CAT3 hybrid track" << std::endl;
344  nfailure++;
345  } else {
346  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridConstrainedNoITSrefit) {
347  AliErrorStream() << "Incorrect hybrid track type for CAT3 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
348  nfailure++;
349  }
350  }
351  }
352 
353  auto result_nohybrid = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testNoHybrid);
354  if(result_nohybrid){
355  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
356  nfailure++;
357  }
358 
359  return nfailure == 0;
360 }
361 
363  AliInfoStream() << "Running test for 2010 Definition without non-refit tracks" << std::endl;
364  AliAODTrack testCat1WithRefit, testCat2WithRefit, testCat2WithoutRefit, testNoHybrid;
365  testCat1WithRefit.SetIsHybridGlobalConstrainedGlobal();
366  testCat2WithRefit.SetIsHybridGlobalConstrainedGlobal();
367  testCat2WithoutRefit.SetIsHybridGlobalConstrainedGlobal();
368  testCat1WithRefit.SetStatus(AliVTrack::kITSrefit);
369  testCat2WithRefit.SetStatus(AliVTrack::kITSrefit);
370  testCat1WithRefit.SetFilterMap(BIT(8));
371  testCat2WithRefit.SetFilterMap(BIT(4));
372  testCat2WithoutRefit.SetFilterMap(BIT(4));
373 
374  int nfailure = 0;
375  auto result_cat1_wrefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat1WithRefit);
376  if(!result_cat1_wrefit){
377  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
378  nfailure++;
379  } else {
380  auto hybridcat = FindHybridSelectionResult(result_cat1_wrefit);
381  if(!hybridcat){
382  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
383  nfailure++;
384  } else {
385  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
386  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
387  nfailure++;
388  }
389  }
390  }
391 
392  auto result_cat2_wrefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat2WithRefit);
393  if(!result_cat2_wrefit){
394  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
395  nfailure++;
396  } else {
397  auto hybridcat = FindHybridSelectionResult(result_cat2_wrefit);
398  if(!hybridcat){
399  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
400  nfailure++;
401  } else {
402  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridConstrained) {
403  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
404  nfailure++;
405  }
406  }
407  }
408 
409  auto result_cat2_worefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat2WithoutRefit);
410  if(result_cat2_worefit){
411  AliErrorStream() << "CAT2 track without refit selected as hybrid track in track selection excluding non-refit tracks" << std::endl;
412  nfailure++;
413  }
414 
415  auto result_nohybrid = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testNoHybrid);
416  if(result_nohybrid){
417  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
418  nfailure++;
419  }
420 
421  return nfailure == 0;
422 }
423 
425  AliInfoStream() << "Running test for 2011 Definition" << std::endl;
426  AliAODTrack testCat1, testCat2, testNoHybrid;
427  testCat1.SetIsHybridGlobalConstrainedGlobal();
428  testCat2.SetIsHybridGlobalConstrainedGlobal();
429  testCat1.SetStatus(AliVTrack::kITSrefit);
430  testCat2.SetStatus(AliVTrack::kITSrefit);
431  testCat1.SetFilterMap(BIT(8));
432  testCat2.SetFilterMap(BIT(9));
433 
434  int nfailure = 0;
435 
436  auto result_cat1 = fTrackSelHybrid2011->IsTrackAccepted(&testCat1);
437  if(!result_cat1){
438  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
439  nfailure++;
440  } else {
441  auto hybridcat = FindHybridSelectionResult(result_cat1);
442  if(!hybridcat){
443  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
444  nfailure++;
445  } else {
446  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
447  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
448  nfailure++;
449  }
450  }
451  }
452 
453  auto result_cat2 = fTrackSelHybrid2011->IsTrackAccepted(&testCat2);
454  if(!result_cat2){
455  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
456  nfailure++;
457  } else {
458  auto hybridcat = FindHybridSelectionResult(result_cat2);
459  if(!hybridcat){
460  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
461  nfailure++;
462  } else {
463  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridConstrained) {
464  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
465  nfailure++;
466  }
467  }
468  }
469 
470  auto result_nohybrid = fTrackSelHybrid2011->IsTrackAccepted(&testNoHybrid);
471  if(result_nohybrid){
472  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
473  nfailure++;
474  }
475  return nfailure == 0;
476 }
477 
479  AliInfoStream() << "Running test for TPC-only tracks" << std::endl;
480  AliAODTrack testtrackTrue, testtrackFalse;
481  testtrackTrue.SetIsHybridTPCConstrainedGlobal(true);
482 
483  int nfailure = 0;
484  auto result_true = fTrackSelTPConly->IsTrackAccepted(&testtrackTrue);
485  if(!result_true) {
486  AliErrorStream() << "TPC-only constrained track rejected" << std::endl;
487  nfailure++;
488  }
489 
490  auto result_false = fTrackSelTPConly->IsTrackAccepted(&testtrackFalse);
491  if(result_false) {
492  AliErrorStream() << "Non-TPC-only track selected as constrained track" << std::endl;
493  nfailure++;
494  }
495 
496  return nfailure == 0;
497 }
498 
500  if(!data.GetUserInfo()) return nullptr;
501  if(auto hybridinfo = dynamic_cast<const AliEmcalTrackSelResultHybrid *>(data.GetUserInfo())) return hybridinfo;
502  if(auto combinedinfo = dynamic_cast<const AliEmcalTrackSelResultCombined *>(data.GetUserInfo())) {
503  for(int i = 0; i < combinedinfo->GetNumberOfSelectionResults(); i++) {
504  try{
505  auto res = FindHybridSelectionResult((*combinedinfo)[i]);
506  if(res) return res;
508  // just go on
509  }
510  }
511  }
512  return nullptr;
513 }
514 
515 }
516 
517 }
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.