2d191b80be0b8b88d83e914669a4d7d4278cd82b
[u/mrichter/AliRoot.git] / PWGHF / vertexingHF / AliRDHFCutsLctoV0.cxx
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
18 /////////////////////////////////////////////////////////////
19 //
20 // Class for cuts on AOD reconstructed Lc->V0+X
21 //
22 // Modified by A.De Caro - decaro@sa.infn.it
23 //
24 /////////////////////////////////////////////////////////////
25
26 #include <TDatabasePDG.h>
27 #include <Riostream.h>
28
29 #include "AliRDHFCutsLctoV0.h"
30 #include "AliAODRecoCascadeHF.h"
31 #include "AliAODTrack.h"
32 #include "AliESDtrack.h"
33 #include "AliAODv0.h"
34 #include "AliESDv0.h"
35
36 ClassImp(AliRDHFCutsLctoV0)
37
38 //--------------------------------------------------------------------------
39   AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const char* name, Short_t /*v0channel*/) : 
40   AliRDHFCuts(name),
41   fPidHFV0pos(new AliAODPidHF()),
42   fPidHFV0neg(new AliAODPidHF())
43 {
44   //
45   // Default Constructor
46   //
47
48   Int_t nvars=9;
49   SetNVars(nvars);
50   TString varNames[9]={"inv. mass if K0S [GeV/c2]",
51                        "inv. mass if Lambda [GeV/c2]",
52                        "inv. mass V0 if K0S [GeV/c2]",
53                        "inv. mass V0 if Lambda [GeV/c2]",
54                        "pT min bachelor track [GeV/c]",
55                        "pT min V0-positive track [GeV/c]",
56                        "pT min V0-negative track [GeV/c]",
57                        "dca cascade cut [cm]",
58                        "dca V0 cut [cm]"};
59
60   Bool_t isUpperCut[9]={kTRUE,
61                         kTRUE, 
62                         kTRUE, 
63                         kTRUE,
64                         kFALSE,
65                         kFALSE,
66                         kFALSE,
67                         kTRUE,
68                         kTRUE};
69   SetVarNames(nvars,varNames,isUpperCut);
70   Bool_t forOpt[9]={kFALSE,
71                     kFALSE,
72                     kTRUE,
73                     kTRUE,
74                     kTRUE,
75                     kTRUE,
76                     kTRUE,
77                     kTRUE,
78                     kTRUE};
79   SetVarsForOpt(9,forOpt); // It was 5: why only 5? And which ones?
80
81   Float_t limits[2]={0,999999999.};
82   SetPtBins(2,limits);
83
84   /*
85   switch (v0channel) {
86   case 0:
87     fV0channel = 0x0001;
88     break;
89   case 1:
90     fV0channel = 0x0002;
91     break;
92   case 2:
93     fV0channel = 0x0004;
94     break;
95   }
96   */
97
98 }
99 //--------------------------------------------------------------------------
100 AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const AliRDHFCutsLctoV0 &source) :
101   AliRDHFCuts(source),
102   fPidHFV0pos(new AliAODPidHF(*(source.fPidHFV0pos))),
103   fPidHFV0neg(new AliAODPidHF(*(source.fPidHFV0neg)))/*,
104                                                        fV0channel(source.fV0channel)*/
105 {
106   //
107   // Copy constructor
108   //
109
110 }
111 //--------------------------------------------------------------------------
112 AliRDHFCutsLctoV0 &AliRDHFCutsLctoV0::operator=(const AliRDHFCutsLctoV0 &source)
113 {
114   //
115   // assignment operator
116   //
117
118   if (this != &source) {
119
120     AliRDHFCuts::operator=(source);
121     delete fPidHFV0pos;
122     fPidHFV0pos = new AliAODPidHF(*(source.fPidHFV0pos));
123     delete fPidHFV0neg;
124     fPidHFV0neg = new AliAODPidHF(*(source.fPidHFV0neg));
125
126     //fV0channel = source.fV0channel;
127
128   }
129
130   return *this;
131 }
132
133
134 //---------------------------------------------------------------------------
135 AliRDHFCutsLctoV0::~AliRDHFCutsLctoV0() {
136  //
137  //  // Default Destructor
138  //   
139
140  if (fPidHFV0pos) {
141   delete fPidHFV0pos;
142   fPidHFV0pos=0;
143  }
144  if (fPidHFV0neg) {
145   delete fPidHFV0neg;
146   fPidHFV0neg=0;
147  }
148
149 }
150
151 //---------------------------------------------------------------------------
152 void AliRDHFCutsLctoV0::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) {
153   // 
154   // Fills in vars the values of the variables 
155   //
156
157   if (pdgdaughters[0]==-9999) return; // dummy
158
159   if (nvars!=fnVarsForOpt) {
160     printf("AliRDHFCutsLctoV0::GetCutsVarsForOpt: wrong number of variables\n");
161     return;
162   }
163
164   AliAODRecoCascadeHF *dd = (AliAODRecoCascadeHF*)d;
165
166   // Get the v0 and all daughter tracks
167   AliAODTrack *bachelorTrack = (AliAODTrack*)dd->GetBachelor();
168   AliAODv0 *v0 = (AliAODv0*)dd->Getv0();
169   AliAODTrack *v0positiveTrack = (AliAODTrack*)dd->Getv0PositiveTrack();
170   AliAODTrack *v0negativeTrack = (AliAODTrack*)dd->Getv0NegativeTrack(); 
171
172   Int_t iter=-1;
173   // cut on cascade mass, if K0S + p
174   if (fVarsForOpt[0]) {
175     iter++;
176     vars[iter]=dd->InvMassLctoK0sP();
177   }
178   // cut on cascade mass, if Lambda + pi
179   if (fVarsForOpt[1]) {
180     iter++;
181     vars[iter]=dd->InvMassLctoLambdaPi();
182   }
183
184   // cut on V0 mass if K0S
185   if (fVarsForOpt[2]) {
186     iter++;
187     vars[iter]=v0->MassK0Short();
188   }
189
190   // cut on V0 mass if Lambda
191   // ----------------------------- pb with anti-lambda?? --------->>>>>>>>
192   if (fVarsForOpt[3]) {
193
194     if (bachelorTrack->Charge()==1) {
195       iter++;
196       vars[iter]=v0->MassLambda();
197     } else if (bachelorTrack->Charge()==-1) {
198       iter++;
199       vars[iter]=v0->MassAntiLambda();
200     }
201
202   }
203
204   // cut bachelor min pt
205   if (fVarsForOpt[4]) {
206     iter++;
207     vars[iter]=bachelorTrack->Pt();
208   }
209
210   // cut on V0-positive min pt
211   if (fVarsForOpt[5]) {
212     iter++;
213     vars[iter]=v0positiveTrack->Pt();
214   }
215
216   // cut on V0-negative min pt
217   if (fVarsForOpt[6]) {
218     iter++;
219     vars[iter]=v0negativeTrack->Pt();
220   }
221
222   // cut on cascade dca
223   if (fVarsForOpt[7]) {
224     iter++;
225     vars[iter]=dd->GetDCA(); // prong-to-prong DCA
226   }
227  
228   // cut on V0 dca
229   if (fVarsForOpt[8]) {
230     iter++;
231     vars[iter]=v0->GetDCA(); // prong-to-prong DCA
232   }
233
234   return;
235 }
236 //---------------------------------------------------------------------------
237 Int_t AliRDHFCutsLctoV0::IsSelected(TObject* obj,Int_t selectionLevel) {
238   //
239   // Apply selection
240   //
241
242   if (!fCutsRD) {
243     cout<<"Cut matrice not inizialized. Exit..."<<endl;
244     return 0;
245   }
246
247   //PrintAll();
248
249   AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
250   if (!d) {
251     cout<<"AliAODRecoCascadeHF null"<<endl;
252     return 0;
253   }
254
255   // selection on daughter tracks 
256   if (selectionLevel==AliRDHFCuts::kAll || 
257       selectionLevel==AliRDHFCuts::kTracks) {
258     if (!AreDaughtersSelected(d)) return 0;
259   }
260
261   // Get the bachelor track
262   AliAODTrack *bachelorTrack = (AliAODTrack*)d->GetBachelor();
263   if (!(bachelorTrack->TestFilterMask(BIT(4)))) return 0;
264
265   // Get the V0 and all daughter tracks
266   AliAODv0 *v0 = (AliAODv0*)d->Getv0();
267   AliAODTrack *v0positiveTrack = (AliAODTrack*)d->Getv0PositiveTrack();
268   AliAODTrack *v0negativeTrack = (AliAODTrack*)d->Getv0NegativeTrack(); 
269
270   // If reading ESDv0, return false
271   if ( !d->Getv0() || !d->Getv0PositiveTrack() || !d->Getv0NegativeTrack() ) {
272     AliInfo(Form("Not adapted for ESDv0s, return false..."));
273     return 0;
274   }
275
276   Int_t returnvaluePID = 7;
277
278   // selection on candidate
279   if (selectionLevel==AliRDHFCuts::kAll || 
280       selectionLevel==AliRDHFCuts::kCandidate || 
281       selectionLevel==AliRDHFCuts::kPID)
282     returnvaluePID = IsSelectedPID(d);
283
284   //if (fUsePID && returnvaluePID==0) return 0;
285
286   Bool_t okLck0sp=kTRUE, okLcLpi=kTRUE, okLcLBarpi=kTRUE;
287   Bool_t okK0spipi=kTRUE, okLppi=kTRUE, okLBarpip=kTRUE;
288
289   // selection on candidate
290   if (selectionLevel==AliRDHFCuts::kAll || 
291       selectionLevel==AliRDHFCuts::kCandidate) {
292
293     Double_t pt = d->Pt();
294     
295     Int_t ptbin = PtBin(pt);
296     
297     Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
298     Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
299     Double_t mLPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
300
301     // K0S + p
302     Double_t mk0s = v0->MassK0Short();
303     Double_t mLck0sp = d->InvMassLctoK0sP();
304     // cut on Lc mass with K0S+p hypothesis
305     if (TMath::Abs(mLck0sp-mLcPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) {
306       okLck0sp = kFALSE;
307       AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to Lambda_c into K0S+p cut",mLck0sp));
308     }
309
310     // cuts on the V0 mass: K0S case
311     if (TMath::Abs(mk0s-mk0sPDG)>fCutsRD[GetGlobalIndex(2,ptbin)]) { 
312       okK0spipi = 0;
313       AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to K0S cut",mk0s));
314     }
315
316     // Lambda + pi 
317     Double_t mlambda = v0->MassLambda();
318     Double_t malambda = v0->MassAntiLambda();
319     Double_t mLcLpi = d->InvMassLctoLambdaPi();
320     // cut on Lc mass with Lambda+pi hypothesis
321     if (TMath::Abs(mLcLpi-mLcPDG)>fCutsRD[GetGlobalIndex(1,ptbin)]) {
322       okLcLpi = kFALSE;
323       okLcLBarpi = kFALSE;
324       AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to Lambda_c into Lambda+pi cut",mLcLpi));
325     }
326
327     // cuts on the V0 mass: Lambda/LambdaBar case
328     if ( TMath::Abs(mlambda-mLPDG)>fCutsRD[GetGlobalIndex(3,ptbin)] ) {
329       okLppi = kFALSE;
330       AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to LambdaBar cut",mlambda));
331     }
332
333     if ( TMath::Abs(malambda-mLPDG)>fCutsRD[GetGlobalIndex(3,ptbin)] ) {
334       okLBarpip = kFALSE;
335       AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to LambdaBar cut",malambda));
336     }
337
338     okLck0sp   = okLck0sp   && okK0spipi;
339     okLcLpi    = okLcLpi    && okLppi;
340     okLcLBarpi = okLcLBarpi && okLBarpip;
341
342     if (!okLck0sp && !okLcLpi && !okLcLBarpi) return 0;
343
344     // cuts on the minimum pt of the tracks 
345     if (TMath::Abs(bachelorTrack->Pt()) < fCutsRD[GetGlobalIndex(4,ptbin)]) {
346       AliDebug(4,Form(" bachelor track Pt=%2.2e > %2.2e",bachelorTrack->Pt(),fCutsRD[GetGlobalIndex(4,ptbin)]));
347       return 0;
348     }
349     if (TMath::Abs(v0positiveTrack->Pt()) < fCutsRD[GetGlobalIndex(5,ptbin)]) {
350       AliDebug(4,Form(" V0-positive track Pt=%2.2e > %2.2e",v0positiveTrack->Pt(),fCutsRD[GetGlobalIndex(5,ptbin)]));
351       return 0;
352     }
353     if (TMath::Abs(v0negativeTrack->Pt()) < fCutsRD[GetGlobalIndex(6,ptbin)]) {
354       AliDebug(4,Form(" V0-negative track Pt=%2.2e > %2.2e",v0negativeTrack->Pt(),fCutsRD[GetGlobalIndex(6,ptbin)]));
355       return 0;
356     }
357
358     // cut on cascade dca
359     //if (TMath::Abs(d->GetDCA()) > fCutsRD[GetGlobalIndex(7,ptbin)]) {
360     if ( TMath::Abs(d->GetDCA()) > fCutsRD[GetGlobalIndex(7,ptbin)] /*|| // prong-to-prong DCA
361          TMath::Abs(d->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(7,ptbin)] || // rphi impact params w.r.t. Primary Vtx
362          TMath::Abs(d->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(7,ptbin)]*/ ) { // rphi impact params w.r.t. Primary Vtx
363       AliDebug(4,Form(" cascade tracks DCA don't pass the cut"));
364       return 0;
365     }
366
367     // cut on V0 dca
368     //if (TMath::Abs(v0->DcaV0Daughters()) > fCutsRD[GetGlobalIndex(8,ptbin)]) { // prong-to-prong DCA
369     if ( TMath::Abs(v0->GetDCA()) > fCutsRD[GetGlobalIndex(8,ptbin)] /*|| // prong-to-prong DCA
370          TMath::Abs(v0->DcaV0ToPrimVertex()) > fCutsRD[GetGlobalIndex(8,ptbin)] || // V0-to-vertex DCA
371          TMath::Abs(v0->DcaPosToPrimVertex()) > fCutsRD[GetGlobalIndex(8,ptbin)] || // prong-to-vertex DCA
372          TMath::Abs(v0->DcaNegToPrimVertex()) > fCutsRD[GetGlobalIndex(8,ptbin)]*/ ) { // prong-to-vertex DCA
373       AliDebug(4,Form(" V0 DCA don't pass the cut"));
374       return 0;
375     }
376
377   }
378
379   Int_t returnvalue = okLck0sp+2*okLcLBarpi+4*okLcLpi;
380   /*
381     retvalue case
382           1  Lc->K0S + p
383           2  Lc->LambdaBar + pi
384           3  Lc->K0S + p AND Lc->LambdaBar + pi
385           4  Lc->Lambda + pi
386           5  Lc->K0S + p AND Lc->Lambda + pi
387           6  Lc->LambdaBar + pi AND Lc->Lambda + pi
388           7  Lc->K0S + p AND Lc->LambdaBar + pi AND Lc->Lambda + pi
389   */
390
391   Int_t returnvalueTot = 0;
392   if (fUsePID )
393     returnvalueTot = CombinePIDCuts(returnvalue,returnvaluePID);
394   else
395     returnvalueTot = returnvalue;
396
397   return returnvalueTot;
398
399 }
400 //---------------------------------------------------------------------------
401 Int_t AliRDHFCutsLctoV0::IsSelectedPID(AliAODRecoDecayHF* obj) {
402
403   // fPidHF -> PID object for bachelor
404   // fPidHFV0pos -> PID object for positive V0 daughter
405   // fPidHFV0neg -> PID object for negative V0 daughter
406
407   if (!fUsePID || !obj) return 7; // all hypothesis are valid
408
409   AliAODRecoCascadeHF *objD = (AliAODRecoCascadeHF*)obj;
410
411   Bool_t isPeriodd = fPidHF->GetOnePad();
412   Bool_t isMC = fPidHF->GetMC();
413
414   if (isPeriodd) {
415     fPidHFV0pos->SetOnePad(kTRUE);
416     fPidHFV0neg->SetOnePad(kTRUE);
417   }
418   if (isMC) {
419     fPidHFV0neg->SetMC(kTRUE);
420     fPidHFV0pos->SetMC(kTRUE);
421   }
422
423   AliAODTrack *bachelor = (AliAODTrack*)objD->GetBachelor();
424   AliAODTrack *v0Pos = (AliAODTrack*)objD->Getv0PositiveTrack();
425   AliAODTrack *v0Neg = (AliAODTrack*)objD->Getv0NegativeTrack();
426
427   if (!bachelor || !v0Pos || !v0Neg) return 0;
428
429   // identify bachelor
430   Bool_t isBachelorID1 = fPidHF->IsProtonRaw(bachelor,"TPC") && fPidHF->IsProtonRaw(bachelor,"TOF"); // K0S case
431   //Bool_t isBachelorID2 = fPidHF->IsPionRaw(bachelor,"TPC") && fPidHF->IsPionRaw(bachelor,"TOF"); // LambdaBar case
432   //Bool_t isBachelorID4 = isBachelorID2; // Lambda case
433
434   // identify V0pos
435   //Bool_t isV0PosID1 = fPidHFV0pos->IsPionRaw(v0Pos,"TPC") && fPidHFV0pos->IsPionRaw(v0Pos,"TOF"); // K0S case
436   //Bool_t isV0PosID2 = isV0PosID1; // LambdaBar case
437   Bool_t isV0PosID4 = fPidHFV0pos->IsProtonRaw(v0Pos,"TPC") && fPidHFV0pos->IsProtonRaw(v0Pos,"TOF"); // Lambda case
438
439   // identify V0neg
440   //Bool_t isV0NegID1 = fPidHFV0neg->IsPionRaw(v0Neg,"TPC") && fPidHFV0neg->IsPionRaw(v0Neg,"TOF"); // K0S case
441   Bool_t isV0NegID2 = fPidHFV0neg->IsProtonRaw(v0Neg,"TPC") && fPidHFV0neg->IsProtonRaw(v0Neg,"TOF"); // LambdaBar case
442   //Bool_t isV0NegID4 = isV0NegID1; // Lambda case
443
444   Bool_t okLcK0Sp = isBachelorID1; // K0S case
445   Bool_t okLcLambdaBarPi = isV0NegID2; // LambdaBar case
446   Bool_t okLcLambdaPi = isV0PosID4; // Lambda case
447
448   Int_t returnvalue = okLcK0Sp+2*okLcLambdaBarPi+4*okLcLambdaPi;
449
450   return returnvalue;
451 }
452 //-----------------------
453
454 Int_t AliRDHFCutsLctoV0::CombinePIDCuts(Int_t returnvalue, Int_t returnvaluePID) const {
455   // combine PID with topological cuts
456
457  Int_t returnvalueTot=returnvalue&returnvaluePID;
458
459  return returnvalueTot;
460 }
461
462 //----------------------------------
463 Int_t AliRDHFCutsLctoV0::IsSelected(TObject* obj, Int_t selectionLevel, Int_t cutIndex) {
464   //
465   // Apply selection
466   //
467
468   if (!fCutsRD) {
469     cout<<"Cut matrice not inizialized. Exit..."<<endl;
470     return 0;
471   }
472
473   AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
474   if (!d) {
475     cout<<"AliAODRecoCascadeHF null"<<endl;
476     return 0;
477   }
478
479   // selection on daughter tracks 
480   if (selectionLevel==AliRDHFCuts::kAll || 
481       selectionLevel==AliRDHFCuts::kTracks || 
482       selectionLevel==AliRDHFCuts::kCandidate) {
483     if (!AreDaughtersSelected(d)) return 0;
484   }
485
486   // Get the v0 and all daughter tracks
487   AliAODTrack *bachelorTrack = (AliAODTrack*)d->GetBachelor();
488   if (!(bachelorTrack->TestFilterMask(BIT(4)))) return 0;
489
490   AliAODv0 *v0 = (AliAODv0*)d->Getv0();
491   AliAODTrack *v0positiveTrack = (AliAODTrack*)d->Getv0PositiveTrack();
492   AliAODTrack *v0negativeTrack = (AliAODTrack*)d->Getv0NegativeTrack(); 
493   if ( !d->Getv0() || !d->Getv0PositiveTrack() || !d->Getv0NegativeTrack() ) {
494     AliInfo(Form("Not adapted for ESDv0s, return false..."));
495     return 0;
496   }
497
498
499   Bool_t okLck0sp=kFALSE, okLcLpi=kFALSE, okLcLBarpi=kFALSE;
500
501   // selection on candidate
502   if (selectionLevel==AliRDHFCuts::kAll || 
503       selectionLevel==AliRDHFCuts::kCandidate) {
504
505     Double_t mLcPDG =  TDatabasePDG::Instance()->GetParticle(4122)->Mass();
506     Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
507     Double_t mLPDG =   TDatabasePDG::Instance()->GetParticle(3122)->Mass();
508
509     // k0s + p
510     Double_t mk0s    = v0->MassK0Short();
511     Double_t mLck0sp = d->InvMassLctoK0sP();
512
513     // lambda + pi 
514     Double_t mlambda  = v0->MassLambda();
515     Double_t malambda = v0->MassAntiLambda();
516     Double_t mLcLpi   = d->InvMassLctoLambdaPi();
517
518     Double_t pt = d->Pt();
519     Int_t ptbin = PtBin(pt);
520
521     switch (cutIndex) {
522     case 0:
523       okLck0sp   = TMath::Abs(mLck0sp-mLcPDG)<=fCutsRD[GetGlobalIndex(0,ptbin)];
524       okLcLpi    = kFALSE;
525       okLcLBarpi = kFALSE;
526       break;
527     case 1:
528       okLck0sp   = kFALSE;
529       okLcLpi    = TMath::Abs(mLcLpi-mLcPDG)<=fCutsRD[GetGlobalIndex(1,ptbin)];
530       okLcLBarpi = okLcLpi;
531       break;
532     case 2:
533       okLck0sp   = TMath::Abs(mk0s-mk0sPDG)<=fCutsRD[GetGlobalIndex(2,ptbin)];
534       okLcLpi    = kFALSE;
535       okLcLBarpi = kFALSE;
536       break;
537     case 3:
538       okLck0sp   = kFALSE;
539       okLcLpi    = TMath::Abs(mlambda-mLPDG)<=fCutsRD[GetGlobalIndex(3,ptbin)];
540       okLcLBarpi = TMath::Abs(malambda-mLPDG)<=fCutsRD[GetGlobalIndex(3,ptbin)];
541       break;
542     case 4:
543       okLck0sp   = TMath::Abs(bachelorTrack->Pt())>=fCutsRD[GetGlobalIndex(4,ptbin)];
544       okLcLpi    = okLck0sp;
545       okLcLBarpi = okLck0sp;
546       break;
547     case 5:
548       okLck0sp   = TMath::Abs(v0positiveTrack->Pt())>=fCutsRD[GetGlobalIndex(5,ptbin)];
549       okLcLpi    = okLck0sp;
550       okLcLBarpi = okLck0sp;
551       break;
552     case 6:
553       okLck0sp   = TMath::Abs(v0negativeTrack->Pt())>=fCutsRD[GetGlobalIndex(6,ptbin)];
554       okLcLpi    = okLck0sp;
555       okLcLBarpi = okLck0sp;
556       break;
557     case 7:
558       //okLck0sp = TMath::Abs(d->GetDCA(0))<=fCutsRD[GetGlobalIndex(8,ptbin)];
559       okLck0sp   = TMath::Abs(d->GetDCA())<=fCutsRD[GetGlobalIndex(7,ptbin)] /*&&
560         TMath::Abs(d->Getd0Prong(0))<=fCutsRD[GetGlobalIndex(7,ptbin)] &&
561         TMath::Abs(d->Getd0Prong(1))<=fCutsRD[GetGlobalIndex(7,ptbin)]*/;
562       okLcLpi    = okLck0sp;
563       okLcLBarpi = okLck0sp;
564       break;
565     case 8:
566       //okLck0sp   = TMath::Abs(v0->DcaV0Daughters())<=fCutsRD[GetGlobalIndex(7,ptbin)];
567       okLck0sp   = TMath::Abs(v0->GetDCA())<=fCutsRD[GetGlobalIndex(8,ptbin)] /*&&
568         TMath::Abs(v0->DcaV0ToPrimVertex())<=fCutsRD[GetGlobalIndex(8,ptbin)] &&
569         TMath::Abs(v0->DcaPosToPrimVertex())<=fCutsRD[GetGlobalIndex(8,ptbin)] &&
570         TMath::Abs(v0->DcaNegToPrimVertex())<=fCutsRD[GetGlobalIndex(8,ptbin)]*/;
571       okLcLpi    = okLck0sp;
572       okLcLBarpi = okLck0sp;
573       break;
574     }
575
576   }
577
578   Int_t returnvalue = okLck0sp+2*okLcLBarpi+4*okLcLpi;
579   /*
580     retvalue case
581           1  Lc->K0S + p
582           2  Lc->LambdaBar + pi
583           3  Lc->K0S + p AND Lc->LambdaBar + pi
584           4  Lc->Lambda + pi
585           5  Lc->K0S + p AND Lc->Lambda + pi
586           6  Lc->LambdaBar + pi AND Lc->Lambda + pi
587           7  Lc->K0S + p AND Lc->LambdaBar + pi AND Lc->Lambda + pi
588   */
589
590
591   Int_t returnvaluePID = 7;
592
593   // selection on PID
594   if (selectionLevel==AliRDHFCuts::kAll || 
595       selectionLevel==AliRDHFCuts::kPID)
596     returnvaluePID = IsSelectedPID(d);
597
598   //if (fUsePID && returnvaluePID==0) return 0;
599
600   Int_t returnvalueTot = /*0;
601   if (fUsePID)
602   returnvalueTot =*/ CombinePIDCuts(returnvalue,returnvaluePID);
603   /*else
604     returnvalueTot = returnvalue;*/
605
606   return returnvalueTot;
607
608 }