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