AliPhysics  9b6b435 (9b6b435)
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  std::vector<PWG::EMCAL::AliEmcalTrackSelResultPtr> selectionStatus(fListOfCuts->GetEntries());
171  if (fListOfCuts) {
172  for (auto cutIter : *fListOfCuts){ // @suppress("Symbol is not resolved")
173  PWG::EMCAL::AliEmcalCutBase *trackCuts = static_cast<PWG::EMCAL::AliEmcalCutBase*>(static_cast<AliEmcalManagedObject *>(cutIter)->GetObject());
174  PWG::EMCAL::AliEmcalTrackSelResultPtr cutresults = trackCuts->IsSelected(aodt);
175  if (cutresults) trackbitmap.SetBitNumber(cutcounter);
176  selectionStatus.push_back(cutresults);
177  cutcounter++;
178  }
179  }
180 
182  if (fSelectionModeAny){
183  // In case of ANY one of the cuts need to be fulfilled (equivalent to one but set)
184  result.SetSelectionResult(trackbitmap.CountBits() > 0 || cutcounter == 0);
185  }
186  else {
187  // In case of ALL all of the cuts need to be fulfilled (equivalent to all bits set)
188  result.SetSelectionResult(trackbitmap.CountBits() == cutcounter);
189  }
190  return result;
191 }
192 
194  PWG::EMCAL::AliEmcalAODFilterBitCuts *filtercuts = nullptr;
195  // Find existing filter bit cuts
196  for(auto c : *fListOfCuts) { // @suppress("Symbol is not resolved")
197  if(auto vcutswrapper = dynamic_cast<PWG::EMCAL::AliEmcalVCutsWrapper*>(c)) {
198  if(auto aodcuts = dynamic_cast<PWG::EMCAL::AliEmcalAODFilterBitCuts *>(vcutswrapper->GetCutObject())){
199  filtercuts = aodcuts;
200  break;
201  }
202  }
203  }
204  if(filtercuts) filtercuts->SetFilterBits(filterbits, false);
205  else {
206  filtercuts = new PWG::EMCAL::AliEmcalAODFilterBitCuts("filterbitcuts", "AOD filter bit cuts");
207  filtercuts->SetFilterBits(filterbits, kTRUE);
208  AddTrackCuts(filtercuts);
209  }
210 }
211 
213 {
214  period.ToLower();
215  if (period == "lhc10b" || period == "lhc10c" || period == "lhc10d" ||
216  period == "lhc10e" || period == "lhc10h" ||
217  period == "lhc11h" || period == "lhc12a" || period == "lhc12b" ||
218  period == "lhc12c" || period == "lhc12d" || period == "lhc12e" ||
219  period == "lhc12f" || period == "lhc12g" || period == "lhc12h" ||
220  period == "lhc12i" || period == "lhc13b" || period == "lhc13c" ||
221  period == "lhc13d" || period == "lhc13e" || period == "lhc13f" ||
222  period == "lhc13g" ||
223 
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 == "lhc14j4b" || period == "lhc14j4c" || period == "lhc14j4d" ||
232  period == "lhc14j4e" ||
233  period == "lhc15i2b" || period == "lhc15i2c" || period == "lhc15i2d" ||
234  period == "lhc15i2e" ||
235  period == "lhc15g6b" || period == "lhc15g6c" || period == "lhc15g6d" ||
236  period == "lhc15g6e" ||
237  period == "lhc13b4" || period == "lhc13b4_fix" || period == "lhc13b4_plus" || period == "lhc14k1a" || period == "lhc14k1b" || period == "lhc13e4" ||
238  period.BeginsWith("lhc14a1") || period.BeginsWith("lhc13b2_efix") ||
239  period.BeginsWith("lhc15g6") || period.BeginsWith("lhc16c2") || period.BeginsWith("lhc16e1") || period.BeginsWith("lhc17f8") ||
240  period.BeginsWith("lhc18b8") || period.BeginsWith("lhc18f5") || period.BeginsWith("lhc18g2") || period.BeginsWith("lhc17g8a") ||
241  period.BeginsWith("lhc19a1")) {
242  bits[0] = 8;
243  bits[1] = 9;
244  }
245 
246  else if (period == "lhc11a" || period == "lhc10hold" || period == "lhc11c" || period == "lhc11d") {
247  bits[0] = 8;
248  bits[1] = 4;
249  }
250 
251  else if (period.Contains("lhc12a15a") || period == "lhc12a15f" ||
252  period == "lhc12a15g" || period.BeginsWith("lhc11a1")) {
253  bits[0] = 8;
254  bits[1] = 4;
255  }
256 
257  else {
258  ::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());
259  bits[0] = -1;
260  bits[1] = -1;
261  return kFALSE;
262  }
263 
264  return kTRUE;
265 }
266 
267 namespace PWG {
268 
269 namespace EMCAL {
270 
271 TestAliEmcalTrackSelectionAOD::TestAliEmcalTrackSelectionAOD() :
272  TObject(),
273  fTrackSelHybrid2010wRefit(nullptr),
274  fTrackSelHybrid2010woRefit(nullptr),
275  fTrackSelHybrid2011(nullptr),
276  fTrackSelTPConly(nullptr)
277 {
278 
279 }
280 
286 }
287 
293 }
294 
297 }
298 
300  AliInfoStream() << "Running test for 2010 Definition with non-refit tracks" << std::endl;
301  AliAODTrack testCat1WithRefit, testCat2WithRefit, testCat2WithoutRefit, testNoHybrid;
302  testCat1WithRefit.SetIsHybridGlobalConstrainedGlobal();
303  testCat2WithRefit.SetIsHybridGlobalConstrainedGlobal();
304  testCat2WithoutRefit.SetIsHybridGlobalConstrainedGlobal();
305  testCat1WithRefit.SetStatus(AliVTrack::kITSrefit);
306  testCat2WithRefit.SetStatus(AliVTrack::kITSrefit);
307  testCat1WithRefit.SetFilterMap(BIT(8));
308  testCat2WithRefit.SetFilterMap(BIT(4));
309  testCat2WithoutRefit.SetFilterMap(BIT(4));
310 
311  int nfailure = 0;
312  auto result_cat1_wrefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat1WithRefit);
313  if(!result_cat1_wrefit){
314  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
315  nfailure++;
316  } else {
317  auto hybridcat = FindHybridSelectionResult(result_cat1_wrefit);
318  if(!hybridcat){
319  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
320  nfailure++;
321  } else {
322  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
323  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
324  nfailure++;
325  }
326  }
327  }
328 
329  auto result_cat2_wrefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat2WithRefit);
330  if(!result_cat2_wrefit){
331  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
332  nfailure++;
333  } else {
334  auto hybridcat = FindHybridSelectionResult(result_cat2_wrefit);
335  if(!hybridcat){
336  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
337  nfailure++;
338  } else {
339  if(hybridcat->IsHybridTrackConstrained()) {
340  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
341  nfailure++;
342  }
343  }
344  }
345 
346  auto result_cat2_worefit = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testCat2WithoutRefit);
347  if(!result_cat2_worefit){
348  AliErrorStream() << "Hybrid track CAT3 not selected" << std::endl;
349  nfailure++;
350  } else {
351  auto hybridcat = FindHybridSelectionResult(result_cat2_worefit);
352  if(!hybridcat){
353  AliErrorStream() << "No hybrid selection result found for CAT3 hybrid track" << std::endl;
354  nfailure++;
355  } else {
356  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridConstrainedNoITSrefit) {
357  AliErrorStream() << "Incorrect hybrid track type for CAT3 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
358  nfailure++;
359  }
360  }
361  }
362 
363  auto result_nohybrid = fTrackSelHybrid2010wRefit->IsTrackAccepted(&testNoHybrid);
364  if(result_nohybrid){
365  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
366  nfailure++;
367  }
368 
369  return nfailure == 0;
370 }
371 
373  AliInfoStream() << "Running test for 2010 Definition without non-refit tracks" << std::endl;
374  AliAODTrack testCat1WithRefit, testCat2WithRefit, testCat2WithoutRefit, testNoHybrid;
375  testCat1WithRefit.SetIsHybridGlobalConstrainedGlobal();
376  testCat2WithRefit.SetIsHybridGlobalConstrainedGlobal();
377  testCat2WithoutRefit.SetIsHybridGlobalConstrainedGlobal();
378  testCat1WithRefit.SetStatus(AliVTrack::kITSrefit);
379  testCat2WithRefit.SetStatus(AliVTrack::kITSrefit);
380  testCat1WithRefit.SetFilterMap(BIT(8));
381  testCat2WithRefit.SetFilterMap(BIT(4));
382  testCat2WithoutRefit.SetFilterMap(BIT(4));
383 
384  int nfailure = 0;
385  auto result_cat1_wrefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat1WithRefit);
386  if(!result_cat1_wrefit){
387  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
388  nfailure++;
389  } else {
390  auto hybridcat = FindHybridSelectionResult(result_cat1_wrefit);
391  if(!hybridcat){
392  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
393  nfailure++;
394  } else {
395  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
396  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
397  nfailure++;
398  }
399  }
400  }
401 
402  auto result_cat2_wrefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat2WithRefit);
403  if(!result_cat2_wrefit){
404  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
405  nfailure++;
406  } else {
407  auto hybridcat = FindHybridSelectionResult(result_cat2_wrefit);
408  if(!hybridcat){
409  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
410  nfailure++;
411  } else {
412  if(hybridcat->IsHybridTrackConstrained()) {
413  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
414  nfailure++;
415  }
416  }
417  }
418 
419  auto result_cat2_worefit = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testCat2WithoutRefit);
420  if(result_cat2_worefit){
421  AliErrorStream() << "CAT2 track without refit selected as hybrid track in track selection excluding non-refit tracks" << std::endl;
422  nfailure++;
423  }
424 
425  auto result_nohybrid = fTrackSelHybrid2010woRefit->IsTrackAccepted(&testNoHybrid);
426  if(result_nohybrid){
427  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
428  nfailure++;
429  }
430 
431  return nfailure == 0;
432 }
433 
435  AliInfoStream() << "Running test for 2011 Definition" << std::endl;
436  AliAODTrack testCat1, testCat2, testNoHybrid;
437  testCat1.SetIsHybridGlobalConstrainedGlobal();
438  testCat2.SetIsHybridGlobalConstrainedGlobal();
439  testCat1.SetStatus(AliVTrack::kITSrefit);
440  testCat2.SetStatus(AliVTrack::kITSrefit);
441  testCat1.SetFilterMap(BIT(8));
442  testCat2.SetFilterMap(BIT(9));
443 
444  int nfailure = 0;
445 
446  auto result_cat1 = fTrackSelHybrid2011->IsTrackAccepted(&testCat1);
447  if(!result_cat1){
448  AliErrorStream() << "Hybrid track CAT1 not selected" << std::endl;
449  nfailure++;
450  } else {
451  auto hybridcat = FindHybridSelectionResult(result_cat1);
452  if(!hybridcat){
453  AliErrorStream() << "No hybrid selection result found for CAT1 hybrid track" << std::endl;
454  nfailure++;
455  } else {
456  if(hybridcat->GetHybridTrackType() != AliEmcalTrackSelResultHybrid::kHybridGlobal) {
457  AliErrorStream() << "Incorrect hybrid track type for CAT1 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
458  nfailure++;
459  }
460  }
461  }
462 
463  auto result_cat2 = fTrackSelHybrid2011->IsTrackAccepted(&testCat2);
464  if(!result_cat2){
465  AliErrorStream() << "Hybrid track CAT2 not selected" << std::endl;
466  nfailure++;
467  } else {
468  auto hybridcat = FindHybridSelectionResult(result_cat2);
469  if(!hybridcat){
470  AliErrorStream() << "No hybrid selection result found for CAT2 hybrid track" << std::endl;
471  nfailure++;
472  } else {
473  if(hybridcat->IsHybridTrackConstrained()) {
474  AliErrorStream() << "Incorrect hybrid track type for CAT2 hybrid track: " << hybridcat->GetHybridTrackType() << std::endl;
475  nfailure++;
476  }
477  }
478  }
479 
480  auto result_nohybrid = fTrackSelHybrid2011->IsTrackAccepted(&testNoHybrid);
481  if(result_nohybrid){
482  AliErrorStream() << "Non-hybrid track selected as hybrid track" << std::endl;
483  nfailure++;
484  }
485  return nfailure == 0;
486 }
487 
489  AliInfoStream() << "Running test for TPC-only tracks" << std::endl;
490  AliAODTrack testtrackTrue, testtrackFalse;
491  testtrackTrue.SetIsHybridTPCConstrainedGlobal(true);
492 
493  int nfailure = 0;
494  auto result_true = fTrackSelTPConly->IsTrackAccepted(&testtrackTrue);
495  if(!result_true) {
496  AliErrorStream() << "TPC-only constrained track rejected" << std::endl;
497  nfailure++;
498  }
499 
500  auto result_false = fTrackSelTPConly->IsTrackAccepted(&testtrackFalse);
501  if(result_false) {
502  AliErrorStream() << "Non-TPC-only track selected as constrained track" << std::endl;
503  nfailure++;
504  }
505 
506  return nfailure == 0;
507 }
508 
510  if(!data.GetUserInfo()) return nullptr;
511  if(auto hybridinfo = dynamic_cast<const AliEmcalTrackSelResultHybrid *>(data.GetUserInfo())) return hybridinfo;
512  if(auto combinedinfo = dynamic_cast<const AliEmcalTrackSelResultCombined *>(data.GetUserInfo())) {
513  for(int i = 0; i < combinedinfo->GetNumberOfSelectionResults(); i++) {
514  try{
515  auto res = FindHybridSelectionResult((*combinedinfo)[i]);
516  if(res) return res;
518  // just go on
519  }
520  }
521  }
522  return nullptr;
523 }
524 
525 }
526 
527 }
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.