AliPhysics  master (3d17d9d)
AliRDHFCutsDplustoKpipi.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: The ALICE Off-line Project. *
5  * Contributors are mentioned in the code where appropriate. *
6  * *
7  * Permission to use, copy, modify and distribute this software and its *
8  * documentation strictly for non-commercial purposes is hereby granted *
9  * without fee, provided that the above copyright notice appears in all *
10  * copies and that both the copyright notice and this permission notice *
11  * appear in the supporting documentation. The authors make no claims *
12  * about the suitability of this software for any purpose. It is *
13  * provided "as is" without express or implied warranty. *
14  **************************************************************************/
15 
16 /* $Id$ */
17 
19 //
20 // Class for cuts on AOD reconstructed D+->Kpipi
21 //
22 // Author: R. Bala, bala@to.infn.it
23 // G. Ortona, ortona@to.infn.it
25 
26 #include <TDatabasePDG.h>
27 #include <Riostream.h>
28 
29 #include "AliAODPidHF.h"
32 #include "AliAODTrack.h"
33 #include "AliESDtrack.h"
34 
35 
36 using std::cout;
37 using std::endl;
38 
40 ClassImp(AliRDHFCutsDplustoKpipi);
42 
43 
44 //--------------------------------------------------------------------------
46  AliRDHFCuts(name),
47  fUseStrongPid(0),
48  fMaxPtStrongPid(0.),
49  fMaxPStrongPidK(0.),
50  fMaxPStrongPidpi(0.),
51  fUseImpParProdCorrCut(kFALSE),
52  fUsed0MeasMinusExpCut(kFALSE),
53  fMaxd0MeasMinusExp(0x0),
54  fUsed0Cut(kFALSE),
55  fMaxd0(0x0),
56  fScaleNormDLxyBypOverPt(kTRUE)
57 {
58  //
59  // Default Constructor
60  //
61  Int_t nvars=14;
62  SetNVars(nvars);
63  TString varNames[14]={"inv. mass [GeV]",
64  "pTK [GeV/c]",
65  "pTPi [GeV/c]",
66  "d0K [cm] lower limit!",
67  "d0Pi [cm] lower limit!",
68  "dist12 (cm)",
69  "sigmavert (cm)",
70  "dist prim-sec (cm)",
71  "pM=Max{pT1,pT2,pT3} (GeV/c)",
72  "cosThetaPoint",
73  "Sum d0^2 (cm^2)",
74  "dca cut (cm)",
75  "dec len XY (cm)",
76  "cosThetaPointXY"};
77  Bool_t isUpperCut[14]={kTRUE,
78  kFALSE,
79  kFALSE,
80  kFALSE,
81  kFALSE,
82  kFALSE,
83  kTRUE,
84  kFALSE,
85  kFALSE,
86  kFALSE,
87  kFALSE,
88  kTRUE,
89  kFALSE,
90  kFALSE};
91  SetVarNames(nvars,varNames,isUpperCut);
92  Bool_t forOpt[14]={kFALSE,
93  kFALSE,
94  kFALSE,
95  kFALSE,
96  kFALSE,
97  kFALSE,
98  kTRUE,
99  kTRUE,
100  kTRUE,
101  kTRUE,
102  kTRUE,
103  kFALSE,
104  kTRUE,
105  kTRUE};
106  SetVarsForOpt(7,forOpt);
107  Float_t limits[2]={0,999999999.};
108  SetPtBins(2,limits);
109  if(fPidHF)delete fPidHF;
110  fPidHF=new AliAODPidHF();
111  Double_t plim[2]={0.6,0.8};
112  Double_t nsigma[5]={2.,1.,2.,3.,0.};
113 
114  fPidHF->SetPLimit(plim,2);
115  fPidHF->SetAsym(kTRUE);
116  fPidHF->SetSigma(nsigma);
117  fPidHF->SetMatch(1);
118  fPidHF->SetTPC(1);
119  fPidHF->SetTOF(1);
120  fPidHF->SetITS(0);
121  fPidHF->SetTRD(0);
122  fPidHF->SetCompat(kTRUE);
123 
124 
125 }
126 
127 
128 
129 
130 
131 
132 
133 
134 //--------------------------------------------------------------------------
136  AliRDHFCuts(source),
143  fMaxd0MeasMinusExp(0x0),
144  fUsed0Cut(source.fUsed0Cut),
145  fMaxd0(0x0),
147 {
148  //
149  // Copy constructor
150  //
152  if(source.fMaxd0) Setd0Cut(source.fnPtBins,source.fMaxd0);
153 }
154 //--------------------------------------------------------------------------
156 {
157  //
158  // assignment operator
159  //
160  if(&source == this) return *this;
161 
162  AliRDHFCuts::operator=(source);
163 
170  fUsed0Cut=source.fUsed0Cut;
172  if(source.fMaxd0) Setd0Cut(source.fnPtBins,source.fMaxd0);
174 
175  return *this;
176 }
177 
178 //---------------------------------------------------------------------------
180  //
181  // Destructor
182  //
184  if(fMaxd0) delete [] fMaxd0;
185 }
186 //---------------------------------------------------------------------------
188  //
189  // store the cuts
190  //
191  if(nPtBins!=fnPtBins) {
192  printf("Wrong number of pt bins: it has to be %d\n",fnPtBins);
193  AliFatal("exiting");
194  }
196  for(Int_t ib=0; ib<fnPtBins; ib++) fMaxd0MeasMinusExp[ib] = cutval[ib];
197  fUsed0MeasMinusExpCut=kTRUE;
198  return;
199 }
200 
201 //---------------------------------------------------------------------------
203  //
204  // store the cuts
205  //
206  if(nPtBins!=fnPtBins) {
207  printf("Wrong number of pt bins: it has to be %d\n",fnPtBins);
208  AliFatal("exiting");
209  }
210  if(!fMaxd0) fMaxd0 = new Float_t[fnPtBins];
211  for(Int_t ib=0; ib<fnPtBins; ib++) fMaxd0[ib] = cutval[ib];
212  fUsed0Cut=kTRUE;
213  return;
214 }
215 
216 //---------------------------------------------------------------------------
218  //
219  // apply pre selection
220  //
221  if(!fUsePreselect) return 3;
222  Int_t retVal=3;
223 
224  //compute pt
225  Double_t px=0, py=0;
226  AliAODTrack *track[3];
227  for(Int_t iDaught=0; iDaught<3; iDaught++) {
228  track[iDaught] = (AliAODTrack*)aodTracks.At(iDaught);
229  if(!track[iDaught]) return retVal;
230  px += track[iDaught]->Px();
231  py += track[iDaught]->Py();
232  }
233 
234  Double_t ptD=TMath::Sqrt(px*px+py*py);
235 
236  //not enabled for strong PID
237  Int_t pidoptmem = fUseStrongPid;
238  fUseStrongPid=kFALSE;
239  retVal=IsSelectedPID(ptD,aodTracks);
240  fUseStrongPid=pidoptmem;
241 
242  return retVal;
243 }
244 
245 //---------------------------------------------------------------------------
247  //
248  // Fills in vars the values of the variables
249  //
250 
251 
252  if(nvars!=fnVarsForOpt) {
253  printf("AliRDHFCutsDplustoKpipi::GetCutsVarsForOpt: wrong number of variables\n");
254  return;
255  }
256 
258 
259  //recalculate vertex w/o daughters
260  Bool_t cleanvtx=kFALSE;
261  AliAODVertex *origownvtx=0x0;
263  if(dd->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*dd->GetOwnPrimaryVtx());
264  cleanvtx=kTRUE;
265  if(!RecalcOwnPrimaryVtx(dd,aod)) {
266  CleanOwnPrimaryVtx(dd,aod,origownvtx);
267  cleanvtx=kFALSE;
268  }
269  }
270 
271  Int_t iter=-1;
272  if(fVarsForOpt[0]){
273  iter++;
274  vars[iter]=dd->InvMassDplus();
275  }
276  if(fVarsForOpt[1]){
277  iter++;
278  for(Int_t iprong=0;iprong<3;iprong++){
279  if(TMath::Abs(pdgdaughters[iprong])==321) {
280  vars[iter]=dd->PtProng(iprong);
281  }
282  }
283  }
284  if(fVarsForOpt[2]){
285  iter++;
286  Float_t minPtDau=1000000.0;
287  for(Int_t iprong=0;iprong<3;iprong++){
288  if(TMath::Abs(pdgdaughters[iprong])==211) {
289  if(dd->PtProng(iprong)<minPtDau){
290  minPtDau=dd->PtProng(iprong);
291  }
292  }
293  }
294  vars[iter]=minPtDau;
295  }
296  if(fVarsForOpt[3]){
297  iter++;
298  for(Int_t iprong=0;iprong<3;iprong++){
299  if(TMath::Abs(pdgdaughters[iprong])==321) {
300  vars[iter]=dd->Getd0Prong(iprong);
301  }
302  }
303  }
304  if(fVarsForOpt[4]){
305  iter++;
306  Float_t minImpParDau=1000000.0;
307  for(Int_t iprong=0;iprong<3;iprong++){
308  if(TMath::Abs(pdgdaughters[iprong])==211) {
309  if(dd->Getd0Prong(iprong)<minImpParDau){
310  minImpParDau=dd->Getd0Prong(iprong);
311  }
312  }
313  }
314  vars[iter]=minImpParDau;
315  }
316  if(fVarsForOpt[5]){
317  iter++;
318  Float_t dist12 = dd->GetDist12toPrim();
319  Float_t dist23 = dd->GetDist23toPrim();
320  if(dist12<dist23)vars[iter]=dist12;
321  else vars[iter]=dist23;
322  }
323  if(fVarsForOpt[6]){
324  iter++;
325  vars[iter]=dd->GetSigmaVert(aod);
326  }
327  if(fVarsForOpt[7]){
328  iter++;
329  vars[iter] = dd->DecayLength();
330  }
331  if(fVarsForOpt[8]){
332  iter++;
333  Float_t ptmax=0;
334  for(Int_t i=0;i<3;i++){
335  if(dd->PtProng(i)>ptmax)ptmax=dd->PtProng(i);
336  }
337  vars[iter]=ptmax;
338  }
339  if(fVarsForOpt[9]){
340  iter++;
341  vars[iter]=dd->CosPointingAngle();
342  }
343  if(fVarsForOpt[10]){
344  iter++;
345  vars[iter]=dd->Getd0Prong(0)*dd->Getd0Prong(0)+dd->Getd0Prong(1)*dd->Getd0Prong(1)+dd->Getd0Prong(2)*dd->Getd0Prong(2);
346  }
347  if(fVarsForOpt[11]){
348  iter++;
349  Float_t maxDCA=0;
350  for(Int_t iprong=0;iprong<3;iprong++){
351  if(dd->GetDCA(iprong)<maxDCA){
352  maxDCA=dd->GetDCA(iprong);
353  }
354  }
355  vars[iter]=maxDCA;
356  }
357  if(fVarsForOpt[12]){
358  iter++;
359  if(fScaleNormDLxyBypOverPt) vars[iter]=dd->NormalizedDecayLengthXY()*dd->P()/dd->Pt();
360  else vars[iter]=dd->NormalizedDecayLengthXY();
361  }
362  if(fVarsForOpt[13]){
363  iter++;
364  vars[iter]=dd->CosPointingAngleXY();
365  }
366 
367  if(cleanvtx)CleanOwnPrimaryVtx(dd,aod,origownvtx);
368 
369  return;
370 }
371 //---------------------------------------------------------------------------
373 {
374  //
375  // Checking if Dplus is in fiducial acceptance region
376  //
377 
378  if(fMaxRapidityCand>-998.){
379  if(TMath::Abs(y) > fMaxRapidityCand) return kFALSE;
380  else return kTRUE;
381  }
382 
383  if(pt > 5.) {
384  // applying cut for pt > 5 GeV
385  AliDebug(2,Form("pt of D+ = %f (> 5), cutting at |y| < 0.8",pt));
386  if (TMath::Abs(y) > 0.8) return kFALSE;
387 
388  } else {
389  // appliying smooth cut for pt < 5 GeV
390  Double_t maxFiducialY = -0.2/15*pt*pt+1.9/15*pt+0.5;
391  Double_t minFiducialY = 0.2/15*pt*pt-1.9/15*pt-0.5;
392  AliDebug(2,Form("pt of D+ = %f (< 5), cutting according to the fiducial zone [%f, %f]\n",pt,minFiducialY,maxFiducialY));
393  if (y < minFiducialY || y > maxFiducialY) return kFALSE;
394  }
395 
396  return kTRUE;
397 }
398 
399 //---------------------------------------------------------------------------
401 {
402  if(!fUsePID || !rd) return -1;
403  //if(fUsePID)printf("i am inside the pid \n");
404  Int_t mask=0;
405  Int_t sign=rd->GetCharge();
406  for(Int_t daught=0;daught<3;daught++){
407  AliAODTrack *track=(AliAODTrack*)rd->GetDaughter(daught);
408 
409  if(sign==track->Charge()){//pions
410  Int_t isPion=fPidHF->MakeRawPid(track,AliPID::kPion);
411  if(isPion==0)mask+=1;
412  else if(isPion>0)mask+=3;
413  mask=mask<<2;
414  }
415  else{//kaons
416  Int_t isKaon=fPidHF->MakeRawPid(track,AliPID::kKaon);
417  if(isKaon==0)mask+=1;
418  else if(isKaon>0)mask+=3;
419  mask=mask<<2;
420  }
421  }
422  mask=mask>>2;
423  return mask;
424 }
425 //---------------------------------------------------------------------------
427 {
428  //
429  // PID selection, returns 3 if accepted, 0 if not accepted
430  //
431  Int_t retCode=3;
432  if(!fUsePID) return retCode;
433  if(rd) {
434  Double_t Pt = rd->Pt();
435  TObjArray aodtracks(3);
436  for(Int_t daught=0; daught<3; daught++) {
437  aodtracks.AddAt(rd->GetDaughter(daught),daught);
438  }
439  retCode = IsSelectedPID(Pt,aodtracks);
440  }
441 
442  return retCode;
443 }
444 
445 //---------------------------------------------------------------------------
447  //
448  // PID selection, returns 3 if accepted, 0 if not accepted
449  //
450  AliAODTrack *track[3];
451  for(Int_t daught=0; daught<3; daught++){
452  track[daught]=(AliAODTrack*)aodtracks.At(daught);
453  }
454 
455  if(!fUsePID || !track[0] || !track[1] || !track[2]) return 3;
456 
457  Int_t sign = track[0]->Charge();
458 
459  //if(fUsePID)printf("i am inside the pid \n");
460  Int_t nkaons=0;
461  Int_t nNotKaons=0;
462  for(Int_t daught=0;daught<3;daught++){
463  Int_t isPion=fPidHF->MakeRawPid(track[daught],AliPID::kPion);
464  Int_t isKaon=fPidHF->MakeRawPid(track[daught],AliPID::kKaon);
465  Int_t isProton=fPidHF->MakeRawPid(track[daught],AliPID::kProton);
466 
467  if(isProton>0 && isKaon<0 && isPion<0) return 0;
468  if(isKaon>0 && isPion<0) nkaons++;
469  if(isKaon<0) nNotKaons++;
470  if(sign==track[daught]->Charge()){//pions
471  if(isPion<0)return 0;
472  if(Pt<fMaxPtStrongPid && isPion<=0 && fUseStrongPid&2 && track[daught]->P()<fMaxPStrongPidpi)return 0;
473  }
474  else{//kaons
475  if(isKaon<0)return 0;
476  if(Pt<fMaxPtStrongPid && isKaon<=0 && fUseStrongPid&1&& track[daught]->P()<fMaxPStrongPidK)return 0;
477  }
478  }
479 
480  if(nkaons>1)return 0;
481  if(nNotKaons==3)return 0;
482 
483  return 3;
484 }
485 
486 //---------------------------------------------------------------------------
488  //
489  // Apply selection, returns 3 if accepted, 0 if not accepted
490  //
491 
492 
493  fIsSelectedCuts=0;
494  fIsSelectedPID=0;
495 
496  if(!fCutsRD){
497  cout<<"Cut matrix not inizialized. Exit..."<<endl;
498  return 0;
499  }
500  //PrintAll();
502 
503 
504  if(!d){
505  cout<<"AliAODRecoDecayHF3Prong null"<<endl;
506  return 0;
507  }
508 
509  if(fKeepSignalMC) if(IsSignalMC(d,aod,411)) return 3;
510 
511  // PID selection
512  Int_t returnvaluePID=3;
513  Int_t returnvalueCuts=3;
514 
515  Double_t pt=d->Pt();
516  if(pt<fMinPtCand) return 0;
517  if(pt>fMaxPtCand) return 0;
518 
520 
521  // selection on candidate
522  if(selectionLevel==AliRDHFCuts::kAll ||
523  selectionLevel==AliRDHFCuts::kCandidate) {
524 
525  //recalculate vertex w/o daughters
526  AliAODVertex *origownvtx=0x0;
528  if(d->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*d->GetOwnPrimaryVtx());
529  if(!RecalcOwnPrimaryVtx(d,aod)) {
530  CleanOwnPrimaryVtx(d,aod,origownvtx);
531  return 0;
532  }
533  }
534 
535  if(fUseMCVertex) {
536  if(d->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*d->GetOwnPrimaryVtx());
537  if(!SetMCPrimaryVtx(d,aod)) {
538  CleanOwnPrimaryVtx(d,aod,origownvtx);
539  return 0;
540  }
541  }
542 
543  Int_t ptbin=PtBin(pt);
544  if (ptbin==-1) {
545  CleanOwnPrimaryVtx(d,aod,origownvtx);
546  return 0;
547  }
548 
549  //sec vert
550  Double_t sigmavert=d->GetSigmaVert(aod);
551  if(sigmavert>fCutsRD[GetGlobalIndex(6,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
552 
553  // Decay length and pointing angle
554  if(d->DecayLength2()<fCutsRD[GetGlobalIndex(7,ptbin)]*fCutsRD[GetGlobalIndex(7,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
555  if(d->CosPointingAngle()< fCutsRD[GetGlobalIndex(9,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
557  if(d->NormalizedDecayLengthXY()*d->P()/pt<fCutsRD[GetGlobalIndex(12,ptbin)]){CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
558  }else{
559  if(d->NormalizedDecayLengthXY()<fCutsRD[GetGlobalIndex(12,ptbin)]){CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
560  }
561  if(d->CosPointingAngleXY()<fCutsRD[GetGlobalIndex(13,ptbin)]){CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
562 
563  //2track cuts
564  if(d->GetDist12toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)]|| d->GetDist23toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
565 
566  Double_t sum2=d->Getd0Prong(0)*d->Getd0Prong(0)+d->Getd0Prong(1)*d->Getd0Prong(1)+d->Getd0Prong(2)*d->Getd0Prong(2);
567  if(sum2<fCutsRD[GetGlobalIndex(10,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
568 
570  if(d->Getd0Prong(0)*d->Getd0Prong(1)<0. && d->Getd0Prong(2)*d->Getd0Prong(1)<0.) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
571  }
572 
573 
574  //DCA
575  for(Int_t i=0;i<3;i++) if(d->GetDCA(i)>fCutsRD[GetGlobalIndex(11,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
576 
577  if(d->Pt2Prong(1) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] || TMath::Abs(d->Getd0Prong(1))<fCutsRD[GetGlobalIndex(3,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}//Kaon
578 
579  if(d->Pt2Prong(0) < fCutsRD[GetGlobalIndex(2,ptbin)]*fCutsRD[GetGlobalIndex(2,ptbin)] || TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(4,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}//Pion1
580 
581  if(d->Pt2Prong(2) < fCutsRD[GetGlobalIndex(2,ptbin)]*fCutsRD[GetGlobalIndex(2,ptbin)] || TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(4,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}//Pion2
582 
583  if(d->Pt2Prong(0)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)] && d->Pt2Prong(1)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)] && d->Pt2Prong(2)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
584 
585 
586 
587  // d0meas-exp
589  Double_t dd0max=0;
590  for(Int_t ipr=0; ipr<3; ipr++) {
591  Double_t diffIP, errdiffIP;
592  d->Getd0MeasMinusExpProng(ipr,aod->GetMagneticField(),diffIP,errdiffIP);
593  Double_t normdd0=0.;
594  if(errdiffIP>0) normdd0=diffIP/errdiffIP;
595  if(ipr==0) dd0max=normdd0;
596  else if(TMath::Abs(normdd0)>TMath::Abs(dd0max)) dd0max=normdd0;
597  }
598  if(TMath::Abs(dd0max)>fMaxd0MeasMinusExp[ptbin]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
599  }
600 
601  // d0
602  if(fUsed0Cut){
603  Double_t d0=d->ImpParXY()*10000.;
604  if(TMath::Abs(d0)>fMaxd0[ptbin]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
605  }
606 
607  Double_t mDplusPDG = TDatabasePDG::Instance()->GetParticle(411)->Mass();
608  Double_t mDplus=d->InvMassDplus();
609  if(TMath::Abs(mDplus-mDplusPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
610 
611  // unset recalculated primary vertex when not needed any more
612  CleanOwnPrimaryVtx(d,aod,origownvtx);
613 
614  fIsSelectedCuts=returnvalueCuts;
615 
616  //if(!returnvalueCuts) return 0; // returnvalueCuts cannot be 0 here
617  }
618 
619  if(selectionLevel==AliRDHFCuts::kAll ||
620  selectionLevel==AliRDHFCuts::kCandidate ||
621  selectionLevel==AliRDHFCuts::kPID) {
622  returnvaluePID = IsSelectedPID(d);
623  fIsSelectedPID=returnvaluePID;
624  }
625  if(returnvaluePID==0)return 0;
626 
627  // selection on daughter tracks
628  if(selectionLevel==AliRDHFCuts::kAll ||
629  selectionLevel==AliRDHFCuts::kTracks) {
630  if(!AreDaughtersSelected(d,aod)) return 0;
631  }
632 
633 
634 
635 
636  return 3;
637 }
638 
639 
640 
641 
642 //---------------------------------------------------------------------------
643 
644 
646  //
647  //STANDARD CUTS USED FOR 2010 pp analysis
648  //
649 
650  SetName("DplustoKpipiCutsStandard");
651  SetTitle("Standard Cuts for D+ analysis");
652 
653  // PILE UP REJECTION
655 
656  // EVENT CUTS
657  SetMinVtxContr(1);
658 
659  AliESDtrackCuts* esdTrackCuts=new AliESDtrackCuts();
660  esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
661  //default
662  esdTrackCuts->SetRequireTPCRefit(kTRUE);
663  esdTrackCuts->SetRequireITSRefit(kTRUE);
664  //esdTrackCuts->SetMinNClustersITS(4); // default is 5
665  esdTrackCuts->SetMinNClustersTPC(70);
666  esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
667  AliESDtrackCuts::kAny);
668  // default is kBoth, otherwise kAny
669  esdTrackCuts->SetMinDCAToVertexXY(0.);
670  esdTrackCuts->SetPtRange(0.3,1.e10);
671 
672  AddTrackCuts(esdTrackCuts);
673 
674 
675  const Int_t nptbins =15;
676  const Int_t nvars=14;
677  Float_t ptbins[nptbins+1];
678  ptbins[0]=0.;
679  ptbins[1]=1;
680  ptbins[2]=2.;
681  ptbins[3]=3.;
682  ptbins[4]=4.;
683  ptbins[5]=5.;
684  ptbins[6]=6.;
685  ptbins[7]=7.;
686  ptbins[8]=8.;
687  ptbins[9]=9.;
688  ptbins[10]=10.;
689  ptbins[11]=12.;
690  ptbins[12]=14.;
691  ptbins[13]=16.;
692  ptbins[14]=24.;
693  ptbins[15]=99999.;
694 
695 
696  Float_t** anacutsval;
697  anacutsval=new Float_t*[nvars];
698 
699  for(Int_t ic=0;ic<nvars;ic++){anacutsval[ic]=new Float_t[nptbins];}
700 
701  //Double_t cutsDplus[12]={0.2,0.4,0.4,0.,0.,0.01,0.06,0.02,0.,0.85,0.,10000000000.};
702  for(Int_t ipt=0;ipt<nptbins;ipt++){
703  anacutsval[0][ipt]=0.2;
704  anacutsval[3][ipt]=0.;
705  anacutsval[4][ipt]=0.;
706  anacutsval[5][ipt]=0.01;
707  anacutsval[11][ipt]=10000000000.;
708  }
709 
710  anacutsval[1][0]=0.3;
711  anacutsval[1][1]=0.4;
712  anacutsval[1][2]=0.4;
713  anacutsval[2][0]=0.3;
714  anacutsval[2][1]=0.3;
715  anacutsval[2][2]=0.4;
716  for(Int_t ipt=3;ipt<nptbins;ipt++){
717  anacutsval[1][ipt]=0.4;
718  anacutsval[2][ipt]=0.4;
719  }
720 
721  anacutsval[6][0]=0.022100;
722  anacutsval[6][1]=0.022100;
723  anacutsval[6][2]=0.034;
724  anacutsval[6][3]=0.020667;
725  anacutsval[6][4]=0.020667;
726  anacutsval[6][5]=0.023333;
727 
728 
729  anacutsval[7][0]=0.08;
730  anacutsval[7][1]=0.08;
731  anacutsval[7][2]=0.09;
732  anacutsval[7][3]=0.095;
733  anacutsval[7][4]=0.095;
734 
735  anacutsval[8][0]=0.5;
736  anacutsval[8][1]=0.5;
737  anacutsval[8][2]=1.0;
738  anacutsval[8][3]=0.5;
739  anacutsval[8][4]=0.5;
740 
741 
742  anacutsval[9][0]=0.97;
743  anacutsval[9][1]=0.936;
744  anacutsval[9][2]=0.95;
745  anacutsval[9][3]=0.95;
746  anacutsval[9][4]= 0.95;
747  anacutsval[9][5]=0.92;
748  anacutsval[9][6]=0.92;
749  anacutsval[9][7]=0.92;
750  anacutsval[9][8]=0.92;
751  anacutsval[9][9]=0.90;
752  for(Int_t ipt=10;ipt<nptbins;ipt++){
753  anacutsval[9][ipt]=0.90;
754  }
755 
756 
757  anacutsval[10][0]=0.0055;
758  anacutsval[10][1]=0.0055;
759  anacutsval[10][2]= 0.0028;
760  anacutsval[10][3]=0.000883;
761  anacutsval[10][4]=0.000883;
762 
763 
764  for(Int_t ipt=5;ipt<nptbins;ipt++){
765  anacutsval[6][ipt]=0.02333;
766  anacutsval[7][ipt]=0.115;
767  anacutsval[8][ipt]=0.5;
768  anacutsval[10][ipt]=0.000883;
769  }
770 
771  anacutsval[12][0]=8;
772  anacutsval[12][1]=8;
773 
774  anacutsval[13][0]=0.98;
775  anacutsval[13][1]=0.98;
776  for(Int_t ipt=2;ipt<nptbins;ipt++){
777  anacutsval[12][ipt]=0.;
778  anacutsval[13][ipt]=0.;
779  }
780 
781 
782 
783  SetGlobalIndex(nvars,nptbins);
784  SetPtBins(nptbins+1,ptbins);
785  SetCuts(nvars,nptbins,anacutsval);
786  SetUsePID(kTRUE);
787  fPidHF->SetOldPid(kTRUE);
789 
790  // PrintAll();
791 
792  for(Int_t iic=0;iic<nvars;iic++){delete [] anacutsval[iic];}
793  delete [] anacutsval;
794  anacutsval=NULL;
795 
796  delete esdTrackCuts;
797  esdTrackCuts=NULL;
798 
799  return;
800 }
801 
802 
804  //
805  //STANDARD CUTS USED FOR 2010 Pb Pb analysis.... not optimized yet
806  //
807 
808  SetName("DplustoKpipiCutsStandard");
809  SetTitle("Standard Cuts for D+ analysis in PbPb2010 run");
810 
811  // PILE UP REJECTION
812  //SetOptPileup(AliRDHFCuts::kRejectPileupEvent);
813 
814  // EVENT CUTS
815  SetMinVtxContr(1);
816 
817 
818  AliESDtrackCuts* esdTrackCuts=new AliESDtrackCuts();
819  esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
820  //default
821  esdTrackCuts->SetRequireTPCRefit(kTRUE);
822  esdTrackCuts->SetRequireITSRefit(kTRUE);
823  //esdTrackCuts->SetMinNClustersITS(4); // default is 5
824  esdTrackCuts->SetMinNClustersTPC(70);
825  esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
826  AliESDtrackCuts::kAny);
827  // default is kBoth, otherwise kAny
828  esdTrackCuts->SetMinDCAToVertexXY(0.);
829  esdTrackCuts->SetPtRange(0.8,1.e10);
830 
831  AddTrackCuts(esdTrackCuts);
832 
833  const Int_t nptbins=10;
834  Float_t* ptbins;
835  ptbins=new Float_t[nptbins+1];
836 
837  ptbins[0]=0.;
838  ptbins[1]=1.;
839  ptbins[2]=2.;
840  ptbins[3]=3.;
841  ptbins[4]=4.;
842  ptbins[5]=5.;
843  ptbins[6]=6.;
844  ptbins[7]=8.;
845  ptbins[8]=12.;
846  ptbins[9]=16.;
847  ptbins[10]=24.;
848  const Int_t nvars=14;
849 
850  Float_t** anacutsval;
851  anacutsval=new Float_t*[nvars];
852 
853  for(Int_t ic=0;ic<nvars;ic++){anacutsval[ic]=new Float_t[nptbins];}
854  //Double_t cutsDplus[12]={0.2,0.4,0.4,0.,0.,0.01,0.06,0.02,0.,0.85,0.,10000000000.};
855 
856  for(Int_t ipt=0;ipt<nptbins;ipt++){
857  anacutsval[0][ipt]=0.2;
858  anacutsval[1][ipt]=0.8;
859  anacutsval[2][ipt]=0.8;
860  anacutsval[3][ipt]=0.;
861  anacutsval[4][ipt]=0.;
862  anacutsval[5][ipt]=0.01;
863  anacutsval[11][ipt]=10000000000.;
864  anacutsval[12][ipt]=0.;
865  anacutsval[13][ipt]=0.;
866  }
867  anacutsval[1][5]=0.9;
868 
869  anacutsval[6][0]=0.022100;
870  anacutsval[6][1]=0.022100;
871  anacutsval[6][2]=0.034;
872  anacutsval[6][3]=0.020667;
873  anacutsval[6][4]=0.020667;
874  anacutsval[6][5]=0.023333;
875 
876  anacutsval[7][0]=0.08;
877  anacutsval[7][1]=0.08;
878  anacutsval[7][2]=0.17;
879  anacutsval[7][3]=0.14;
880  anacutsval[7][4]=0.14;
881  anacutsval[7][5]=0.19;
882 
883  anacutsval[8][0]=0.8;
884  anacutsval[8][1]=0.8;
885  anacutsval[8][2]=1.1;
886  anacutsval[8][3]=0.5;
887  anacutsval[8][4]=0.5;
888  anacutsval[8][5]=0.5;
889 
890  anacutsval[9][0]=0.995;
891  anacutsval[9][1]=0.995;
892  anacutsval[9][2]=0.997;
893  anacutsval[9][3]=0.998;
894  anacutsval[9][4]=0.998;
895  anacutsval[9][5]=0.995;
896 
897  anacutsval[10][0]=0.0055;
898  anacutsval[10][1]=0.0055;
899  anacutsval[10][2]= 0.0028;
900  anacutsval[10][3]=0.000883;
901  anacutsval[10][4]=0.000883;
902  anacutsval[10][5]=0.000883;
903 
904  anacutsval[12][5]=12.;
905  anacutsval[13][5]=0.998571;
906  anacutsval[12][6]=10.;
907  anacutsval[13][6]=0.997143;
908 
909  for(Int_t ipt=6;ipt<nptbins;ipt++){
910  anacutsval[6][ipt]=0.02333;
911  anacutsval[7][ipt]=0.19;
912  anacutsval[8][ipt]=2.0;
913  anacutsval[9][ipt]=0.997;
914  anacutsval[10][ipt]=0.000883;
915  }
916  anacutsval[7][6]=0.14;
917  anacutsval[9][6]=0.995;
918 
919  SetPtBins(nptbins+1,ptbins);
920  SetCuts(nvars,nptbins,anacutsval);
921  SetUsePID(kTRUE);
922  fPidHF->SetOldPid(kTRUE);
923  SetMinCentrality(1E-10);
924  SetMaxCentrality(20.);
927 
928  // PrintAll();
929 
930  for(Int_t iic=0;iic<nvars;iic++){delete [] anacutsval[iic];}
931  delete [] anacutsval;
932  anacutsval=NULL;
933 
934  delete [] ptbins;
935  ptbins=NULL;
936 
937  delete esdTrackCuts;
938  esdTrackCuts=NULL;
939 
940  return;
941 }
942 
943 
945 
946  // Default 2010 PbPb cut object
948 
949  // Enable all 2011 PbPb run triggers
950  //
951  SetTriggerClass("");
955 
956  // new PID
957  fPidHF->SetOldPid(kFALSE);
958 
959 }
960 //--------------------------------------------------------------------------
961 
963 
964  UInt_t bitmap=0;
965 
966  Double_t sigmaTPCPionHyp=-999.;
967  Double_t sigmaTPCKaonHyp=-999.;
968  Double_t sigmaTPCProtonHyp=-999.;
969  Double_t sigmaTOFPionHyp=-999.;
970  Double_t sigmaTOFKaonHyp=-999.;
971  Double_t sigmaTOFProtonHyp=-999.;
972 
973  Int_t oksigmaTPCPionHyp=fPidHF->GetnSigmaTPC(track,2,sigmaTPCPionHyp);
974  Int_t oksigmaTPCKaonHyp=fPidHF->GetnSigmaTPC(track,3,sigmaTPCKaonHyp);
975  Int_t oksigmaTPCProtonHyp=fPidHF->GetnSigmaTPC(track,4,sigmaTPCProtonHyp);
976  Int_t oksigmaTOFPionHyp=fPidHF->GetnSigmaTOF(track,2,sigmaTOFPionHyp);
977  Int_t oksigmaTOFKaonHyp=fPidHF->GetnSigmaTOF(track,3,sigmaTOFKaonHyp);
978  Int_t oksigmaTOFProtonHyp=fPidHF->GetnSigmaTOF(track,4,sigmaTOFProtonHyp);
979 
980  sigmaTPCPionHyp=TMath::Abs(sigmaTPCPionHyp);
981  sigmaTPCKaonHyp=TMath::Abs(sigmaTPCKaonHyp);
982  sigmaTPCProtonHyp=TMath::Abs(sigmaTPCProtonHyp);
983  sigmaTOFPionHyp=TMath::Abs(sigmaTOFPionHyp);
984  sigmaTOFKaonHyp=TMath::Abs(sigmaTOFKaonHyp);
985  sigmaTOFProtonHyp=TMath::Abs(sigmaTOFProtonHyp);
986 
987  if (oksigmaTPCPionHyp && sigmaTPCPionHyp>0.){
988  if (sigmaTPCPionHyp<1.) bitmap+=1<<kTPCPionLess1;
989  else{
990  if (sigmaTPCPionHyp<2.) bitmap+=1<<kTPCPionMore1Less2;
991  else {
992  if (sigmaTPCPionHyp<3.) bitmap+=1<<kTPCPionMore2Less3;
993  else bitmap+=1<<kTPCPionMore3;
994  }
995  }
996  }
997 
998  if (oksigmaTPCKaonHyp && sigmaTPCKaonHyp>0.){
999  if (sigmaTPCKaonHyp<1.) bitmap+=1<<kTPCKaonLess1;
1000  else{
1001  if (sigmaTPCKaonHyp<2.) bitmap+=1<<kTPCKaonMore1Less2;
1002  else {
1003  if (sigmaTPCKaonHyp<3.) bitmap+=1<<kTPCKaonMore2Less3;
1004  else bitmap+=1<<kTPCKaonMore3;
1005  }
1006  }
1007  }
1008 
1009  if (oksigmaTPCProtonHyp && sigmaTPCProtonHyp>0.){
1010  if (sigmaTPCProtonHyp<1.) bitmap+=1<<kTPCProtonLess1;
1011  else{
1012  if (sigmaTPCProtonHyp<2.) bitmap+=1<<kTPCProtonMore1Less2;
1013  else {
1014  if (sigmaTPCProtonHyp<3.) bitmap+=1<<kTPCProtonMore2Less3;
1015  else bitmap+=1<<kTPCProtonMore3;
1016  }
1017  }
1018  }
1019 
1020  if (oksigmaTOFPionHyp && sigmaTOFPionHyp>0.){
1021  if (sigmaTOFPionHyp<1.) bitmap+=1<<kTOFPionLess1;
1022  else{
1023  if (sigmaTOFPionHyp<2.) bitmap+=1<<kTOFPionMore1Less2;
1024  else {
1025  if (sigmaTOFPionHyp<3.) bitmap+=1<<kTOFPionMore2Less3;
1026  else bitmap+=1<<kTOFPionMore3;
1027  }
1028  }
1029  }
1030 
1031  if (oksigmaTOFKaonHyp && sigmaTOFKaonHyp>0.){
1032  if (sigmaTOFKaonHyp<1.) bitmap+=1<<kTOFKaonLess1;
1033  else{
1034  if (sigmaTOFKaonHyp<2.) bitmap+=1<<kTOFKaonMore1Less2;
1035  else {
1036  if (sigmaTOFKaonHyp<3.) bitmap+=1<<kTOFKaonMore2Less3;
1037  else bitmap+=1<<kTOFKaonMore3;
1038  }
1039  }
1040  }
1041 
1042  if (oksigmaTOFProtonHyp && sigmaTOFProtonHyp>0.){
1043  if (sigmaTOFProtonHyp<1.) bitmap+=1<<kTOFProtonLess1;
1044  else{
1045  if (sigmaTOFProtonHyp<2.) bitmap+=1<<kTOFProtonMore1Less2;
1046  else {
1047  if (sigmaTOFProtonHyp<3.) bitmap+=1<<kTOFProtonMore2Less3;
1048  else bitmap+=1<<kTOFProtonMore3;
1049  }
1050  }
1051  }
1052 
1053 
1054 
1055  return bitmap;
1056 
1057 }
1058 //---------------------------------------------------------------------------
1060  //
1061  // print all cuts values
1062  //
1065  printf("Cuts on d0meas-d0exp:\n");
1066  for(Int_t ib=0;ib<fnPtBins;ib++){
1067  printf("%f ",fMaxd0MeasMinusExp[ib]);
1068  }
1069  printf("\n");
1070  }else{
1071  printf("No cut on d0meas-d0exp:\n");
1072  }
1073  if(fUsed0Cut){
1074  printf("Cuts on d0:\n");
1075  for(Int_t ib=0;ib<fnPtBins;ib++){
1076  printf("%f ",fMaxd0[ib]);
1077  }
1078  printf("\n");
1079  }else{
1080  printf("No cut on d0\n");
1081  }
1083  printf("NormDLxy scaled by p/pt\n");
1084  }else{
1085  printf("NormDLxy NOT scaled by p/pt\n");
1086  }
1088  printf("d0K*d0pi1 vs. d0K*d0pi2 cut enabled\n");
1089  }else{
1090  printf("d0K*d0pi1 vs. d0K*d0pi2 cut disabled\n");
1091  }
1092 }
Double_t NormalizedDecayLengthXY() const
Int_t fIsSelectedCuts
fix the daughter track references
Definition: AliRDHFCuts.h:497
Bool_t fUsed0MeasMinusExpCut
switch for d0K*d0pi1 vs. d0K*d0pi2 cut
void SetAsym(Bool_t asym)
Definition: AliAODPidHF.h:101
Int_t PtBin(Float_t pt) const
Definition: AliRDHFCuts.h:330
#define P(T, U, S)
double Double_t
Definition: External.C:58
Bool_t IsSignalMC(AliAODRecoDecay *d, AliAODEvent *aod, Int_t pdg) const
void Setd0MeasMinusExpCut(Int_t nPtBins, Float_t *cutval)
void Getd0MeasMinusExpProng(Int_t ip, Double_t magf, Double_t &d0diff, Double_t &errd0diff) const
AliRDHFCutsDplustoKpipi & operator=(const AliRDHFCutsDplustoKpipi &source)
Int_t GetnSigmaTOF(AliAODTrack *track, Int_t species, Double_t &sigma) const
void SetTRD(Bool_t trd)
Definition: AliAODPidHF.h:110
Bool_t fUseMCVertex
flag to switch on the removal of duaghters from the primary vertex computation
Definition: AliRDHFCuts.h:482
Bool_t SetMCPrimaryVtx(AliAODRecoDecayHF *d, AliAODEvent *aod) const
Bool_t fRemoveDaughtersFromPrimary
Definition: AliRDHFCuts.h:481
Int_t GetnSigmaTPC(AliAODTrack *track, Int_t species, Double_t &sigma) const
void SetUseCentrality(Int_t flag=1)
Int_t GetPIDBitMask(AliAODRecoDecayHF *rd)
Double_t ImpParXY() const
Float_t fMaxPStrongPidpi
Maximum P of track to apply strong Pid on K.
void Setd0Cut(Int_t nPtBins, Float_t *cutval)
void SetNVars(Int_t nVars)
Definition: AliRDHFCuts.h:445
UInt_t GetPIDTrackTPCTOFBitMap(AliAODTrack *track) const
Double_t CosPointingAngleXY() const
Double_t fMaxRapidityCand
minimum pt of the candidate
Definition: AliRDHFCuts.h:501
void EnableSemiCentralTrigger()
Definition: AliRDHFCuts.h:101
void SetGlobalIndex()
Definition: AliRDHFCuts.h:213
virtual Bool_t IsInFiducialAcceptance(Double_t pt, Double_t y) const
AliRDHFCuts & operator=(const AliRDHFCuts &source)
Bool_t fUsePID
Definition: AliRDHFCuts.h:476
AliRDHFCutsDplustoKpipi(const char *name="CutsDplustoKpipi")
Float_t * fMaxd0
switch for cut on d0
void SetTOF(Bool_t tof)
Definition: AliAODPidHF.h:108
Bool_t HasBadDaughters() const
Float_t * fMaxd0MeasMinusExp
switch for cut on d0meas-d0exp
Class for cuts on AOD reconstructed D+->Kpipi.
void SetMinVtxContr(Int_t contr=1)
Definition: AliRDHFCuts.h:62
int Int_t
Definition: External.C:63
Bool_t fUseTrackSelectionWithFilterBits
flag to reject kink daughters
Definition: AliRDHFCuts.h:512
void SetCuts(Int_t nVars, Int_t nPtBins, Float_t **cutsRD)
Int_t fnVarsForOpt
Definition: AliRDHFCuts.h:471
void ResetMaskAndEnableMBTrigger()
Definition: AliRDHFCuts.h:81
void SetMinCentrality(Float_t minCentrality=0.)
Definition: AliRDHFCuts.h:54
virtual Int_t IsSelected(TObject *obj, Int_t selectionLevel)
unsigned int UInt_t
Definition: External.C:33
Bool_t fUseImpParProdCorrCut
Maximum P of track to apply strong Pid on pi.
float Float_t
Definition: External.C:68
virtual void GetCutVarsForOpt(AliAODRecoDecayHF *d, Float_t *vars, Int_t nvars, Int_t *pdgdaughters)
const Double_t ptmax
Double_t fMaxPtCand
minimum pt of the candidate
Definition: AliRDHFCuts.h:500
Float_t fMaxPStrongPidK
Maximum pt of candidate to apply strong Pid.
AliAODVertex * GetOwnPrimaryVtx() const
Bool_t fKeepSignalMC
max rapidity of candidate (if !=-999 overrides IsInFiducialAcceptance)
Definition: AliRDHFCuts.h:502
Double_t GetSigmaVert(const AliAODEvent *aod=0x0)
virtual Int_t PreSelect(TObjArray aodTracks)
Int_t fIsSelectedPID
outcome of cuts selection
Definition: AliRDHFCuts.h:498
Double_t nsigma
Int_t MakeRawPid(AliAODTrack *track, Int_t specie)
void SetSigma(Double_t *sigma)
Definition: AliAODPidHF.h:52
Float_t * fCutsRD
fnVars*fnPtBins
Definition: AliRDHFCuts.h:474
Double_t DecayLength2() const
kinematics & topology
void SetMaxCentrality(Float_t maxCentrality=100.)
Definition: AliRDHFCuts.h:55
Int_t fUsePreselect
Definition: AliRDHFCuts.h:529
void SetVarsForOpt(Int_t nVars, Bool_t *forOpt)
void SetVarNames(Int_t nVars, TString *varNames, Bool_t *isUpperCut)
Bool_t * fVarsForOpt
number of cut vars to be optimized for candidates
Definition: AliRDHFCuts.h:472
Bool_t AreDaughtersSelected(AliAODRecoDecayHF *rd, const AliAODEvent *aod=0x0) const
void EnableCentralTrigger()
Definition: AliRDHFCuts.h:89
void SetUsePID(Bool_t flag=kTRUE)
Definition: AliRDHFCuts.h:221
virtual void PrintAll() const
virtual Int_t IsSelectedPID(AliAODRecoDecayHF *rd)
void CleanOwnPrimaryVtx(AliAODRecoDecayHF *d, AliAODEvent *aod, AliAODVertex *origownvtx) const
void SetRemoveDaughtersFromPrim(Bool_t removeDaughtersPrim)
Definition: AliRDHFCuts.h:231
void SetOldPid(Bool_t oldPid)
Definition: AliAODPidHF.h:121
void SetPtBins(Int_t nPtBinLimits, Float_t *ptBinLimits)
void SetITS(Bool_t its)
Definition: AliAODPidHF.h:109
void SetMatch(Int_t match)
Definition: AliAODPidHF.h:111
void AddTrackCuts(const AliESDtrackCuts *cuts)
Definition: AliRDHFCuts.h:219
void SetPLimit(Double_t *plim, Int_t npLim)
void SetTPC(Bool_t tpc)
Definition: AliAODPidHF.h:107
bool Bool_t
Definition: External.C:53
Double_t CosPointingAngle() const
Int_t fnPtBins
cuts on the candidate
Definition: AliRDHFCuts.h:466
void SetCompat(Bool_t comp)
Definition: AliAODPidHF.h:113
void SetTriggerClass(TString trclass0, TString trclass1="")
Definition: AliRDHFCuts.h:208
AliAODPidHF * fPidHF
enable AOD049 centrality cleanup
Definition: AliRDHFCuts.h:478
Bool_t RecalcOwnPrimaryVtx(AliAODRecoDecayHF *d, AliAODEvent *aod) const
void SetOptPileup(Int_t opt=0)
Definition: AliRDHFCuts.h:235
Int_t GetGlobalIndex(Int_t iVar, Int_t iPtBin) const
Double_t DecayLength() const
Float_t fMaxPtStrongPid
use strong pid 0 no,1 only for K,2 pi 3 both
Int_t nptbins
Double_t fMinPtCand
outcome of PID selection
Definition: AliRDHFCuts.h:499