AliPhysics  c7b8e89 (c7b8e89)
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){ // @suppress("Symbol is not resolved")
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) { // @suppress("Symbol is not resolved")
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 
225  (period.Length() == 6 && (period.BeginsWith("lhc15") || period.BeginsWith("lhc16") || period.BeginsWith("lhc17"))) // all Run-2 data, excluding MC productions
226  ) {
227  bits[0] = 8;
228  bits[1] = 9;
229  }
230 
231  else if (period == "lhc10f7a" || period == "lhc12a15e" || period.BeginsWith("lhc12a17") ||
232  period == "lhc14j4b" || period == "lhc14j4c" || period == "lhc14j4d" ||
233  period == "lhc14j4e" ||
234  period == "lhc15i2b" || period == "lhc15i2c" || period == "lhc15i2d" ||
235  period == "lhc15i2e" ||
236  period == "lhc15g6b" || period == "lhc15g6c" || period == "lhc15g6d" ||
237  period == "lhc15g6e" ||
238  period == "lhc13b4" || period == "lhc13b4_fix" || period == "lhc13b4_plus" || period == "lhc14k1a" || period == "lhc14k1b" || period == "lhc13e4" ||
239  period.BeginsWith("lhc14a1") || period.BeginsWith("lhc13b2_efix") ||
240  period.BeginsWith("lhc15g6") || period.BeginsWith("lhc16c2") || period.BeginsWith("lhc16e1") || period.BeginsWith("lhc17f8") || period.BeginsWith("lhc18b8") || period.BeginsWith("lhc18f5") || period.BeginsWith("lhc18g2") || period.BeginsWith("lhc17g8a")) {
241  bits[0] = 8;
242  bits[1] = 9;
243  }
244 
245  else if (period == "lhc11a" || period == "lhc10hold" || period == "lhc11c" || period == "lhc11d") {
246  bits[0] = 8;
247  bits[1] = 4;
248  }
249 
250  else if (period.Contains("lhc12a15a") || period == "lhc12a15f" ||
251  period == "lhc12a15g" || period.BeginsWith("lhc11a1")) {
252  bits[0] = 8;
253  bits[1] = 4;
254  }
255 
256  else {
257  ::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());
258  bits[0] = -1;
259  bits[1] = -1;
260  return kFALSE;
261  }
262 
263  return kTRUE;
264 }
265 
266 namespace PWG {
267 
268 namespace EMCAL {
269 
270 TestAliEmcalTrackSelectionAOD::TestAliEmcalTrackSelectionAOD() :
271  TObject(),
272  fTrackSelHybrid2010wRefit(nullptr),
273  fTrackSelHybrid2010woRefit(nullptr),
274  fTrackSelHybrid2011(nullptr),
275  fTrackSelTPConly(nullptr)
276 {
277 
278 }
279 
285 }
286 
292 }
293 
296 }
297 
299  AliInfoStream() << "Running test for 2010 Definition with non-refit tracks" << std::endl;
300  AliAODTrack testCat1WithRefit, testCat2WithRefit, testCat2WithoutRefit, testNoHybrid;
301  testCat1WithRefit.SetIsHybridGlobalConstrainedGlobal();
302  testCat2WithRefit.SetIsHybridGlobalConstrainedGlobal();
303  testCat2WithoutRefit.SetIsHybridGlobalConstrainedGlobal();
304  testCat1WithRefit.SetStatus(AliVTrack::kITSrefit);
305  testCat2WithRefit.SetStatus(AliVTrack::kITSrefit);
306  testCat1WithRefit.SetFilterMap(BIT(8));
307  testCat2WithRefit.SetFilterMap(BIT(4));
308  testCat2WithoutRefit.SetFilterMap(BIT(4));
309 
310  int nfailure = 0;
311  auto result_cat1_wrefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat1WithRefit);
312  if(!result_cat1_wrefit){
313  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
314  nfailure++;
315  } else {
316  auto hybridcat = FindHybridSelectionResult(result_cat1_wrefit);
317  if(!hybridcat){
318  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
319  nfailure++;
320  } else {
321  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
322  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
323  nfailure++;
324  }
325  }
326  }
327 
328  auto result_cat2_wrefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat2WithRefit);
329  if(!result_cat2_wrefit){
330  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
331  nfailure++;
332  } else {
333  auto hybridcat = FindHybridSelectionResult(result_cat2_wrefit);
334  if(!hybridcat){
335  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
336  nfailure++;
337  } else {
338  if(hybridcat->IsHybridTrackConstrained()) {
339  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
340  nfailure++;
341  }
342  }
343  }
344 
345  auto result_cat2_worefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat2WithoutRefit);
346  if(!result_cat2_worefit){
347  AliErrorStream() << "Hybrid track CAT3 not selected" << std::endl;
348  nfailure++;
349  } else {
350  auto hybridcat = FindHybridSelectionResult(result_cat2_worefit);
351  if(!hybridcat){
352  AliErrorStream() << "No hybrid selection result found for CAT3 hybrid track" << std::endl;
353  nfailure++;
354  } else {
355  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridConstrainedNoITSrefit) {
356  AliErrorStream() << "Incorrect hybrid track type for CAT3 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
357  nfailure++;
358  }
359  }
360  }
361 
362  auto result_nohybrid = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testNoHybrid);
363  if(result_nohybrid){
364  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
365  nfailure++;
366  }
367 
368  return nfailure == 0;
369 }
370 
372  AliInfoStream() << "Running test for 2010 Definition without non-refit tracks" << std::endl;
373  AliAODTrack testCat1WithRefit, testCat2WithRefit, testCat2WithoutRefit, testNoHybrid;
374  testCat1WithRefit.SetIsHybridGlobalConstrainedGlobal();
375  testCat2WithRefit.SetIsHybridGlobalConstrainedGlobal();
376  testCat2WithoutRefit.SetIsHybridGlobalConstrainedGlobal();
377  testCat1WithRefit.SetStatus(AliVTrack::kITSrefit);
378  testCat2WithRefit.SetStatus(AliVTrack::kITSrefit);
379  testCat1WithRefit.SetFilterMap(BIT(8));
380  testCat2WithRefit.SetFilterMap(BIT(4));
381  testCat2WithoutRefit.SetFilterMap(BIT(4));
382 
383  int nfailure = 0;
384  auto result_cat1_wrefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat1WithRefit);
385  if(!result_cat1_wrefit){
386  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
387  nfailure++;
388  } else {
389  auto hybridcat = FindHybridSelectionResult(result_cat1_wrefit);
390  if(!hybridcat){
391  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
392  nfailure++;
393  } else {
394  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
395  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
396  nfailure++;
397  }
398  }
399  }
400 
401  auto result_cat2_wrefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat2WithRefit);
402  if(!result_cat2_wrefit){
403  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
404  nfailure++;
405  } else {
406  auto hybridcat = FindHybridSelectionResult(result_cat2_wrefit);
407  if(!hybridcat){
408  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
409  nfailure++;
410  } else {
411  if(hybridcat->IsHybridTrackConstrained()) {
412  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
413  nfailure++;
414  }
415  }
416  }
417 
418  auto result_cat2_worefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat2WithoutRefit);
419  if(result_cat2_worefit){
420  AliErrorStream() << "CAT2 track without refit selected as hybrid track in track selection excluding non-refit tracks" << std::endl;
421  nfailure++;
422  }
423 
424  auto result_nohybrid = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testNoHybrid);
425  if(result_nohybrid){
426  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
427  nfailure++;
428  }
429 
430  return nfailure == 0;
431 }
432 
434  AliInfoStream() << "Running test for 2011 Definition" << std::endl;
435  AliAODTrack testCat1, testCat2, testNoHybrid;
436  testCat1.SetIsHybridGlobalConstrainedGlobal();
437  testCat2.SetIsHybridGlobalConstrainedGlobal();
438  testCat1.SetStatus(AliVTrack::kITSrefit);
439  testCat2.SetStatus(AliVTrack::kITSrefit);
440  testCat1.SetFilterMap(BIT(8));
441  testCat2.SetFilterMap(BIT(9));
442 
443  int nfailure = 0;
444 
445  auto result_cat1 = fTrackSelHybrid2011->IsTrackAccepted(&testCat1);
446  if(!result_cat1){
447  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
448  nfailure++;
449  } else {
450  auto hybridcat = FindHybridSelectionResult(result_cat1);
451  if(!hybridcat){
452  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
453  nfailure++;
454  } else {
455  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
456  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
457  nfailure++;
458  }
459  }
460  }
461 
462  auto result_cat2 = fTrackSelHybrid2011->IsTrackAccepted(&testCat2);
463  if(!result_cat2){
464  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
465  nfailure++;
466  } else {
467  auto hybridcat = FindHybridSelectionResult(result_cat2);
468  if(!hybridcat){
469  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
470  nfailure++;
471  } else {
472  if(hybridcat->IsHybridTrackConstrained()) {
473  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
474  nfailure++;
475  }
476  }
477  }
478 
479  auto result_nohybrid = fTrackSelHybrid2011->IsTrackAccepted(&testNoHybrid);
480  if(result_nohybrid){
481  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
482  nfailure++;
483  }
484  return nfailure == 0;
485 }
486 
488  AliInfoStream() << "Running test for TPC-only tracks" << std::endl;
489  AliAODTrack testtrackTrue, testtrackFalse;
490  testtrackTrue.SetIsHybridTPCConstrainedGlobal(true);
491 
492  int nfailure = 0;
493  auto result_true = fTrackSelTPConly->IsTrackAccepted(&testtrackTrue);
494  if(!result_true) {
495  AliErrorStream() << "TPC-only constrained track rejected" << std::endl;
496  nfailure++;
497  }
498 
499  auto result_false = fTrackSelTPConly->IsTrackAccepted(&testtrackFalse);
500  if(result_false) {
501  AliErrorStream() << "Non-TPC-only track selected as constrained track" << std::endl;
502  nfailure++;
503  }
504 
505  return nfailure == 0;
506 }
507 
509  if(!data.GetUserInfo()) return nullptr;
510  if(auto hybridinfo = dynamic_cast<const AliEmcalTrackSelResultHybrid *>(data.GetUserInfo())) return hybridinfo;
511  if(auto combinedinfo = dynamic_cast<const AliEmcalTrackSelResultCombined *>(data.GetUserInfo())) {
512  for(int i = 0; i < combinedinfo->GetNumberOfSelectionResults(); i++) {
513  try{
514  auto res = FindHybridSelectionResult((*combinedinfo)[i]);
515  if(res) return res;
517  // just go on
518  }
519  }
520  }
521  return nullptr;
522 }
523 
524 }
525 
526 }
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.
Selection result of the hybrid track selection.
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.