]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGHF/vertexingHF/AliRDHFCutsLctoV0.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'feature-movesplit'
[u/mrichter/AliRoot.git] / PWGHF / vertexingHF / AliRDHFCutsLctoV0.cxx
CommitLineData
a07ad8e0 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
27de2dfb 16/* $Id$ */
17
a07ad8e0 18/////////////////////////////////////////////////////////////
19//
992ba7d8 20// Class for cuts on AOD reconstructed Lc->V0+X
21//
22// Modified by A.De Caro - decaro@sa.infn.it
a07ad8e0 23//
24/////////////////////////////////////////////////////////////
25
a07ad8e0 26#include <Riostream.h>
27
a578b2da 28#include <TDatabasePDG.h>
29#include <TMath.h>
30
31#include "AliAnalysisManager.h"
32#include "AliInputEventHandler.h"
33#include "AliPIDResponse.h"
a07ad8e0 34#include "AliRDHFCutsLctoV0.h"
35#include "AliAODRecoCascadeHF.h"
36#include "AliAODTrack.h"
37#include "AliESDtrack.h"
e7af8919 38#include "AliESDVertex.h"
39#include "AliAODVertex.h"
a07ad8e0 40#include "AliAODv0.h"
41#include "AliESDv0.h"
42
c64cb1f6 43using std::cout;
44using std::endl;
45
a07ad8e0 46ClassImp(AliRDHFCutsLctoV0)
47
48//--------------------------------------------------------------------------
53c91ed7 49AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const char* name, Short_t /*v0channel*/) :
50AliRDHFCuts(name),
e7af8919 51 fPidSelectionFlag(0),
34595b3c 52 fV0daughtersCuts(0),
53c91ed7 53 fV0Type(0),
54 fHighPtCut(2.5),
b833016c 55 fLowPtCut(1.0),
56 fExcludedCut(-1)
a07ad8e0 57{
58 //
59 // Default Constructor
60 //
992ba7d8 61
a578b2da 62 const Int_t nvars=17;
a07ad8e0 63 SetNVars(nvars);
a578b2da 64 TString varNames[nvars]={"Lc inv. mass if K0S [GeV/c2]", // 0
65 "Lc inv. mass if Lambda [GeV/c2]", // 1
66 "K0S inv. mass [GeV/c2]", // 2
67 "Lambda/LambdaBar inv. mass[GeV/c2]", // 3
68 "pT min bachelor track [GeV/c]", // 4
69 "pT min V0-positive track [GeV/c]", // 5
70 "pT min V0-negative track [GeV/c]", // 6
71 "dca cascade (prong-to-prong) cut [cm]", // 7
72 "dca V0 (prong-to-prong) cut [number of sigmas]", // 8
73 "V0 cosPA min wrt PV", // 9
74 "d0 max bachelor wrt PV [cm]", // 10
75 "d0 max V0 wrt PV [cm]", // 11
76 "mass K0S veto [GeV/c2]", // 12
77 "mass Lambda/LambdaBar veto [GeV/c2]", // 13
78 "mass Gamma veto [GeV/c2]", // 14
79 "pT min V0 track [GeV/c]", // 15
80 "V0 type" // 16
81 };
82
83 Bool_t isUpperCut[nvars]={kTRUE, // 0
84 kTRUE, // 1
85 kTRUE, // 2
86 kTRUE, // 3
87 kFALSE, // 4
88 kFALSE, // 5
89 kFALSE, // 6
90 kTRUE, // 7
91 kTRUE, // 8
92 kFALSE, // 9
93 kTRUE, // 10
94 kTRUE, // 11
95 kFALSE, // 12
96 kFALSE, // 13
97 kFALSE, // 14
98 kFALSE, // 15
99 kFALSE // 16
100 };
a07ad8e0 101 SetVarNames(nvars,varNames,isUpperCut);
a578b2da 102 Bool_t forOpt[nvars]={kFALSE, // 0
103 kFALSE, // 1
104 kTRUE, // 2
105 kTRUE, // 3
106 kTRUE, // 4
107 kTRUE, // 5
108 kTRUE, // 6
109 kTRUE, // 7
110 kTRUE, // 8
111 kTRUE, // 9
112 kTRUE, // 10
113 kTRUE, // 11
114 kTRUE, // 12
115 kTRUE, // 13
116 kTRUE, // 14
117 kTRUE, // 15
118 kFALSE // 16
119 };
120 SetVarsForOpt(nvars,forOpt);
992ba7d8 121
a07ad8e0 122 Float_t limits[2]={0,999999999.};
123 SetPtBins(2,limits);
992ba7d8 124
125 /*
53c91ed7 126 switch (v0channel) {
127 case 0:
992ba7d8 128 fV0channel = 0x0001;
129 break;
53c91ed7 130 case 1:
992ba7d8 131 fV0channel = 0x0002;
132 break;
53c91ed7 133 case 2:
992ba7d8 134 fV0channel = 0x0004;
135 break;
53c91ed7 136 }
992ba7d8 137 */
138
a07ad8e0 139}
140//--------------------------------------------------------------------------
141AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const AliRDHFCutsLctoV0 &source) :
992ba7d8 142 AliRDHFCuts(source),
a578b2da 143 fPidSelectionFlag(source.fPidSelectionFlag),
34595b3c 144 fV0daughtersCuts(0),
53c91ed7 145 fV0Type(source.fV0Type),
146 fHighPtCut(source.fHighPtCut),
b833016c 147 fLowPtCut(source.fLowPtCut),
148 fExcludedCut(source.fExcludedCut)
53c91ed7 149 /*fV0channel(source.fV0channel)*/
a07ad8e0 150{
151 //
152 // Copy constructor
153 //
154
60b29186 155 if (source.fV0daughtersCuts) AddTrackCutsV0daughters(source.fV0daughtersCuts);
e7af8919 156 else fV0daughtersCuts = new AliESDtrackCuts();
157
a07ad8e0 158}
159//--------------------------------------------------------------------------
160AliRDHFCutsLctoV0 &AliRDHFCutsLctoV0::operator=(const AliRDHFCutsLctoV0 &source)
161{
162 //
163 // assignment operator
164 //
a07ad8e0 165
992ba7d8 166 if (this != &source) {
167
168 AliRDHFCuts::operator=(source);
e7af8919 169 fPidSelectionFlag = source.fPidSelectionFlag;
992ba7d8 170
e7af8919 171 delete fV0daughtersCuts;
172 fV0daughtersCuts = new AliESDtrackCuts(*(source.fV0daughtersCuts));
173
34595b3c 174 fV0Type = source.fV0Type;
992ba7d8 175
53c91ed7 176 fHighPtCut = source.fHighPtCut;
177 fLowPtCut = source.fLowPtCut;
178
992ba7d8 179 }
a07ad8e0 180
181 return *this;
182}
183
184
992ba7d8 185//---------------------------------------------------------------------------
186AliRDHFCutsLctoV0::~AliRDHFCutsLctoV0() {
53c91ed7 187 //
188 // Default Destructor
189 //
190
191 if (fV0daughtersCuts) {
192 delete fV0daughtersCuts;
193 fV0daughtersCuts=0;
194 }
e7af8919 195
992ba7d8 196}
197
a07ad8e0 198//---------------------------------------------------------------------------
199void AliRDHFCutsLctoV0::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) {
34595b3c 200 //
201 // Fills in vars the values of the variables
a07ad8e0 202 //
e654189e 203
992ba7d8 204 if (pdgdaughters[0]==-9999) return; // dummy
a07ad8e0 205
992ba7d8 206 if (nvars!=fnVarsForOpt) {
a578b2da 207 printf("AliRDHFCutsLctoV0::GetCutVarsForOpt: wrong number of variables\n");
a07ad8e0 208 return;
209 }
210
a578b2da 211 Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
212 Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
213 Double_t mLPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
214
a07ad8e0 215 AliAODRecoCascadeHF *dd = (AliAODRecoCascadeHF*)d;
216
217 // Get the v0 and all daughter tracks
992ba7d8 218 AliAODTrack *bachelorTrack = (AliAODTrack*)dd->GetBachelor();
219 AliAODv0 *v0 = (AliAODv0*)dd->Getv0();
220 AliAODTrack *v0positiveTrack = (AliAODTrack*)dd->Getv0PositiveTrack();
34595b3c 221 AliAODTrack *v0negativeTrack = (AliAODTrack*)dd->Getv0NegativeTrack();
a07ad8e0 222
223 Int_t iter=-1;
992ba7d8 224 // cut on cascade mass, if K0S + p
225 if (fVarsForOpt[0]) {
a07ad8e0 226 iter++;
a578b2da 227 vars[iter]=TMath::Abs(dd->InvMassLctoK0sP()-mLcPDG);
a07ad8e0 228 }
a578b2da 229 // cut on cascade mass, if Lambda/LambdaBar + pi
992ba7d8 230 if (fVarsForOpt[1]) {
a07ad8e0 231 iter++;
a578b2da 232 vars[iter]=TMath::Abs(dd->InvMassLctoLambdaPi()-mLcPDG);
a07ad8e0 233 }
234
992ba7d8 235 // cut on V0 mass if K0S
236 if (fVarsForOpt[2]) {
a07ad8e0 237 iter++;
a578b2da 238 vars[iter]=TMath::Abs(v0->MassK0Short()-mk0sPDG);
a07ad8e0 239 }
240
a578b2da 241 // cut on V0 mass if Lambda/LambdaBar
992ba7d8 242 if (fVarsForOpt[3]) {
243
244 if (bachelorTrack->Charge()==1) {
245 iter++;
a578b2da 246 vars[iter]=TMath::Abs(v0->MassLambda()-mLPDG);
992ba7d8 247 } else if (bachelorTrack->Charge()==-1) {
248 iter++;
a578b2da 249 vars[iter]=TMath::Abs(v0->MassAntiLambda()-mLPDG);
992ba7d8 250 }
a07ad8e0 251
a07ad8e0 252 }
253
992ba7d8 254 // cut bachelor min pt
255 if (fVarsForOpt[4]) {
a07ad8e0 256 iter++;
992ba7d8 257 vars[iter]=bachelorTrack->Pt();
a07ad8e0 258 }
259
992ba7d8 260 // cut on V0-positive min pt
261 if (fVarsForOpt[5]) {
a07ad8e0 262 iter++;
992ba7d8 263 vars[iter]=v0positiveTrack->Pt();
a07ad8e0 264 }
265
992ba7d8 266 // cut on V0-negative min pt
267 if (fVarsForOpt[6]) {
a07ad8e0 268 iter++;
992ba7d8 269 vars[iter]=v0negativeTrack->Pt();
a07ad8e0 270 }
271
a578b2da 272 // cut on cascade dca (prong-to-prong)
992ba7d8 273 if (fVarsForOpt[7]) {
274 iter++;
a578b2da 275 vars[iter]=dd->GetDCA(); // prong-to-prong cascade DCA
992ba7d8 276 }
34595b3c 277
a578b2da 278 // cut on V0 dca (prong-to-prong)
992ba7d8 279 if (fVarsForOpt[8]) {
a07ad8e0 280 iter++;
a578b2da 281 vars[iter]=v0->GetDCA(); // prong-to-prong V0 DCA
282 }
283
284 // cut on V0 cosPA wrt PV
285 if (fVarsForOpt[9]) {
286 iter++;
287 vars[iter]=dd->CosV0PointingAngle(); // cosine of V0 pointing angle wrt primary vertex
288 }
289
290 // cut on bachelor transverse impact parameter wrt PV
291 if (fVarsForOpt[10]) {
292 iter++;
293 vars[iter]=dd->Getd0Prong(0); // bachelor transverse impact parameter wrt primary vertex
294 }
295
296 // cut on V0 transverse impact parameter wrt PV
297 if (fVarsForOpt[11]) {
298 iter++;
299 vars[iter]=dd->Getd0Prong(1); // V0 transverse impact parameter wrt primary vertex
300 }
301
302 // cut on K0S invariant mass veto
303 if (fVarsForOpt[12]) {
304 iter++;
305 vars[iter]=TMath::Abs(v0->MassK0Short()-mk0sPDG); // K0S invariant mass veto
306 }
307
308 // cut on Lambda/LambdaBar invariant mass veto
309 if (fVarsForOpt[13]) {
310
311 if (bachelorTrack->Charge()==1) {
312 iter++;
313 vars[iter]=TMath::Abs(v0->MassLambda()-mLPDG);
314 } else if (bachelorTrack->Charge()==-1) {
315 iter++;
316 vars[iter]=TMath::Abs(v0->MassAntiLambda()-mLPDG);
317 }
318
319 }
320
321 // cut on gamma invariant mass veto
322 if (fVarsForOpt[14]) {
323 iter++;
324 vars[iter]= v0->InvMass2Prongs(0,1,11,11); // gamma invariant mass veto
325 }
326
327
328 // cut on V0 pT min
329 if (fVarsForOpt[15]) {
330 iter++;
331 vars[iter]= v0->Pt(); // V0 pT min
a07ad8e0 332 }
333
a578b2da 334
a07ad8e0 335 return;
336}
337//---------------------------------------------------------------------------
338Int_t AliRDHFCutsLctoV0::IsSelected(TObject* obj,Int_t selectionLevel) {
339 //
340 // Apply selection
341 //
342
992ba7d8 343 if (!fCutsRD) {
60b29186 344 AliFatal("Cut matrice not inizialized. Exit...");
a07ad8e0 345 return 0;
346 }
992ba7d8 347
992ba7d8 348 AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
349 if (!d) {
e7af8919 350 AliDebug(2,"AliAODRecoCascadeHF null");
a07ad8e0 351 return 0;
352 }
353
ff12b981 354 if (!d->GetSecondaryVtx()) {
355 AliDebug(2,"No secondary vertex for cascade");
e7af8919 356 return 0;
357 }
0dbd1d4f 358
ff12b981 359 if (d->GetNDaughters()!=2) {
360 AliDebug(2,Form("No 2 daughters for current cascade (nDaughters=%d)",d->GetNDaughters()));
361 return 0;
362 }
363
ff12b981 364 AliAODv0 * v0 = dynamic_cast<AliAODv0*>(d->Getv0());
b833016c 365
366 if ( v0 && ((v0->GetOnFlyStatus() == kTRUE && GetV0Type() == AliRDHFCuts::kOnlyOfflineV0s) ||
367 (v0->GetOnFlyStatus() == kFALSE && GetV0Type() == AliRDHFCuts::kOnlyOnTheFlyV0s)) ) return 0;
368
ff12b981 369 AliAODTrack * bachelorTrack = dynamic_cast<AliAODTrack*>(d->GetBachelor());
370 if (!v0 || !bachelorTrack) {
371 AliDebug(2,"No V0 or no bachelor for current cascade");
372 return 0;
373 }
374
375 if (bachelorTrack->GetID()<0) {
376 AliDebug(2,Form("Bachelor has negative ID %d",bachelorTrack->GetID()));
377 return 0;
378 }
379
380 if (!v0->GetSecondaryVtx()) {
381 AliDebug(2,"No secondary vertex for V0 by cascade");
382 return 0;
383 }
a07ad8e0 384
ff12b981 385 if (v0->GetNDaughters()!=2) {
386 AliDebug(2,Form("No 2 daughters for V0 of current cascade (onTheFly=%d, nDaughters=%d)",v0->GetOnFlyStatus(),v0->GetNDaughters()));
e7af8919 387 return 0;
388 }
389
ff12b981 390
e7af8919 391 // Get the V0 daughter tracks
ff12b981 392 AliAODTrack *v0positiveTrack = dynamic_cast<AliAODTrack*>(d->Getv0PositiveTrack());
393 AliAODTrack *v0negativeTrack = dynamic_cast<AliAODTrack*>(d->Getv0NegativeTrack());
e7af8919 394 if (!v0positiveTrack || !v0negativeTrack ) {
395 AliDebug(2,"No V0 daughters' objects");
992ba7d8 396 return 0;
397 }
a07ad8e0 398
ff12b981 399 if (v0positiveTrack->GetID()<0 || v0negativeTrack->GetID()<0) {
400 AliDebug(2,Form("At least one of V0 daughters has negative ID %d %d",v0positiveTrack->GetID(),v0negativeTrack->GetID()));
401 return 0;
402 }
403
ff12b981 404 //if(fUseTrackSelectionWithFilterBits && d->HasBadDaughters()) return 0;
60b29186 405 if ( fUseTrackSelectionWithFilterBits && !(bachelorTrack->TestFilterMask(BIT(4))) ) {
406 AliDebug(2,"Check on the bachelor FilterBit: no BIT(4). Candidate rejected.");
407 return 0;
408 }
409
410 Int_t returnvalueTrack = 7;
ff12b981 411
34595b3c 412 // selection on daughter tracks
413 if (selectionLevel==AliRDHFCuts::kAll ||
e7af8919 414 selectionLevel==AliRDHFCuts::kTracks) {
415
60b29186 416 if (!AreLctoV0DaughtersSelected(d)) return 0;
ff12b981 417
e7af8919 418 }
419
992ba7d8 420 Bool_t okLck0sp=kTRUE, okLcLpi=kTRUE, okLcLBarpi=kTRUE;
a07ad8e0 421
422 // selection on candidate
34595b3c 423 if (selectionLevel==AliRDHFCuts::kAll ||
992ba7d8 424 selectionLevel==AliRDHFCuts::kCandidate) {
a07ad8e0 425
992ba7d8 426 Double_t pt = d->Pt();
992ba7d8 427 Int_t ptbin = PtBin(pt);
34595b3c 428
0dbd1d4f 429 Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
a07ad8e0 430 Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
0dbd1d4f 431 Double_t mLPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
a07ad8e0 432
992ba7d8 433 // K0S + p
0dbd1d4f 434 Double_t mk0s = v0->MassK0Short();
992ba7d8 435 Double_t mLck0sp = d->InvMassLctoK0sP();
0dbd1d4f 436
34595b3c 437 // Lambda + pi
0dbd1d4f 438 Double_t mlambda = v0->MassLambda();
439 Double_t malambda = v0->MassAntiLambda();
440 Double_t mLcLpi = d->InvMassLctoLambdaPi();
441
60b29186 442 Bool_t okK0spipi=kTRUE, okLppi=kTRUE, okLBarpip=kTRUE;
443 Bool_t isNotK0S = kTRUE, isNotLambda = kTRUE, isNotLambdaBar = kTRUE, isNotGamma = kTRUE;
444
992ba7d8 445 // cut on Lc mass with K0S+p hypothesis
b833016c 446 if (TMath::Abs(mLck0sp-mLcPDG) > fCutsRD[GetGlobalIndex(0,ptbin)] && fExcludedCut!=0) {
992ba7d8 447 okLck0sp = kFALSE;
448 AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to Lambda_c into K0S+p cut",mLck0sp));
449 }
a07ad8e0 450
992ba7d8 451 // cuts on the V0 mass: K0S case
b833016c 452 if (TMath::Abs(mk0s-mk0sPDG) > fCutsRD[GetGlobalIndex(2,ptbin)] && fExcludedCut!=2) {
0dbd1d4f 453 okK0spipi = kFALSE;
992ba7d8 454 AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to K0S cut",mk0s));
a07ad8e0 455 }
992ba7d8 456
992ba7d8 457 // cut on Lc mass with Lambda+pi hypothesis
b833016c 458 if (TMath::Abs(mLcLpi-mLcPDG) > fCutsRD[GetGlobalIndex(1,ptbin)] && fExcludedCut!=1) {
992ba7d8 459 okLcLpi = kFALSE;
460 okLcLBarpi = kFALSE;
461 AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to Lambda_c into Lambda+pi cut",mLcLpi));
a07ad8e0 462 }
463
992ba7d8 464 // cuts on the V0 mass: Lambda/LambdaBar case
a578b2da 465 //if ( !(bachelorTrack->Charge()==+1 && TMath::Abs(mlambda-mLPDG) <= fCutsRD[GetGlobalIndex(3,ptbin)] ) ) {
b833016c 466 if ( TMath::Abs(mlambda-mLPDG) > fCutsRD[GetGlobalIndex(3,ptbin)] && fExcludedCut!=3) {
992ba7d8 467 okLppi = kFALSE;
468 AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to LambdaBar cut",mlambda));
a07ad8e0 469 }
992ba7d8 470
a578b2da 471 //if ( !(bachelorTrack->Charge()==-1 && TMath::Abs(malambda-mLPDG) <= fCutsRD[GetGlobalIndex(3,ptbin)] ) ) {
b833016c 472 if ( TMath::Abs(malambda-mLPDG) > fCutsRD[GetGlobalIndex(3,ptbin)] && fExcludedCut!=3) {
992ba7d8 473 okLBarpip = kFALSE;
474 AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to LambdaBar cut",malambda));
a07ad8e0 475 }
476
60b29186 477 // cut on K0S invariant mass veto
b833016c 478 if (TMath::Abs(v0->MassK0Short()-mk0sPDG) < fCutsRD[GetGlobalIndex(12,ptbin)] && fExcludedCut!=12) { // K0S invariant mass veto
60b29186 479 AliDebug(4,Form(" veto on K0S invariant mass doesn't pass the cut"));
480 //return 0;
481 isNotK0S=kFALSE;
482 }
483
484 // cut on Lambda/LambdaBar invariant mass veto
b833016c 485 if (TMath::Abs(v0->MassLambda()-mLPDG) < fCutsRD[GetGlobalIndex(13,ptbin)] && fExcludedCut!=13) { // Lambda invariant mass veto
60b29186 486 AliDebug(4,Form(" veto on Lambda invariant mass doesn't pass the cut"));
487 isNotLambda=kFALSE;
488 //return 0;
489 }
b833016c 490 if (TMath::Abs(v0->MassAntiLambda()-mLPDG) < fCutsRD[GetGlobalIndex(13,ptbin)] && fExcludedCut!=13) { // LambdaBar invariant mass veto
60b29186 491 AliDebug(4,Form(" veto on LambdaBar invariant mass doesn't pass the cut"));
492 isNotLambdaBar=kFALSE;
493 //return 0;
494 }
495
496 // cut on gamma invariant mass veto
b833016c 497 if (v0->InvMass2Prongs(0,1,11,11) < fCutsRD[GetGlobalIndex(14,ptbin)] && fExcludedCut!=14) { // K0S invariant mass veto
60b29186 498 AliDebug(4,Form(" veto on gamma invariant mass doesn't pass the cut"));
499 isNotGamma=kFALSE;
500 //return 0;
501 }
502
503 okLck0sp = okLck0sp && okK0spipi && isNotLambda && isNotLambdaBar && isNotGamma;
504 okLcLpi = okLcLpi && okLppi && isNotK0S && isNotLambdaBar && isNotGamma;
505 okLcLBarpi = okLcLBarpi && okLBarpip && isNotK0S && isNotLambda && isNotGamma;
992ba7d8 506
507 if (!okLck0sp && !okLcLpi && !okLcLBarpi) return 0;
a07ad8e0 508
34595b3c 509 // cuts on the minimum pt of the tracks
b833016c 510 if (TMath::Abs(bachelorTrack->Pt()) < fCutsRD[GetGlobalIndex(4,ptbin)] && fExcludedCut!=4) {
992ba7d8 511 AliDebug(4,Form(" bachelor track Pt=%2.2e > %2.2e",bachelorTrack->Pt(),fCutsRD[GetGlobalIndex(4,ptbin)]));
a07ad8e0 512 return 0;
513 }
b833016c 514 if (TMath::Abs(v0positiveTrack->Pt()) < fCutsRD[GetGlobalIndex(5,ptbin)] && fExcludedCut!=5) {
992ba7d8 515 AliDebug(4,Form(" V0-positive track Pt=%2.2e > %2.2e",v0positiveTrack->Pt(),fCutsRD[GetGlobalIndex(5,ptbin)]));
a07ad8e0 516 return 0;
517 }
b833016c 518 if (TMath::Abs(v0negativeTrack->Pt()) < fCutsRD[GetGlobalIndex(6,ptbin)] && fExcludedCut!=6) {
992ba7d8 519 AliDebug(4,Form(" V0-negative track Pt=%2.2e > %2.2e",v0negativeTrack->Pt(),fCutsRD[GetGlobalIndex(6,ptbin)]));
a07ad8e0 520 return 0;
521 }
522
a578b2da 523 // cut on cascade dca (prong-to-prong)
b833016c 524 if ( TMath::Abs(d->GetDCA()) > fCutsRD[GetGlobalIndex(7,ptbin)] && fExcludedCut!=7) { // prong-to-prong cascade DCA
992ba7d8 525 AliDebug(4,Form(" cascade tracks DCA don't pass the cut"));
a07ad8e0 526 return 0;
527 }
528
a578b2da 529 // cut on V0 dca (prong-to-prong)
b833016c 530 if ( TMath::Abs(v0->GetDCA()) > fCutsRD[GetGlobalIndex(8,ptbin)] && fExcludedCut!=8) { // prong-to-prong V0 DCA
992ba7d8 531 AliDebug(4,Form(" V0 DCA don't pass the cut"));
a07ad8e0 532 return 0;
533 }
534
a578b2da 535 // cut on V0 cosine of pointing angle wrt PV
b833016c 536 if (d->CosV0PointingAngle() < fCutsRD[GetGlobalIndex(9,ptbin)] && fExcludedCut!=9) { // cosine of V0 pointing angle wrt primary vertex
a578b2da 537 AliDebug(4,Form(" V0 cosine of pointing angle doesn't pass the cut"));
538 return 0;
539 }
540
541 // cut on bachelor transverse impact parameter wrt PV
b833016c 542 if (TMath::Abs(d->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(10,ptbin)] && fExcludedCut!=10) { // bachelor transverse impact parameter wrt PV
a578b2da 543 AliDebug(4,Form(" bachelor transverse impact parameter doesn't pass the cut"));
544 return 0;
545 }
546
547 // cut on V0 transverse impact parameter wrt PV
b833016c 548 if (TMath::Abs(d->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(11,ptbin)] && fExcludedCut!=11) { // V0 transverse impact parameter wrt PV
a578b2da 549 AliDebug(4,Form(" V0 transverse impact parameter doesn't pass the cut"));
550 return 0;
551 }
552
a578b2da 553 // cut on V0 pT min
b833016c 554 if (v0->Pt() < fCutsRD[GetGlobalIndex(15,ptbin)] && fExcludedCut!=15) { // V0 pT min
a578b2da 555 AliDebug(4,Form(" V0 track Pt=%2.2e > %2.2e",v0->Pt(),fCutsRD[GetGlobalIndex(15,ptbin)]));
556 return 0;
557 }
558
992ba7d8 559 }
a07ad8e0 560
992ba7d8 561 Int_t returnvalue = okLck0sp+2*okLcLBarpi+4*okLcLpi;
562 /*
563 retvalue case
53c91ed7 564 1 Lc->K0S + p
565 2 Lc->LambdaBar + pi
566 3 Lc->K0S + p AND Lc->LambdaBar + pi
567 4 Lc->Lambda + pi
568 5 Lc->K0S + p AND Lc->Lambda + pi
569 6 Lc->LambdaBar + pi AND Lc->Lambda + pi
570 7 Lc->K0S + p AND Lc->LambdaBar + pi AND Lc->Lambda + pi
992ba7d8 571 */
572
0dbd1d4f 573 Int_t returnvaluePID = 7;
574
575 // selection on candidate
34595b3c 576 if (selectionLevel==AliRDHFCuts::kAll ||
a578b2da 577 selectionLevel==AliRDHFCuts::kCandidate ||
0dbd1d4f 578 selectionLevel==AliRDHFCuts::kPID )
579 returnvaluePID = IsSelectedPID(d);
580
581 //if (fUsePID && returnvaluePID==0) return 0;
582
992ba7d8 583 Int_t returnvalueTot = 0;
e7af8919 584 if ( fUsePID )
60b29186 585 returnvalueTot = CombineCuts(returnvalueTrack,returnvalue,returnvaluePID);
992ba7d8 586 else
60b29186 587 returnvalueTot = CombineCuts(returnvalueTrack,returnvalue,7);
992ba7d8 588
589 return returnvalueTot;
590
591}
592//---------------------------------------------------------------------------
593Int_t AliRDHFCutsLctoV0::IsSelectedPID(AliAODRecoDecayHF* obj) {
594
595 // fPidHF -> PID object for bachelor
992ba7d8 596
60b29186 597 if (!fUsePID || !obj) {
598 AliDebug(2,"PID selection inactive. Candidate accepted.");
599 return 7; // all hypothesis are valid
600 }
992ba7d8 601
602 AliAODRecoCascadeHF *objD = (AliAODRecoCascadeHF*)obj;
603
b833016c 604 AliAODv0 * v0 = dynamic_cast<AliAODv0*>(objD->Getv0());
605 if ( v0 && ((v0->GetOnFlyStatus() == kTRUE && GetV0Type() == AliRDHFCuts::kOnlyOfflineV0s) ||
606 (v0->GetOnFlyStatus() == kFALSE && GetV0Type() == AliRDHFCuts::kOnlyOnTheFlyV0s)) ) return 0;
607
992ba7d8 608 AliAODTrack *bachelor = (AliAODTrack*)objD->GetBachelor();
609 AliAODTrack *v0Pos = (AliAODTrack*)objD->Getv0PositiveTrack();
610 AliAODTrack *v0Neg = (AliAODTrack*)objD->Getv0NegativeTrack();
611
612 if (!bachelor || !v0Pos || !v0Neg) return 0;
613
e7af8919 614 Bool_t okLcK0Sp = kTRUE; // K0S case
615 Bool_t okLcLambdaBarPi = kTRUE; // LambdaBar case
616 Bool_t okLcLambdaPi = kTRUE; // Lambda case
992ba7d8 617
e7af8919 618 CheckPID(bachelor,v0Neg,v0Pos,okLcK0Sp,okLcLambdaBarPi,okLcLambdaPi);
992ba7d8 619
620 Int_t returnvalue = okLcK0Sp+2*okLcLambdaBarPi+4*okLcLambdaPi;
621
a07ad8e0 622 return returnvalue;
623}
992ba7d8 624//-----------------------
53c91ed7 625void AliRDHFCutsLctoV0::CheckPID(AliAODTrack *bachelor,
626 AliAODTrack * /*v0Neg*/, AliAODTrack * /*v0Pos*/,
627 Bool_t &isBachelorID1, Bool_t &isBachelorID2, Bool_t &isBachelorID4) {
e7af8919 628 // identification strategy
629
53c91ed7 630 Int_t idxIDbyTOF = -1;
631 Int_t idxIDbyTPC = -1;
a578b2da 632
633 Int_t tpcID = -1;
634 Int_t tofID = -1;
53c91ed7 635 Double_t nTPCsigmas = -999;
636 Double_t nTOFsigmas = -999;
a578b2da 637
53c91ed7 638 Bool_t trackIDByTOF = -1;
639 Bool_t trackIDByTPC = -1;
640
641 Bool_t dummy = kFALSE;
a578b2da 642
e7af8919 643 switch (fPidSelectionFlag) {
644
645 case 0:
646
647 // identify bachelor
53c91ed7 648 idxIDbyTOF = fPidHF->ApplyPidTOFRaw(bachelor,4);
649 idxIDbyTPC = fPidHF->ApplyPidTPCRaw(bachelor,4);
650 isBachelorID1 = (idxIDbyTOF==4) && (idxIDbyTPC==4); // K0S case
651
652 idxIDbyTOF = fPidHF->ApplyPidTOFRaw(bachelor,2);
653 idxIDbyTPC = fPidHF->ApplyPidTPCRaw(bachelor,2);
654 isBachelorID2 = (idxIDbyTOF==2) && (idxIDbyTPC==2); // LambdaBar case
655
656 isBachelorID4 = isBachelorID2; // Lambda case
e7af8919 657
658 break;
53c91ed7 659
e7af8919 660 case 1:
661
662 // identify bachelor
53c91ed7 663 idxIDbyTOF = fPidHF->ApplyPidTOFRaw(bachelor,4);
664 idxIDbyTPC = fPidHF->ApplyPidTPCRaw(bachelor,4);
665 dummy = ( !(fPidHF->CheckTOFPIDStatus(bachelor)) && (idxIDbyTPC==4) &&
666 fPidHF->IsExcluded(bachelor,2,2.,"TPC") && fPidHF->IsExcluded(bachelor,3,2.,"TPC") ); // K0S case
667 isBachelorID1 = ( (idxIDbyTOF==4) || dummy );
668
669 idxIDbyTOF = fPidHF->ApplyPidTOFRaw(bachelor,2);
670 idxIDbyTPC = fPidHF->ApplyPidTPCRaw(bachelor,2);
671 dummy = ( !(fPidHF->CheckTOFPIDStatus(bachelor)) && (idxIDbyTPC==2) &&
672 fPidHF->IsExcluded(bachelor,3,2.,"TPC") && fPidHF->IsExcluded(bachelor,4,2.,"TPC") ); // LambdaBar case
673 isBachelorID2 = ( (idxIDbyTOF==2) || dummy );
e7af8919 674
53c91ed7 675 isBachelorID4 = isBachelorID2; // Lambda case
e7af8919 676
a578b2da 677 break;
53c91ed7 678
a578b2da 679 case 2:
680
681 // identify bachelor
53c91ed7 682 nTOFsigmas = -999;
683 tofID = fPidHF->GetnSigmaTOF(bachelor,4,nTOFsigmas);
684 nTPCsigmas = -999;
685 tpcID = fPidHF->GetnSigmaTPC(bachelor,4,nTPCsigmas);
686 trackIDByTOF = ( (tofID==1) && ( (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && TMath::Abs(nTOFsigmas)<3) ||
687 (bachelor->P()>=fHighPtCut && nTOFsigmas>-2 && nTOFsigmas<3) ) );
688 trackIDByTPC = ( (tpcID==1) && ( (bachelor->P()<fLowPtCut && TMath::Abs(nTPCsigmas)<2) ||
689 (bachelor->P()>=fLowPtCut && TMath::Abs(nTPCsigmas)<3) ) );
690 isBachelorID1 = (bachelor->P()<fLowPtCut && trackIDByTPC) || (bachelor->P()>=fLowPtCut && trackIDByTPC && trackIDByTOF); // K0S case
691
692 nTOFsigmas = -999;
693 tofID = fPidHF->GetnSigmaTOF(bachelor,2,nTOFsigmas);
694 nTPCsigmas = -999;
695 tpcID = fPidHF->GetnSigmaTPC(bachelor,2,nTPCsigmas);
696 trackIDByTOF = ( (tofID==1) && ( (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && TMath::Abs(nTOFsigmas)<3) ||
697 (bachelor->P()>=fHighPtCut && nTOFsigmas>-2 && nTOFsigmas<3) ) );
698 trackIDByTPC = ( (tpcID==1) && ( (bachelor->P()<fLowPtCut && TMath::Abs(nTPCsigmas)<2) ||
699 (bachelor->P()>=fLowPtCut && TMath::Abs(nTPCsigmas)<3) ) );
700 isBachelorID2 = (bachelor->P()<fLowPtCut && trackIDByTPC) || (bachelor->P()>=fLowPtCut && trackIDByTPC && trackIDByTOF); // LambdaBar case
701
702 isBachelorID4 = isBachelorID2; // Lambda case
a578b2da 703
704 break;
53c91ed7 705
a578b2da 706 case 3:
707
708 // identify bachelor
53c91ed7 709 nTOFsigmas = -999;
710 tofID = fPidHF->GetnSigmaTOF(bachelor,4,nTOFsigmas);
711 nTPCsigmas = -999;
712 tpcID = fPidHF->GetnSigmaTPC(bachelor,4,nTPCsigmas);
713 trackIDByTOF = ( (tofID==1) && ( (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && TMath::Abs(nTOFsigmas)<3) ||
714 (bachelor->P()>=fHighPtCut && nTOFsigmas>-2 && nTOFsigmas<3) ) );
715 trackIDByTPC = ( (tpcID==1) && ( (bachelor->P()<fLowPtCut && TMath::Abs(nTPCsigmas)<2) ||
716 (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && TMath::Abs(nTPCsigmas)<3) ||
717 (bachelor->P()>=fHighPtCut && nTPCsigmas>-3 && nTPCsigmas<2) ) );
718 isBachelorID1 = (bachelor->P()<fLowPtCut && trackIDByTPC) || (bachelor->P()>=fLowPtCut && trackIDByTPC && trackIDByTOF); // K0S case
719
720 nTOFsigmas = -999;
721 tofID = fPidHF->GetnSigmaTOF(bachelor,2,nTOFsigmas);
722 nTPCsigmas = -999;
723 tpcID = fPidHF->GetnSigmaTPC(bachelor,2,nTPCsigmas);
724 trackIDByTOF = ( (tofID==1) && ( (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && TMath::Abs(nTOFsigmas)<3) ||
725 (bachelor->P()>=fHighPtCut && nTOFsigmas>-2 && nTOFsigmas<3) ) );
726 trackIDByTPC = ( (tpcID==1) && ( (bachelor->P()<fLowPtCut && TMath::Abs(nTPCsigmas)<2) ||
727 (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && TMath::Abs(nTPCsigmas)<3) ||
728 (bachelor->P()>=fHighPtCut && nTPCsigmas>-3 && nTPCsigmas<2) ) );
729 isBachelorID2 = (bachelor->P()<fLowPtCut && trackIDByTPC) || (bachelor->P()>=fLowPtCut && trackIDByTPC && trackIDByTOF); // LambdaBar case
730
731 isBachelorID4 = isBachelorID2; // Lambda case
732
733 break;
734
735 case 4:
736
737 // identify bachelor
738 nTOFsigmas = -999;
739 tofID = fPidHF->GetnSigmaTOF(bachelor,4,nTOFsigmas);
740 nTPCsigmas = -999;
741 tpcID = fPidHF->GetnSigmaTPC(bachelor,4,nTPCsigmas);
742 trackIDByTOF = ( (tofID==1) && ( (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && TMath::Abs(nTOFsigmas)<3) ||
743 (bachelor->P()>=fHighPtCut && nTOFsigmas>-2 && nTOFsigmas<3) ) );
744 trackIDByTPC = ( (tpcID==1) && (TMath::Abs(nTPCsigmas)<2) );
745 isBachelorID1 = ( (bachelor->P()<fLowPtCut && trackIDByTPC) || (bachelor->P()>=fLowPtCut && trackIDByTOF) ); // K0S case
746
747 nTOFsigmas = -999;
748 tofID = fPidHF->GetnSigmaTOF(bachelor,2,nTOFsigmas);
749 nTPCsigmas = -999;
750 tpcID = fPidHF->GetnSigmaTPC(bachelor,2,nTPCsigmas);
751 trackIDByTOF = ( (tofID==1) && ( (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && TMath::Abs(nTOFsigmas)<3) ||
752 (bachelor->P()>=fHighPtCut && nTOFsigmas>-2 && nTOFsigmas<3) ) );
753 trackIDByTPC = ( (tpcID==1) && (TMath::Abs(nTPCsigmas)<2) );
754 isBachelorID2 = ( (bachelor->P()<fLowPtCut && trackIDByTPC) || (bachelor->P()>=fLowPtCut && trackIDByTOF) ); // LambdaBar case
755
756 isBachelorID4 = isBachelorID2; // Lambda case
a578b2da 757
e7af8919 758 break;
759
53c91ed7 760 case 5:
761
762 // identify bachelor
763 nTOFsigmas = -999;
764 tofID = fPidHF->GetnSigmaTOF(bachelor,4,nTOFsigmas);
765 nTPCsigmas = -999;
766 tpcID = fPidHF->GetnSigmaTPC(bachelor,4,nTPCsigmas);
767 trackIDByTOF = ( (tofID==1) && ( (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && TMath::Abs(nTOFsigmas)<3) ||
768 (bachelor->P()>=fHighPtCut && nTOFsigmas>-2 && nTOFsigmas<3) ) );
769 trackIDByTPC = ( (tpcID==1) && ( (bachelor->P()<fLowPtCut && TMath::Abs(nTPCsigmas)<2) || (bachelor->P()>=fHighPtCut && !trackIDByTOF && TMath::Abs(nTPCsigmas)<3) ) );
770 isBachelorID1 = (bachelor->P()<fLowPtCut && trackIDByTPC) || (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && trackIDByTOF) || (bachelor->P()>=fHighPtCut && (trackIDByTOF || trackIDByTPC) ); // K0S case
771
772 nTOFsigmas = -999;
773 tofID = fPidHF->GetnSigmaTOF(bachelor,2,nTOFsigmas);
774 nTPCsigmas = -999;
775 tpcID = fPidHF->GetnSigmaTPC(bachelor,2,nTPCsigmas);
776 trackIDByTOF = ( (tofID==1) && ( (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && TMath::Abs(nTOFsigmas)<3) ||
777 (bachelor->P()>=fHighPtCut && nTOFsigmas>-2 && nTOFsigmas<3) ) );
778 trackIDByTPC = ( (tpcID==1) && ( (bachelor->P()<fLowPtCut && TMath::Abs(nTPCsigmas)<2) || (bachelor->P()>=fHighPtCut && !trackIDByTOF && TMath::Abs(nTPCsigmas)<3) ) );
779 isBachelorID2 = (bachelor->P()<fLowPtCut && trackIDByTPC) || (bachelor->P()>=fLowPtCut && bachelor->P()<fHighPtCut && trackIDByTOF) || (bachelor->P()>=fHighPtCut && (trackIDByTOF || trackIDByTPC) ); // LambdaBar case
780
781 isBachelorID4 = isBachelorID2; // Lambda case
782
783 break;
e7af8919 784 }
785
786}
787//----------------
60b29186 788Int_t AliRDHFCutsLctoV0::CombineCuts(Int_t returnvalueTrack, Int_t returnvalue, Int_t returnvaluePID) const {
789 //
790 // combine track selection, topological cuts and PID
791 //
992ba7d8 792
53c91ed7 793 Int_t returnvalueTot=returnvalueTrack&returnvalue;
794 returnvalueTot=returnvalueTot&returnvaluePID;
992ba7d8 795
53c91ed7 796 return returnvalueTot;
992ba7d8 797}
798
799//----------------------------------
0dbd1d4f 800Int_t AliRDHFCutsLctoV0::IsSelectedSingleCut(TObject* obj, Int_t selectionLevel, Int_t cutIndex) {
992ba7d8 801 //
0dbd1d4f 802 // Apply selection on single cut
992ba7d8 803 //
804
805 if (!fCutsRD) {
60b29186 806 AliDebug(2,"Cut matrice not inizialized. Exit...");
992ba7d8 807 return 0;
808 }
809
810 AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
811 if (!d) {
0dbd1d4f 812 AliDebug(2,"AliAODRecoCascadeHF null");
992ba7d8 813 return 0;
814 }
815
ff12b981 816 if (!d->GetSecondaryVtx()) {
817 AliDebug(2,"No secondary vertex for cascade");
0dbd1d4f 818 return 0;
819 }
820
ff12b981 821 if (d->GetNDaughters()!=2) {
822 AliDebug(2,Form("No 2 daughters for current cascade (nDaughters=%d)",d->GetNDaughters()));
823 return 0;
824 }
992ba7d8 825
ff12b981 826 AliAODv0 * v0 = dynamic_cast<AliAODv0*>(d->Getv0());
b833016c 827 if ( v0 && ((v0->GetOnFlyStatus() == kTRUE && GetV0Type() == AliRDHFCuts::kOnlyOfflineV0s) ||
828 (v0->GetOnFlyStatus() == kFALSE && GetV0Type() == AliRDHFCuts::kOnlyOnTheFlyV0s)) ) return 0;
829
ff12b981 830 AliAODTrack * bachelorTrack = dynamic_cast<AliAODTrack*>(d->GetBachelor());
831 if (!v0 || !bachelorTrack) {
832 AliDebug(2,"No V0 or no bachelor for current cascade");
833 return 0;
834 }
835
836 if (bachelorTrack->GetID()<0) {
837 AliDebug(2,Form("Bachelor has negative ID %d",bachelorTrack->GetID()));
838 return 0;
839 }
840
841 if (!v0->GetSecondaryVtx()) {
842 AliDebug(2,"No secondary vertex for V0 by cascade");
843 return 0;
844 }
845
846 if (v0->GetNDaughters()!=2) {
847 AliDebug(2,Form("No 2 daughters for V0 of current cascade (onTheFly=%d, nDaughters=%d)",v0->GetOnFlyStatus(),v0->GetNDaughters()));
848 return 0;
849 }
850
851
0dbd1d4f 852 // Get the V0 daughter tracks
ff12b981 853 AliAODTrack *v0positiveTrack = dynamic_cast<AliAODTrack*>(d->Getv0PositiveTrack());
854 AliAODTrack *v0negativeTrack = dynamic_cast<AliAODTrack*>(d->Getv0NegativeTrack());
0dbd1d4f 855 if (!v0positiveTrack || !v0negativeTrack ) {
856 AliDebug(2,"No V0 daughters' objects");
992ba7d8 857 return 0;
858 }
859
ff12b981 860 if (v0positiveTrack->GetID()<0 || v0negativeTrack->GetID()<0) {
861 AliDebug(2,Form("At least one of V0 daughters has negative ID %d %d",v0positiveTrack->GetID(),v0negativeTrack->GetID()));
862 return 0;
863 }
864
ff12b981 865 //if(fUseTrackSelectionWithFilterBits && d->HasBadDaughters()) return 0;
60b29186 866 if ( fUseTrackSelectionWithFilterBits && !(bachelorTrack->TestFilterMask(BIT(4))) ) {
867 AliDebug(2,"Check on the bachelor FilterBit: no BIT(4). Candidate rejected.");
868 return 0;
869 }
870
ff12b981 871
34595b3c 872 // selection on daughter tracks
873 if (selectionLevel==AliRDHFCuts::kAll ||
0dbd1d4f 874 selectionLevel==AliRDHFCuts::kTracks) {
875
60b29186 876 if (!AreLctoV0DaughtersSelected(d)) return 0;
877
0dbd1d4f 878 }
992ba7d8 879
880 Bool_t okLck0sp=kFALSE, okLcLpi=kFALSE, okLcLBarpi=kFALSE;
881
882 // selection on candidate
34595b3c 883 if (selectionLevel==AliRDHFCuts::kAll ||
992ba7d8 884 selectionLevel==AliRDHFCuts::kCandidate) {
885
0dbd1d4f 886 Double_t pt = d->Pt();
887 Int_t ptbin = PtBin(pt);
888
889 Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
992ba7d8 890 Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
0dbd1d4f 891 Double_t mLPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
992ba7d8 892
0dbd1d4f 893 // K0S + p
992ba7d8 894 Double_t mk0s = v0->MassK0Short();
895 Double_t mLck0sp = d->InvMassLctoK0sP();
896
34595b3c 897 // Lambda + pi
992ba7d8 898 Double_t mlambda = v0->MassLambda();
899 Double_t malambda = v0->MassAntiLambda();
900 Double_t mLcLpi = d->InvMassLctoLambdaPi();
901
992ba7d8 902 switch (cutIndex) {
903 case 0:
0dbd1d4f 904 // cut on Lc mass with K0S+p hypothesis
992ba7d8 905 okLck0sp = TMath::Abs(mLck0sp-mLcPDG)<=fCutsRD[GetGlobalIndex(0,ptbin)];
906 okLcLpi = kFALSE;
907 okLcLBarpi = kFALSE;
908 break;
909 case 1:
0dbd1d4f 910 // cut on Lc mass with Lambda+pi hypothesis
992ba7d8 911 okLck0sp = kFALSE;
912 okLcLpi = TMath::Abs(mLcLpi-mLcPDG)<=fCutsRD[GetGlobalIndex(1,ptbin)];
913 okLcLBarpi = okLcLpi;
914 break;
915 case 2:
0dbd1d4f 916 // cuts on the V0 mass: K0S case
992ba7d8 917 okLck0sp = TMath::Abs(mk0s-mk0sPDG)<=fCutsRD[GetGlobalIndex(2,ptbin)];
918 okLcLpi = kFALSE;
919 okLcLBarpi = kFALSE;
920 break;
921 case 3:
0dbd1d4f 922 // cuts on the V0 mass: Lambda/LambdaBar case
992ba7d8 923 okLck0sp = kFALSE;
924 okLcLpi = TMath::Abs(mlambda-mLPDG)<=fCutsRD[GetGlobalIndex(3,ptbin)];
a578b2da 925 //okLcLpi = okLcLpi && (bachelorTrack->Charge()==+1);
992ba7d8 926 okLcLBarpi = TMath::Abs(malambda-mLPDG)<=fCutsRD[GetGlobalIndex(3,ptbin)];
a578b2da 927 //okLcLBarpi = okLcLBarpi && (bachelorTrack->Charge()==-1);
992ba7d8 928 break;
929 case 4:
0dbd1d4f 930 // cuts on the minimum pt of bachelor
992ba7d8 931 okLck0sp = TMath::Abs(bachelorTrack->Pt())>=fCutsRD[GetGlobalIndex(4,ptbin)];
932 okLcLpi = okLck0sp;
933 okLcLBarpi = okLck0sp;
934 break;
935 case 5:
0dbd1d4f 936 // cuts on the minimum pt of positive V0daughter
992ba7d8 937 okLck0sp = TMath::Abs(v0positiveTrack->Pt())>=fCutsRD[GetGlobalIndex(5,ptbin)];
938 okLcLpi = okLck0sp;
939 okLcLBarpi = okLck0sp;
940 break;
941 case 6:
0dbd1d4f 942 // cuts on the minimum pt of negative V0daughter
992ba7d8 943 okLck0sp = TMath::Abs(v0negativeTrack->Pt())>=fCutsRD[GetGlobalIndex(6,ptbin)];
944 okLcLpi = okLck0sp;
945 okLcLBarpi = okLck0sp;
946 break;
947 case 7:
0dbd1d4f 948 // cut on cascade dca
a578b2da 949 okLck0sp = TMath::Abs(d->GetDCA())<=fCutsRD[GetGlobalIndex(7,ptbin)];
992ba7d8 950 okLcLpi = okLck0sp;
951 okLcLBarpi = okLck0sp;
952 break;
953 case 8:
0dbd1d4f 954 // cut on V0 dca
a578b2da 955 okLck0sp = TMath::Abs(v0->GetDCA())<=fCutsRD[GetGlobalIndex(8,ptbin)];
956 okLcLpi = okLck0sp;
957 okLcLBarpi = okLck0sp;
958 break;
959 case 9:
960 // cut on V0 cosine of pointing angle wrt PV
961 okLck0sp = d->CosV0PointingAngle()>=fCutsRD[GetGlobalIndex(9,ptbin)];
962 okLcLpi = okLck0sp;
963 okLcLBarpi = okLck0sp;
964 break;
965 case 10:
966 // cut on bachelor transverse impact parameter wrt PV
967 okLck0sp = TMath::Abs(d->Getd0Prong(0))<=fCutsRD[GetGlobalIndex(10,ptbin)];
968 okLcLpi = okLck0sp;
969 okLcLBarpi = okLck0sp;
970 break;
971 case 11:
972 // cut on V0 transverse impact parameter wrt PV
973 okLck0sp = TMath::Abs(d->Getd0Prong(1))<=fCutsRD[GetGlobalIndex(11,ptbin)];
974 okLcLpi = okLck0sp;
975 okLcLBarpi = okLck0sp;
976 break;
977 case 12:
978 // cut on K0S invariant mass veto
979 okLcLpi = TMath::Abs(mk0s-mk0sPDG)>=fCutsRD[GetGlobalIndex(12,ptbin)];
980 okLcLBarpi = TMath::Abs(mk0s-mk0sPDG)>=fCutsRD[GetGlobalIndex(12,ptbin)];
981 break;
982 case 13:
983 // cut on Lambda/LambdaBar invariant mass veto
984 okLck0sp = (TMath::Abs(mlambda-mLPDG)>=fCutsRD[GetGlobalIndex(13,ptbin)] &&
985 TMath::Abs(malambda-mLPDG)>=fCutsRD[GetGlobalIndex(13,ptbin)]);
986 break;
987 case 14:
988 // cut on gamma invariant mass veto
989 okLck0sp = v0->InvMass2Prongs(0,1,11,11)>=fCutsRD[GetGlobalIndex(14,ptbin)];
990 okLcLpi = okLck0sp;
991 okLcLBarpi = okLck0sp;
992 break;
993 case 15:
994 // cut on V0 pT min
995 okLck0sp = v0->Pt()>=fCutsRD[GetGlobalIndex(15,ptbin)];
992ba7d8 996 okLcLpi = okLck0sp;
997 okLcLBarpi = okLck0sp;
998 break;
999 }
992ba7d8 1000 }
1001
1002 Int_t returnvalue = okLck0sp+2*okLcLBarpi+4*okLcLpi;
1003 /*
1004 retvalue case
53c91ed7 1005 1 Lc->K0S + p
1006 2 Lc->LambdaBar + pi
1007 3 Lc->K0S + p AND Lc->LambdaBar + pi
1008 4 Lc->Lambda + pi
1009 5 Lc->K0S + p AND Lc->Lambda + pi
1010 6 Lc->LambdaBar + pi AND Lc->Lambda + pi
1011 7 Lc->K0S + p AND Lc->LambdaBar + pi AND Lc->Lambda + pi
992ba7d8 1012 */
1013
1014
0dbd1d4f 1015 /*
53c91ed7 1016 Int_t returnvaluePID = 7;
992ba7d8 1017
53c91ed7 1018 // selection on PID
1019 if (selectionLevel==AliRDHFCuts::kAll ||
1020 selectionLevel==AliRDHFCuts::kCandidate ||
1021 selectionLevel==AliRDHFCuts::kPID )
992ba7d8 1022 returnvaluePID = IsSelectedPID(d);
0dbd1d4f 1023 */
992ba7d8 1024
0dbd1d4f 1025 Int_t returnvalueTot = 0;
1026 //if ( fUsePID )
60b29186 1027 //returnvalueTot = CombineCuts(returnvalue,returnvaluePID);
0dbd1d4f 1028 //else
1029 returnvalueTot = returnvalue;
992ba7d8 1030
1031 return returnvalueTot;
1032
1033}
e7af8919 1034//----------------------------------
1035void AliRDHFCutsLctoV0::SetStandardCutsPP2010() {
1036
53c91ed7 1037 SetName("LctoV0ProductionCuts");
1038 SetTitle("Production cuts for Lc->V0+bachelor analysis");
e7af8919 1039
1040 AliESDtrackCuts* esdTrackCuts=new AliESDtrackCuts();
1041 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
1042 //default
1043 esdTrackCuts->SetRequireTPCRefit(kTRUE);
1044 esdTrackCuts->SetRequireITSRefit(kTRUE);
0dbd1d4f 1045 esdTrackCuts->SetMinNClustersITS(0);//(4); // default is 5
e7af8919 1046 esdTrackCuts->SetMinNClustersTPC(70);
0dbd1d4f 1047 //esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
34595b3c 1048 // AliESDtrackCuts::kAny);
e7af8919 1049 // default is kBoth, otherwise kAny
1050 esdTrackCuts->SetMinDCAToVertexXY(0.);
1051 esdTrackCuts->SetPtRange(0.3,1.e10);
0dbd1d4f 1052 //esdTrackCuts->SetEtaRange(-0.8,+0.8);
1053 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
e7af8919 1054 AddTrackCuts(esdTrackCuts);
57d15652 1055 delete esdTrackCuts;
1056 esdTrackCuts=NULL;
e7af8919 1057
1058
1059 AliESDtrackCuts* esdTrackCutsV0daughters=new AliESDtrackCuts();
1060 esdTrackCutsV0daughters->SetRequireSigmaToVertex(kFALSE);
1061 //default
1062 esdTrackCutsV0daughters->SetRequireTPCRefit(kTRUE);
0dbd1d4f 1063 esdTrackCutsV0daughters->SetRequireITSRefit(kFALSE);//(kTRUE);
1064 esdTrackCutsV0daughters->SetMinNClustersITS(0);//(4); // default is 5
e7af8919 1065 esdTrackCutsV0daughters->SetMinNClustersTPC(70);
0dbd1d4f 1066 //esdTrackCutsV0daughters->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
34595b3c 1067 // AliESDtrackCuts::kAny);
e7af8919 1068 // default is kBoth, otherwise kAny
1069 esdTrackCutsV0daughters->SetMinDCAToVertexXY(0.);
1070 esdTrackCutsV0daughters->SetPtRange(0.,1.e10);
0dbd1d4f 1071 esdTrackCutsV0daughters->SetAcceptKinkDaughters(kFALSE);
e7af8919 1072 AddTrackCutsV0daughters(esdTrackCutsV0daughters);
57d15652 1073 delete esdTrackCutsV0daughters;
1074 esdTrackCutsV0daughters=NULL;
e7af8919 1075
1076 const Int_t nptbins=1;
1077 Float_t* ptbins;
1078 ptbins=new Float_t[nptbins+1];
1079 ptbins[0]=0.;
1080 ptbins[1]=99999999.;
1081
1082 SetPtBins(nptbins+1,ptbins);
1083 SetPtBins(nptbins+1,ptbins);
1084
a578b2da 1085 const Int_t nvars=17;
e7af8919 1086
1087 Float_t** prodcutsval;
1088 prodcutsval=new Float_t*[nvars];
1089 for(Int_t ic=0;ic<nvars;ic++){prodcutsval[ic]=new Float_t[nptbins];}
1090 for(Int_t ipt2=0;ipt2<nptbins;ipt2++){
53c91ed7 1091 prodcutsval[0][ipt2]=1.; // inv. mass if K0S [GeV/c2]
1092 prodcutsval[1][ipt2]=1.; // inv. mass if Lambda [GeV/c2]
1093 prodcutsval[2][ipt2]=0.05; // inv. mass V0 if K0S [GeV/c2]
1094 prodcutsval[3][ipt2]=0.05; // inv. mass V0 if Lambda [GeV/c2]
1095 prodcutsval[4][ipt2]=0.3; // pT min bachelor track [GeV/c] // AOD by construction
1096 prodcutsval[5][ipt2]=0.; // pT min V0-positive track [GeV/c]
1097 prodcutsval[6][ipt2]=0.; // pT min V0-negative track [GeV/c]
1098 prodcutsval[7][ipt2]=1000.; // dca cascade cut [cm]
1099 prodcutsval[8][ipt2]=1.5; // dca V0 cut [nSigma] // it's 1.5 x offline V0s
1100 prodcutsval[9][ipt2]=-1.; // cosPA V0 cut // it's 0.90 x offline V0s at reconstruction level, 0.99 at filtering level
1101 prodcutsval[10][ipt2]=3.; // d0 max bachelor wrt PV [cm]
1102 prodcutsval[11][ipt2]=1000.;// d0 max V0 wrt PV [cm]
1103 prodcutsval[12][ipt2]=0.; // mass K0S veto [GeV/c2]
1104 prodcutsval[13][ipt2]=0.; // mass Lambda/LambdaBar veto [GeV/c2]
1105 prodcutsval[14][ipt2]=0.; // mass Gamma veto [GeV/c2]
1106 prodcutsval[15][ipt2]=0.; // pT min V0 track [GeV/c]
1107 prodcutsval[16][ipt2]=0.; // V0 type cut
e7af8919 1108 }
0dbd1d4f 1109 SetCuts(nvars,nptbins,prodcutsval);
e7af8919 1110
0dbd1d4f 1111 SetGlobalIndex(nvars,nptbins);
1112 SetPtBins(nptbins+1,ptbins);
e7af8919 1113
1114
1115 //pid settings
1116 //1. bachelor: default one
1117 AliAODPidHF* pidObjBachelor = new AliAODPidHF();
1118 Double_t sigmasBac[5]={3.,1.,1.,3.,3.}; // 0, 1(A), 2(A) -> TPC; 3 -> TOF; 4 -> ITS
1119 pidObjBachelor->SetSigma(sigmasBac);
1120 pidObjBachelor->SetAsym(kFALSE);
1121 pidObjBachelor->SetMatch(1);
1122 pidObjBachelor->SetTPC(kTRUE);
1123 pidObjBachelor->SetTOF(kTRUE);
1124 pidObjBachelor->SetTOFdecide(kFALSE);
1125 SetPidHF(pidObjBachelor);
1126
e7af8919 1127 SetUsePID(kFALSE);//(kTRUE);
1128
ff12b981 1129 //PrintAll();
e7af8919 1130
53c91ed7 1131 for(Int_t iiv=0;iiv<nvars;iiv++){
1132 delete [] prodcutsval[iiv];
1133 }
1134 delete [] prodcutsval;
1135 prodcutsval=NULL;
1136 delete [] ptbins;
1137 ptbins=NULL;
e7af8919 1138
e7af8919 1139
53c91ed7 1140 delete pidObjBachelor;
1141 pidObjBachelor=NULL;
e7af8919 1142
53c91ed7 1143 return;
e7af8919 1144}
1145//------------------
1146void AliRDHFCutsLctoV0::SetStandardCutsPbPb2010() {
1147
53c91ed7 1148 SetName("LctoV0ProductionCuts");
1149 SetTitle("Production cuts for Lc->V0+bachelor analysis");
e7af8919 1150
53c91ed7 1151 SetStandardCutsPP2010();
e7af8919 1152
53c91ed7 1153 return;
e7af8919 1154}
1155//------------------
1156void AliRDHFCutsLctoV0::SetStandardCutsPbPb2011() {
1157
1158 // Default 2010 PbPb cut object
1159 SetStandardCutsPbPb2010();
1160
1161 //
1162 // Enable all 2011 PbPb run triggers
34595b3c 1163 //
e7af8919 1164 SetTriggerClass("");
1165 ResetMaskAndEnableMBTrigger();
1166 EnableCentralTrigger();
1167 EnableSemiCentralTrigger();
1168
1169}
34595b3c 1170//-----------------------
1171Int_t AliRDHFCutsLctoV0::GetV0Type(){
1172
1173 const Int_t nvars = this->GetNVars() ;
1174 //Float_t *vArray =GetCuts();
1175 //fV0Type = vArray[nvars-1];
1176 fV0Type = (this->GetCuts())[nvars-1];
1177 //this->GetCuts(vArray);
1178 TString *sVarNames=GetVarNames();
1179
1180 if(sVarNames[nvars-1].Contains("V0 type")) return (Int_t)fV0Type;
a578b2da 1181 else {AliInfo("AliRDHFCutsLctoV0 Last variable is not the V0 type!!!"); return -999;}
1182}
1183
1184//---------------------------------------------------------------------------
1185void AliRDHFCutsLctoV0::PrintAll() const {
1186 //
1187 // print all cuts values
1188 //
1189
1190 printf("Minimum vtx type %d\n",fMinVtxType);
1191 printf("Minimum vtx contr %d\n",fMinVtxContr);
1192 printf("Max vtx red chi2 %f\n",fMaxVtxRedChi2);
1193 printf("Min SPD mult %d\n",fMinSPDMultiplicity);
1194 printf("Use PID %d (PID selection flag = %d) OldPid=%d\n",(Int_t)fUsePID,(Int_t)fPidSelectionFlag,fPidHF ? fPidHF->GetOldPid() : -1);
53c91ed7 1195 printf("High value for pT %f\n",fHighPtCut);
1196 printf("Low and high values for pT cuts: %f %f\n",fLowPtCut,fHighPtCut);
a578b2da 1197 printf("Remove daughters from vtx %d\n",(Int_t)fRemoveDaughtersFromPrimary);
a578b2da 1198 printf("Physics selection: %s\n",fUsePhysicsSelection ? "Yes" : "No");
1199 printf("Pileup rejection: %s\n",(fOptPileup > 0) ? "Yes" : "No");
ff12b981 1200 printf("UseTrackSelectionWithFilterBits: %s\n",fUseTrackSelectionWithFilterBits ? "Yes" : "No");
60b29186 1201 printf("Reject kink: %s\n",fKinkReject ? "Yes" : "No");
a578b2da 1202 if(fOptPileup==1) printf(" -- Reject pileup event");
1203 if(fOptPileup==2) printf(" -- Reject tracks from pileup vtx");
1204 if(fUseCentrality>0) {
1205 TString estimator="";
1206 if(fUseCentrality==1) estimator = "V0";
1207 if(fUseCentrality==2) estimator = "Tracks";
1208 if(fUseCentrality==3) estimator = "Tracklets";
1209 if(fUseCentrality==4) estimator = "SPD clusters outer";
1210 printf("Centrality class considered: %.1f-%.1f, estimated with %s",fMinCentrality,fMaxCentrality,estimator.Data());
1211 }
1212 if(fIsCandTrackSPDFirst) printf("Check for candidates with pt < %2.2f, that daughters fullfill kFirst criteria\n",fMaxPtCandTrackSPDFirst);
60b29186 1213
a578b2da 1214 if(fVarNames){
1215 cout<<"Array of variables"<<endl;
1216 for(Int_t iv=0;iv<fnVars;iv++){
1217 cout<<fVarNames[iv]<<"\t";
1218 }
1219 cout<<endl;
1220 }
1221 if(fVarsForOpt){
1222 cout<<"Array of optimization"<<endl;
1223 for(Int_t iv=0;iv<fnVars;iv++){
1224 cout<<fVarsForOpt[iv]<<"\t";
1225 }
1226 cout<<endl;
1227 }
1228 if(fIsUpperCut){
1229 cout<<"Array of upper/lower cut"<<endl;
53c91ed7 1230 for(Int_t iv=0;iv<fnVars;iv++){
1231 cout<<fIsUpperCut[iv]<<"\t";
1232 }
1233 cout<<endl;
a578b2da 1234 }
1235 if(fPtBinLimits){
1236 cout<<"Array of ptbin limits"<<endl;
1237 for(Int_t ib=0;ib<fnPtBinLimits;ib++){
1238 cout<<fPtBinLimits[ib]<<"\t";
1239 }
1240 cout<<endl;
1241 }
1242 if(fCutsRD){
1243 cout<<"Matrix of cuts"<<endl;
53c91ed7 1244 for(Int_t iv=0;iv<fnVars;iv++){
1245 for(Int_t ib=0;ib<fnPtBins;ib++){
1246 cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<"\t";
1247 }
1248 cout<<endl;
1249 }
1250 cout<<endl;
a578b2da 1251 }
ff12b981 1252
60b29186 1253 if (fTrackCuts) {
1254 Float_t eta1=0, eta2=0; fTrackCuts->GetEtaRange(eta1,eta2);
1255 cout << " etaRange for Bachelor: [" << eta1 << "," << eta2 << "]\n";
1256 }
1257 if (fV0daughtersCuts) {
1258 Float_t eta3=0, eta4=0; fV0daughtersCuts->GetEtaRange(eta3,eta4);
1259 cout << " etaRange for V0daughters: [" << eta3 << "," << eta4 << "]\n";
1260 }
a578b2da 1261 return;
ff12b981 1262
a578b2da 1263}
1264
1265//-------------------------
1266Bool_t AliRDHFCutsLctoV0::IsInFiducialAcceptance(Double_t pt, Double_t y) const
1267{
1268 //
1269 //
1270 // Checking if Lc is in fiducial acceptance region
1271 //
1272 //
1273
1274 if(fMaxRapidityCand>-998.){
1275 if(TMath::Abs(y) > fMaxRapidityCand) return kFALSE;
1276 else return kTRUE;
1277 }
1278
1279 if(pt > 5.) {
1280 // applying cut for pt > 5 GeV
1281 AliDebug(2,Form("pt of Lambda_c = %f (> 5), cutting at |y| < 0.8",pt));
1282 if (TMath::Abs(y) > 0.8) return kFALSE;
1283
1284 } else {
1285 // appliying smooth cut for pt < 5 GeV
1286 Double_t maxFiducialY = -0.2/15*pt*pt+1.9/15*pt+0.5;
1287 Double_t minFiducialY = 0.2/15*pt*pt-1.9/15*pt-0.5;
1288 AliDebug(2,Form("pt of Lambda_c = %f (< 5), cutting according to the fiducial zone [%f, %f]\n",pt,minFiducialY,maxFiducialY));
1289 if (y < minFiducialY || y > maxFiducialY) return kFALSE;
1290 }
1291 //
1292 return kTRUE;
34595b3c 1293}
60b29186 1294//---------------------------------------------------------------------------
1295Bool_t AliRDHFCutsLctoV0::AreLctoV0DaughtersSelected(AliAODRecoDecayHF *dd) const{
1296 //
1297 // Daughter tracks selection
1298 //
1299
1300 AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)dd;
1301 if (!d) {
1302 AliDebug(2,"AliAODRecoCascadeHF null");
1303 return kFALSE;
1304 }
1305
1306 if (!fTrackCuts) {
1307 AliFatal("Cut object is not defined for bachelor. Candidate accepted.");
1308 return kFALSE;
1309 }
1310
1311 AliAODTrack * bachelorTrack = dynamic_cast<AliAODTrack*>(d->GetBachelor());
1312 if (!bachelorTrack) return kFALSE;
1313
1314 if (fIsCandTrackSPDFirst && d->Pt()<fMaxPtCandTrackSPDFirst) {
53c91ed7 1315 if(!bachelorTrack->HasPointOnITSLayer(0)) return kFALSE;
60b29186 1316 }
1317
1318 if (fKinkReject != (!(fTrackCuts->GetAcceptKinkDaughters())) ) {
1319 AliError(Form("Not compatible setting: fKinkReject=%1d - fTrackCuts->GetAcceptKinkDaughters()=%1d",fKinkReject, fTrackCuts->GetAcceptKinkDaughters()));
1320 return kFALSE;
1321 }
1322
1323 AliAODVertex *vAOD = d->GetPrimaryVtx();
1324 Double_t pos[3]; vAOD->GetXYZ(pos);
1325 Double_t cov[6]; vAOD->GetCovarianceMatrix(cov);
1326 const AliESDVertex vESD(pos,cov,100.,100);
1327
1328 if (!IsDaughterSelected(bachelorTrack,&vESD,fTrackCuts)) return kFALSE;
1329
1330 if (!fV0daughtersCuts) {
1331 AliFatal("Cut object is not defined for V0daughters. Candidate accepted.");
1332 return kFALSE;
1333 }
1334
1335 AliAODv0 * v0 = dynamic_cast<AliAODv0*>(d->Getv0());
1336 if (!v0) return kFALSE;
1337 AliAODTrack *v0positiveTrack = dynamic_cast<AliAODTrack*>(d->Getv0PositiveTrack());
1338 if (!v0positiveTrack) return kFALSE;
1339 AliAODTrack *v0negativeTrack = dynamic_cast<AliAODTrack*>(d->Getv0NegativeTrack());
1340 if (!v0negativeTrack) return kFALSE;
1341
1342
1343 Float_t etaMin=0, etaMax=0; fV0daughtersCuts->GetEtaRange(etaMin,etaMax);
1344 if ( (v0positiveTrack->Eta()<=etaMin || v0positiveTrack->Eta()>=etaMax) ||
1345 (v0negativeTrack->Eta()<=etaMin || v0negativeTrack->Eta()>=etaMax) ) return kFALSE;
1346 Float_t ptMin=0, ptMax=0; fV0daughtersCuts->GetPtRange(ptMin,ptMax);
1347 if ( (v0positiveTrack->Pt()<=ptMin || v0positiveTrack->Pt()>=ptMax) ||
1348 (v0negativeTrack->Pt()<=ptMin || v0negativeTrack->Pt()>=ptMax) ) return kFALSE;
1349
1350 // Condition on nTPCclusters
1351 if (fV0daughtersCuts->GetMinNClusterTPC()>0) {
1352 if ( ( ( v0positiveTrack->GetTPCClusterInfo(2,1) ) < fV0daughtersCuts->GetMinNClusterTPC() ) ||
1353 ( ( v0negativeTrack->GetTPCClusterInfo(2,1) ) < fV0daughtersCuts->GetMinNClusterTPC() ) ) return kFALSE;
1354 }
1355
1356 // kTPCrefit status
1357 if (v0->GetOnFlyStatus()==kFALSE) { // only for offline V0s
1358 if (fV0daughtersCuts->GetRequireTPCRefit()) {
1359 if( !(v0positiveTrack->GetStatus() & AliESDtrack::kTPCrefit)) return kFALSE;
1360 if( !(v0negativeTrack->GetStatus() & AliESDtrack::kTPCrefit)) return kFALSE;
1361 }
1362 }
1363 // kink condition
1364 if (!fV0daughtersCuts->GetAcceptKinkDaughters()) {
1365 AliAODVertex *maybeKinkPos = (AliAODVertex*)v0positiveTrack->GetProdVertex();
1366 AliAODVertex *maybeKinkNeg = (AliAODVertex*)v0negativeTrack->GetProdVertex();
1367 if (maybeKinkPos->GetType()==AliAODVertex::kKink ||
1368 maybeKinkNeg->GetType()==AliAODVertex::kKink) return kFALSE;
1369 }
1370 // Findable clusters > 0 condition - from V0 analysis
1371 //if( v0positiveTrack->GetTPCNclsF()<=0 || v0negativeTrack->GetTPCNclsF()<=0 ) return kFALSE;
1372 /*
1373 Float_t lPosTrackCrossedRows = v0positiveTrack->GetTPCClusterInfo(2,1);
1374 Float_t lNegTrackCrossedRows = v0positiveTrack->GetTPCClusterInfo(2,1);
1375 fTreeVariableLeastNbrCrossedRows = (Int_t) lPosTrackCrossedRows;
1376 if( lNegTrackCrossedRows < fTreeVariableLeastNbrCrossedRows )
1377 fTreeVariableLeastNbrCrossedRows = (Int_t) lNegTrackCrossedRows;
1378 //Compute ratio Crossed Rows / Findable clusters
1379 //Note: above test avoids division by zero!
1380 Float_t lPosTrackCrossedRowsOverFindable = lPosTrackCrossedRows / ((double)(pTrack->GetTPCNclsF()));
1381 Float_t lNegTrackCrossedRowsOverFindable = lNegTrackCrossedRows / ((double)(nTrack->GetTPCNclsF()));
1382 fTreeVariableLeastRatioCrossedRowsOverFindable = lPosTrackCrossedRowsOverFindable;
1383 if( lNegTrackCrossedRowsOverFindable < fTreeVariableLeastRatioCrossedRowsOverFindable )
1384 fTreeVariableLeastRatioCrossedRowsOverFindable = lNegTrackCrossedRowsOverFindable;
1385 //Lowest Cut Level for Ratio Crossed Rows / Findable = 0.8, set here
1386 if ( fTreeVariableLeastRatioCrossedRowsOverFindable < 0.8 ) return kFALSE;
1387 */
1388
1389 return kTRUE;
1390
1391}
b833016c 1392