]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - PWGHF/vertexingHF/AliRDHFCutsLctoV0.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fix in the SetLabelArray of CF for Lc->V0+bachelor (Annalisa)
[u/mrichter/AliRoot.git] / PWGHF / vertexingHF / AliRDHFCutsLctoV0.cxx
... / ...
CommitLineData
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 "AliESDVertex.h"
34#include "AliAODVertex.h"
35#include "AliAODv0.h"
36#include "AliESDv0.h"
37
38using std::cout;
39using std::endl;
40
41ClassImp(AliRDHFCutsLctoV0)
42
43//--------------------------------------------------------------------------
44 AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const char* name, Short_t /*v0channel*/) :
45 AliRDHFCuts(name),
46 fPidSelectionFlag(0),
47 fPidHFV0pos(0),
48 fPidHFV0neg(0),
49 fV0daughtersCuts(0),
50 fV0Type(0)
51{
52 //
53 // Default Constructor
54 //
55
56 const Int_t nvars=10;
57 SetNVars(nvars);
58 TString varNames[nvars]={"inv. mass if K0S [GeV/c2]",
59 "inv. mass if Lambda [GeV/c2]",
60 "inv. mass V0 if K0S [GeV/c2]",
61 "inv. mass V0 if Lambda [GeV/c2]",
62 "pT min bachelor track [GeV/c]",
63 "pT min V0-positive track [GeV/c]",
64 "pT min V0-negative track [GeV/c]",
65 "dca cascade cut [cm]",
66 "dca V0 cut [cm]",
67 "V0 type"
68 };
69
70 Bool_t isUpperCut[nvars]={kTRUE,
71 kTRUE,
72 kTRUE,
73 kTRUE,
74 kFALSE,
75 kFALSE,
76 kFALSE,
77 kTRUE,
78 kTRUE,
79 kTRUE
80 };
81 SetVarNames(nvars,varNames,isUpperCut);
82 Bool_t forOpt[nvars]={kFALSE,
83 kFALSE,
84 kTRUE,
85 kTRUE,
86 kTRUE,
87 kTRUE,
88 kTRUE,
89 kTRUE,
90 kTRUE,
91 kTRUE
92 };
93 SetVarsForOpt(nvars,forOpt); // It was 5: why only 5? And which ones?
94
95 Float_t limits[2]={0,999999999.};
96 SetPtBins(2,limits);
97
98 /*
99 switch (v0channel) {
100 case 0:
101 fV0channel = 0x0001;
102 break;
103 case 1:
104 fV0channel = 0x0002;
105 break;
106 case 2:
107 fV0channel = 0x0004;
108 break;
109 }
110 */
111
112}
113//--------------------------------------------------------------------------
114AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const AliRDHFCutsLctoV0 &source) :
115 AliRDHFCuts(source),
116 fPidSelectionFlag(0),
117 fPidHFV0pos(0),
118 fPidHFV0neg(0),
119 fV0daughtersCuts(0),
120 fV0Type(0)
121 /*
122 fV0channel(source.fV0channel)*/
123{
124 //
125 // Copy constructor
126 //
127
128 if (source.fPidHFV0pos) fPidHFV0pos = new AliAODPidHF(*(source.fPidHFV0pos));
129 else fPidHFV0pos = new AliAODPidHF();
130 if (source.fPidHFV0neg) fPidHFV0neg = new AliAODPidHF(*(source.fPidHFV0neg));
131 else fPidHFV0neg = new AliAODPidHF();
132
133 if (source.fV0daughtersCuts) fV0daughtersCuts = new AliESDtrackCuts(*(source.fV0daughtersCuts));
134 else fV0daughtersCuts = new AliESDtrackCuts();
135
136}
137//--------------------------------------------------------------------------
138AliRDHFCutsLctoV0 &AliRDHFCutsLctoV0::operator=(const AliRDHFCutsLctoV0 &source)
139{
140 //
141 // assignment operator
142 //
143
144 if (this != &source) {
145
146 AliRDHFCuts::operator=(source);
147 fPidSelectionFlag = source.fPidSelectionFlag;
148 delete fPidHFV0pos;
149 fPidHFV0pos = new AliAODPidHF(*(source.fPidHFV0pos));
150 delete fPidHFV0neg;
151 fPidHFV0neg = new AliAODPidHF(*(source.fPidHFV0neg));
152
153 delete fV0daughtersCuts;
154 fV0daughtersCuts = new AliESDtrackCuts(*(source.fV0daughtersCuts));
155
156 fV0Type = source.fV0Type;
157
158 }
159
160 return *this;
161}
162
163
164//---------------------------------------------------------------------------
165AliRDHFCutsLctoV0::~AliRDHFCutsLctoV0() {
166 //
167 // // Default Destructor
168 //
169
170 if (fPidHFV0pos) {
171 delete fPidHFV0pos;
172 fPidHFV0pos=0;
173 }
174 if (fPidHFV0neg) {
175 delete fPidHFV0neg;
176 fPidHFV0neg=0;
177 }
178
179 if (fV0daughtersCuts) {
180 delete fV0daughtersCuts;
181 fV0daughtersCuts=0;
182 }
183
184}
185
186//---------------------------------------------------------------------------
187void AliRDHFCutsLctoV0::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) {
188 //
189 // Fills in vars the values of the variables
190 //
191
192 if (pdgdaughters[0]==-9999) return; // dummy
193
194 if (nvars!=fnVarsForOpt) {
195 printf("AliRDHFCutsLctoV0::GetCutsVarsForOpt: wrong number of variables\n");
196 return;
197 }
198
199 AliAODRecoCascadeHF *dd = (AliAODRecoCascadeHF*)d;
200
201 // Get the v0 and all daughter tracks
202 AliAODTrack *bachelorTrack = (AliAODTrack*)dd->GetBachelor();
203 AliAODv0 *v0 = (AliAODv0*)dd->Getv0();
204 AliAODTrack *v0positiveTrack = (AliAODTrack*)dd->Getv0PositiveTrack();
205 AliAODTrack *v0negativeTrack = (AliAODTrack*)dd->Getv0NegativeTrack();
206
207 Int_t iter=-1;
208 // cut on cascade mass, if K0S + p
209 if (fVarsForOpt[0]) {
210 iter++;
211 vars[iter]=dd->InvMassLctoK0sP();
212 }
213 // cut on cascade mass, if Lambda + pi
214 if (fVarsForOpt[1]) {
215 iter++;
216 vars[iter]=dd->InvMassLctoLambdaPi();
217 }
218
219 // cut on V0 mass if K0S
220 if (fVarsForOpt[2]) {
221 iter++;
222 vars[iter]=v0->MassK0Short();
223 }
224
225 // cut on V0 mass if Lambda
226 // ----------------------------- pb with anti-lambda?? --------->>>>>>>>
227 if (fVarsForOpt[3]) {
228
229 if (bachelorTrack->Charge()==1) {
230 iter++;
231 vars[iter]=v0->MassLambda();
232 } else if (bachelorTrack->Charge()==-1) {
233 iter++;
234 vars[iter]=v0->MassAntiLambda();
235 }
236
237 }
238
239 // cut bachelor min pt
240 if (fVarsForOpt[4]) {
241 iter++;
242 vars[iter]=bachelorTrack->Pt();
243 }
244
245 // cut on V0-positive min pt
246 if (fVarsForOpt[5]) {
247 iter++;
248 vars[iter]=v0positiveTrack->Pt();
249 }
250
251 // cut on V0-negative min pt
252 if (fVarsForOpt[6]) {
253 iter++;
254 vars[iter]=v0negativeTrack->Pt();
255 }
256
257 // cut on cascade dca
258 if (fVarsForOpt[7]) {
259 iter++;
260 vars[iter]=dd->GetDCA(); // prong-to-prong DCA
261 }
262
263 // cut on V0 dca
264 if (fVarsForOpt[8]) {
265 iter++;
266 vars[iter]=v0->GetDCA(); // prong-to-prong DCA
267 }
268
269 return;
270}
271//---------------------------------------------------------------------------
272Int_t AliRDHFCutsLctoV0::IsSelected(TObject* obj,Int_t selectionLevel) {
273 //
274 // Apply selection
275 //
276
277 if (!fCutsRD) {
278 cout<<"Cut matrice not inizialized. Exit..."<<endl;
279 return 0;
280 }
281
282 //PrintAll();
283
284 AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
285 if (!d) {
286 AliDebug(2,"AliAODRecoCascadeHF null");
287 return 0;
288 }
289
290 // Get the bachelor track
291 AliAODTrack *bachelorTrack = (AliAODTrack*)d->GetBachelor();
292 if (!bachelorTrack) {
293 AliDebug(2,"No bachelor object");
294 return 0;
295 }
296
297 // not used
298 //if ( fUseTrackSelectionWithFilterBits &&
299 //!(bachelorTrack->TestFilterMask(BIT(4))) ) return 0;
300
301 // Get V0
302 AliAODv0 *v0 = (AliAODv0*)d->Getv0();
303 if (!v0) {
304 AliDebug(2,"No v0 object");
305 return 0;
306 }
307
308
309
310 // Get the V0 daughter tracks
311 AliAODTrack *v0positiveTrack = (AliAODTrack*)d->Getv0PositiveTrack();
312 AliAODTrack *v0negativeTrack = (AliAODTrack*)d->Getv0NegativeTrack();
313 if (!v0positiveTrack || !v0negativeTrack ) {
314 AliDebug(2,"No V0 daughters' objects");
315 return 0;
316 }
317
318 // selection on daughter tracks
319 if (selectionLevel==AliRDHFCuts::kAll ||
320 selectionLevel==AliRDHFCuts::kTracks) {
321
322 if (fIsCandTrackSPDFirst && d->Pt()<fMaxPtCandTrackSPDFirst) {
323 if (!bachelorTrack->HasPointOnITSLayer(0)) return 0;
324 }
325 if (fTrackCuts && fV0daughtersCuts) {
326 AliAODVertex *vAOD = (AliAODVertex*)d->GetPrimaryVtx();
327 Double_t pos[3]; vAOD->GetXYZ(pos);
328 Double_t cov[6]; vAOD->GetCovarianceMatrix(cov);
329 const AliESDVertex vESD(pos,cov,100.,100);
330 if ( !(IsDaughterSelected(bachelorTrack,&vESD,fTrackCuts)) ||
331 !(IsDaughterSelected(v0negativeTrack,&vESD,fV0daughtersCuts)) ||
332 !(IsDaughterSelected(v0positiveTrack,&vESD,fV0daughtersCuts)) ) return 0;
333 }
334 //if (!AreDaughtersSelected(d)) return 0;
335 }
336
337 Bool_t okLck0sp=kTRUE, okLcLpi=kTRUE, okLcLBarpi=kTRUE;
338 Bool_t okK0spipi=kTRUE, okLppi=kTRUE, okLBarpip=kTRUE;
339
340 // selection on candidate
341 if (selectionLevel==AliRDHFCuts::kAll ||
342 selectionLevel==AliRDHFCuts::kCandidate) {
343
344 Double_t pt = d->Pt();
345 Int_t ptbin = PtBin(pt);
346
347 Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
348 Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
349 Double_t mLPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
350
351 // K0S + p
352 Double_t mk0s = v0->MassK0Short();
353 Double_t mLck0sp = d->InvMassLctoK0sP();
354
355 // Lambda + pi
356 Double_t mlambda = v0->MassLambda();
357 Double_t malambda = v0->MassAntiLambda();
358 Double_t mLcLpi = d->InvMassLctoLambdaPi();
359
360 // cut on Lc mass with K0S+p hypothesis
361 if (TMath::Abs(mLck0sp-mLcPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) {
362 okLck0sp = kFALSE;
363 AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to Lambda_c into K0S+p cut",mLck0sp));
364 }
365
366 // cuts on the V0 mass: K0S case
367 if (TMath::Abs(mk0s-mk0sPDG)>fCutsRD[GetGlobalIndex(2,ptbin)]) {
368 okK0spipi = kFALSE;
369 AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to K0S cut",mk0s));
370 }
371
372 // cut on Lc mass with Lambda+pi hypothesis
373 if (TMath::Abs(mLcLpi-mLcPDG)>fCutsRD[GetGlobalIndex(1,ptbin)]) {
374 okLcLpi = kFALSE;
375 okLcLBarpi = kFALSE;
376 AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to Lambda_c into Lambda+pi cut",mLcLpi));
377 }
378
379 // cuts on the V0 mass: Lambda/LambdaBar case
380 if ( TMath::Abs(mlambda-mLPDG)>fCutsRD[GetGlobalIndex(3,ptbin)] ) {
381 okLppi = kFALSE;
382 AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to LambdaBar cut",mlambda));
383 }
384
385 if ( TMath::Abs(malambda-mLPDG)>fCutsRD[GetGlobalIndex(3,ptbin)] ) {
386 okLBarpip = kFALSE;
387 AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to LambdaBar cut",malambda));
388 }
389
390 okLck0sp = okLck0sp && okK0spipi;
391 okLcLpi = okLcLpi && okLppi;
392 okLcLBarpi = okLcLBarpi && okLBarpip;
393
394 if (!okLck0sp && !okLcLpi && !okLcLBarpi) return 0;
395
396 // cuts on the minimum pt of the tracks
397 if (TMath::Abs(bachelorTrack->Pt()) < fCutsRD[GetGlobalIndex(4,ptbin)]) {
398 AliDebug(4,Form(" bachelor track Pt=%2.2e > %2.2e",bachelorTrack->Pt(),fCutsRD[GetGlobalIndex(4,ptbin)]));
399 return 0;
400 }
401 if (TMath::Abs(v0positiveTrack->Pt()) < fCutsRD[GetGlobalIndex(5,ptbin)]) {
402 AliDebug(4,Form(" V0-positive track Pt=%2.2e > %2.2e",v0positiveTrack->Pt(),fCutsRD[GetGlobalIndex(5,ptbin)]));
403 return 0;
404 }
405 if (TMath::Abs(v0negativeTrack->Pt()) < fCutsRD[GetGlobalIndex(6,ptbin)]) {
406 AliDebug(4,Form(" V0-negative track Pt=%2.2e > %2.2e",v0negativeTrack->Pt(),fCutsRD[GetGlobalIndex(6,ptbin)]));
407 return 0;
408 }
409
410 // cut on cascade dca
411 //if (TMath::Abs(d->GetDCA()) > fCutsRD[GetGlobalIndex(7,ptbin)]) {
412 if ( TMath::Abs(d->GetDCA()) > fCutsRD[GetGlobalIndex(7,ptbin)] /*|| // prong-to-prong DCA
413 TMath::Abs(d->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(7,ptbin)] || // rphi impact params w.r.t. Primary Vtx
414 TMath::Abs(d->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(7,ptbin)]*/ ) { // rphi impact params w.r.t. Primary Vtx
415 AliDebug(4,Form(" cascade tracks DCA don't pass the cut"));
416 return 0;
417 }
418
419 // cut on V0 dca
420 //if (TMath::Abs(v0->DcaV0Daughters()) > fCutsRD[GetGlobalIndex(8,ptbin)]) { // prong-to-prong DCA
421 if ( TMath::Abs(v0->GetDCA()) > fCutsRD[GetGlobalIndex(8,ptbin)] /*|| // prong-to-prong DCA
422 TMath::Abs(v0->DcaV0ToPrimVertex()) > fCutsRD[GetGlobalIndex(8,ptbin)] || // V0-to-vertex DCA
423 TMath::Abs(v0->DcaPosToPrimVertex()) > fCutsRD[GetGlobalIndex(8,ptbin)] || // prong-to-vertex DCA
424 TMath::Abs(v0->DcaNegToPrimVertex()) > fCutsRD[GetGlobalIndex(8,ptbin)]*/ ) { // prong-to-vertex DCA
425 AliDebug(4,Form(" V0 DCA don't pass the cut"));
426 return 0;
427 }
428
429 }
430
431 Int_t returnvalue = okLck0sp+2*okLcLBarpi+4*okLcLpi;
432 /*
433 retvalue case
434 1 Lc->K0S + p
435 2 Lc->LambdaBar + pi
436 3 Lc->K0S + p AND Lc->LambdaBar + pi
437 4 Lc->Lambda + pi
438 5 Lc->K0S + p AND Lc->Lambda + pi
439 6 Lc->LambdaBar + pi AND Lc->Lambda + pi
440 7 Lc->K0S + p AND Lc->LambdaBar + pi AND Lc->Lambda + pi
441 */
442
443 Int_t returnvaluePID = 7;
444
445 // selection on candidate
446 if (selectionLevel==AliRDHFCuts::kAll ||
447 //selectionLevel==AliRDHFCuts::kCandidate ||
448 selectionLevel==AliRDHFCuts::kPID )
449 returnvaluePID = IsSelectedPID(d);
450
451 //if (fUsePID && returnvaluePID==0) return 0;
452
453 Int_t returnvalueTot = 0;
454 if ( fUsePID )
455 returnvalueTot = CombinePIDCuts(returnvalue,returnvaluePID);
456 else
457 returnvalueTot = returnvalue;
458
459 return returnvalueTot;
460
461}
462//---------------------------------------------------------------------------
463Int_t AliRDHFCutsLctoV0::IsSelectedPID(AliAODRecoDecayHF* obj) {
464
465 // fPidHF -> PID object for bachelor
466 // fPidHFV0pos -> PID object for positive V0 daughter
467 // fPidHFV0neg -> PID object for negative V0 daughter
468
469 if (!fUsePID || !obj) return 7; // all hypothesis are valid
470
471 AliAODRecoCascadeHF *objD = (AliAODRecoCascadeHF*)obj;
472
473 Bool_t isPeriodd = fPidHF->GetOnePad();
474 Bool_t isMC = fPidHF->GetMC();
475
476 if (isPeriodd) {
477 fPidHFV0pos->SetOnePad(kTRUE);
478 fPidHFV0neg->SetOnePad(kTRUE);
479 }
480 if (isMC) {
481 fPidHFV0neg->SetMC(kTRUE);
482 fPidHFV0pos->SetMC(kTRUE);
483 }
484
485 AliAODTrack *bachelor = (AliAODTrack*)objD->GetBachelor();
486 AliAODTrack *v0Pos = (AliAODTrack*)objD->Getv0PositiveTrack();
487 AliAODTrack *v0Neg = (AliAODTrack*)objD->Getv0NegativeTrack();
488
489 if (!bachelor || !v0Pos || !v0Neg) return 0;
490
491 Bool_t okLcK0Sp = kTRUE; // K0S case
492 Bool_t okLcLambdaBarPi = kTRUE; // LambdaBar case
493 Bool_t okLcLambdaPi = kTRUE; // Lambda case
494
495 CheckPID(bachelor,v0Neg,v0Pos,okLcK0Sp,okLcLambdaBarPi,okLcLambdaPi);
496
497 Int_t returnvalue = okLcK0Sp+2*okLcLambdaBarPi+4*okLcLambdaPi;
498
499 return returnvalue;
500}
501//-----------------------
502void AliRDHFCutsLctoV0::CheckPID(AliAODTrack *bachelor, AliAODTrack *v0Neg, AliAODTrack *v0Pos,
503 Bool_t &isBachelorID1, Bool_t &isV0NegID2, Bool_t &isV0PosID4) {
504 // identification strategy
505
506 Int_t trackIDtof = -1;
507 Int_t trackIDtpc = -1;
508
509 switch (fPidSelectionFlag) {
510
511 case 0:
512
513 // identify bachelor
514 trackIDtof = fPidHF->ApplyPidTOFRaw(bachelor,4);
515 trackIDtpc = fPidHF->ApplyPidTPCRaw(bachelor,4);
516 AliDebug(1,Form(" fPidHF->ApplyPidTOFRaw(bachelor,4)=%d fPidHF->ApplyPidTPCRaw(bachelor,4)=%d",trackIDtof,trackIDtpc));
517 isBachelorID1 = (trackIDtof==4) && (trackIDtpc==4); // K0S case
518 //Bool_t isBachelorID2 = (fPidHF->ApplyPidTPCRaw(bachelor,2)==2) && (fPidHF->ApplyPidTOFRaw(bachelor,2)==2); // LambdaBar case
519 //Bool_t isBachelorID4 = isBachelorID2; // Lambda case
520
521 // identify V0neg
522 //Bool_t isV0NegID1 = (fPidHFV0neg->ApplyPidTPCRaw(v0Neg,2)==2) && (fPidHFV0neg->ApplyPidTOFRaw(v0Neg,2)==2); // K0S case
523 trackIDtof = fPidHFV0neg->ApplyPidTOFRaw(v0Neg,4);
524 trackIDtpc = fPidHFV0neg->ApplyPidTPCRaw(v0Neg,4);
525 AliDebug(1,Form(" fPidHFV0neg->ApplyPidTOFRaw(v0Neg,4)=%d fPidHFV0neg->ApplyPidTPCRaw(v0Neg,4)=%d",trackIDtof,trackIDtpc));
526 isV0NegID2 = (trackIDtof==4) && (trackIDtpc==4); // LambdaBar case
527 //Bool_t isV0NegID4 = isV0NegID1; // Lambda case
528
529 // identify V0pos
530 //Bool_t isV0PosID1 = (fPidHFV0pos->ApplyPidTPCRaw(v0Pos,2)==2) && (fPidHFV0pos->ApplyPidTOFRaw(v0Pos,2)==2); // K0S case
531 //Bool_t isV0PosID2 = isV0PosID1; // LambdaBar case
532 trackIDtof = fPidHFV0pos->ApplyPidTOFRaw(v0Pos,4);
533 trackIDtpc = fPidHFV0pos->ApplyPidTPCRaw(v0Pos,4);
534 AliDebug(1,Form(" fPidHFV0pos->ApplyPidTOFRaw(v0Pos,4)=%d fPidHFV0pos->ApplyPidTPCRaw(v0POS,4)=%d",trackIDtof,trackIDtpc));
535 isV0PosID4 = (trackIDtof==4) && (trackIDtpc==4); // Lambda case
536
537 break;
538 case 1:
539
540 // identify bachelor
541 trackIDtof = fPidHF->ApplyPidTOFRaw(bachelor,4);
542 trackIDtpc = fPidHF->ApplyPidTPCRaw(bachelor,4);
543 AliDebug(1,Form(" fPidHF->ApplyPidTOFRaw(bachelor,4)=%d fPidHFV0->ApplyPidTPCRaw(bachelor,4)=%d",trackIDtof,trackIDtpc));
544 isBachelorID1 = ( trackIDtof==4 );
545 Bool_t dummy1 = ( !(fPidHF->CheckTOFPIDStatus(bachelor)) && (trackIDtpc==4) &&
546 fPidHF->IsExcluded(bachelor,2,2.,"TPC") && fPidHF->IsExcluded(bachelor,3,2.,"TPC") ); // K0S case
547 isBachelorID1 = isBachelorID1 || dummy1;
548
549
550 // identify V0neg
551 trackIDtof = fPidHFV0neg->ApplyPidTOFRaw(v0Neg,4);
552 trackIDtpc = fPidHFV0neg->ApplyPidTPCRaw(v0Neg,4);
553 AliDebug(1,Form(" fPidHFV0neg->ApplyPidTOFRaw(v0Neg,4)=%d fPidHFV0neg->ApplyPidTPCRaw(v0Neg,4)=%d",trackIDtof,trackIDtpc));
554 isV0NegID2 = ( trackIDtof==4 );
555 Bool_t dummy2 = ( !(fPidHFV0neg->CheckTOFPIDStatus(v0Neg)) && (trackIDtpc==4) &&
556 fPidHFV0neg->IsExcluded(v0Neg,2,2.,"TPC") && fPidHFV0neg->IsExcluded(v0Neg,3,2.,"TPC") ); // LambdaBar case
557 isV0NegID2 = isV0NegID2 || dummy2;
558
559
560 // identify V0pos
561 trackIDtof = fPidHFV0pos->ApplyPidTOFRaw(v0Pos,4);
562 trackIDtpc = fPidHFV0pos->ApplyPidTPCRaw(v0Pos,4);
563 AliDebug(1,Form(" fPidHFV0pos->ApplyPidTOFRaw(v0Pos,4)=%d fPidHFV0pos->ApplyPidTPCRaw(v0Pos,4)=%d",trackIDtof,trackIDtpc));
564 isV0PosID4 = ( trackIDtof==4 );
565 Bool_t dummy4 = ( !(fPidHFV0pos->CheckTOFPIDStatus(v0Pos)) && (trackIDtpc==4) &&
566 fPidHFV0pos->IsExcluded(v0Pos,2,2.,"TPC") && fPidHFV0pos->IsExcluded(v0Pos,3,2.,"TPC") ); // Lambda case
567 isV0PosID4 = isV0PosID4 || dummy4;
568
569
570 break;
571
572 }
573
574}
575//----------------
576Int_t AliRDHFCutsLctoV0::CombinePIDCuts(Int_t returnvalue, Int_t returnvaluePID) const {
577 // combine PID with topological cuts
578
579 Int_t returnvalueTot=returnvalue&returnvaluePID;
580
581 return returnvalueTot;
582}
583
584//----------------------------------
585Int_t AliRDHFCutsLctoV0::IsSelectedSingleCut(TObject* obj, Int_t selectionLevel, Int_t cutIndex) {
586 //
587 // Apply selection on single cut
588 //
589
590 if (!fCutsRD) {
591 cout<<"Cut matrice not inizialized. Exit..."<<endl;
592 return 0;
593 }
594
595 AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
596 if (!d) {
597 AliDebug(2,"AliAODRecoCascadeHF null");
598 return 0;
599 }
600
601 // Get the v0 and all daughter tracks
602 AliAODTrack *bachelorTrack = (AliAODTrack*)d->GetBachelor();
603 if (!bachelorTrack) {
604 AliDebug(2,"No bachelor object");
605 return 0;
606 }
607
608 // not used
609 //if ( fUseTrackSelectionWithFilterBits &&
610 //!(bachelorTrack->TestFilterMask(BIT(4))) ) return 0;
611
612 AliAODv0 *v0 = (AliAODv0*)d->Getv0();
613 if (!v0) {
614 AliDebug(2,"No v0 object");
615 return 0;
616 }
617
618 // Get the V0 daughter tracks
619 AliAODTrack *v0positiveTrack = (AliAODTrack*)d->Getv0PositiveTrack();
620 AliAODTrack *v0negativeTrack = (AliAODTrack*)d->Getv0NegativeTrack();
621 if (!v0positiveTrack || !v0negativeTrack ) {
622 AliDebug(2,"No V0 daughters' objects");
623 return 0;
624 }
625
626 // selection on daughter tracks
627 if (selectionLevel==AliRDHFCuts::kAll ||
628 selectionLevel==AliRDHFCuts::kTracks) {
629
630 if (fIsCandTrackSPDFirst && d->Pt()<fMaxPtCandTrackSPDFirst) {
631 if (!bachelorTrack->HasPointOnITSLayer(0)) return 0;
632 }
633 if (fTrackCuts && fV0daughtersCuts) {
634 AliAODVertex *vAOD = (AliAODVertex*)d->GetPrimaryVtx();
635 Double_t pos[3]; vAOD->GetXYZ(pos);
636 Double_t cov[6]; vAOD->GetCovarianceMatrix(cov);
637 const AliESDVertex vESD(pos,cov,100.,100);
638 if ( !(IsDaughterSelected(bachelorTrack,&vESD,fTrackCuts)) ||
639 !(IsDaughterSelected(v0negativeTrack,&vESD,fV0daughtersCuts)) ||
640 !(IsDaughterSelected(v0positiveTrack,&vESD,fV0daughtersCuts)) ) return 0;
641 }
642 //if (!AreDaughtersSelected(d)) return 0;
643 }
644
645 Bool_t okLck0sp=kFALSE, okLcLpi=kFALSE, okLcLBarpi=kFALSE;
646
647 // selection on candidate
648 if (selectionLevel==AliRDHFCuts::kAll ||
649 selectionLevel==AliRDHFCuts::kCandidate) {
650
651 Double_t pt = d->Pt();
652 Int_t ptbin = PtBin(pt);
653
654 Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
655 Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
656 Double_t mLPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
657
658 // K0S + p
659 Double_t mk0s = v0->MassK0Short();
660 Double_t mLck0sp = d->InvMassLctoK0sP();
661
662 // Lambda + pi
663 Double_t mlambda = v0->MassLambda();
664 Double_t malambda = v0->MassAntiLambda();
665 Double_t mLcLpi = d->InvMassLctoLambdaPi();
666
667 switch (cutIndex) {
668 case 0:
669 // cut on Lc mass with K0S+p hypothesis
670 okLck0sp = TMath::Abs(mLck0sp-mLcPDG)<=fCutsRD[GetGlobalIndex(0,ptbin)];
671 okLcLpi = kFALSE;
672 okLcLBarpi = kFALSE;
673 break;
674 case 1:
675 // cut on Lc mass with Lambda+pi hypothesis
676 okLck0sp = kFALSE;
677 okLcLpi = TMath::Abs(mLcLpi-mLcPDG)<=fCutsRD[GetGlobalIndex(1,ptbin)];
678 okLcLBarpi = okLcLpi;
679 break;
680 case 2:
681 // cuts on the V0 mass: K0S case
682 okLck0sp = TMath::Abs(mk0s-mk0sPDG)<=fCutsRD[GetGlobalIndex(2,ptbin)];
683 okLcLpi = kFALSE;
684 okLcLBarpi = kFALSE;
685 break;
686 case 3:
687 // cuts on the V0 mass: Lambda/LambdaBar case
688 okLck0sp = kFALSE;
689 okLcLpi = TMath::Abs(mlambda-mLPDG)<=fCutsRD[GetGlobalIndex(3,ptbin)];
690 okLcLBarpi = TMath::Abs(malambda-mLPDG)<=fCutsRD[GetGlobalIndex(3,ptbin)];
691 break;
692 case 4:
693 // cuts on the minimum pt of bachelor
694 okLck0sp = TMath::Abs(bachelorTrack->Pt())>=fCutsRD[GetGlobalIndex(4,ptbin)];
695 okLcLpi = okLck0sp;
696 okLcLBarpi = okLck0sp;
697 break;
698 case 5:
699 // cuts on the minimum pt of positive V0daughter
700 okLck0sp = TMath::Abs(v0positiveTrack->Pt())>=fCutsRD[GetGlobalIndex(5,ptbin)];
701 okLcLpi = okLck0sp;
702 okLcLBarpi = okLck0sp;
703 break;
704 case 6:
705 // cuts on the minimum pt of negative V0daughter
706 okLck0sp = TMath::Abs(v0negativeTrack->Pt())>=fCutsRD[GetGlobalIndex(6,ptbin)];
707 okLcLpi = okLck0sp;
708 okLcLBarpi = okLck0sp;
709 break;
710 case 7:
711 // cut on cascade dca
712 //okLck0sp = TMath::Abs(d->GetDCA(0))<=fCutsRD[GetGlobalIndex(8,ptbin)];
713 okLck0sp = TMath::Abs(d->GetDCA())<=fCutsRD[GetGlobalIndex(7,ptbin)] /*&&
714 TMath::Abs(d->Getd0Prong(0))<=fCutsRD[GetGlobalIndex(7,ptbin)] &&
715 TMath::Abs(d->Getd0Prong(1))<=fCutsRD[GetGlobalIndex(7,ptbin)]*/;
716 okLcLpi = okLck0sp;
717 okLcLBarpi = okLck0sp;
718 break;
719 case 8:
720 // cut on V0 dca
721 //okLck0sp = TMath::Abs(v0->DcaV0Daughters())<=fCutsRD[GetGlobalIndex(7,ptbin)];
722 okLck0sp = TMath::Abs(v0->GetDCA())<=fCutsRD[GetGlobalIndex(8,ptbin)] /*&&
723 TMath::Abs(v0->DcaV0ToPrimVertex())<=fCutsRD[GetGlobalIndex(8,ptbin)] &&
724 TMath::Abs(v0->DcaPosToPrimVertex())<=fCutsRD[GetGlobalIndex(8,ptbin)] &&
725 TMath::Abs(v0->DcaNegToPrimVertex())<=fCutsRD[GetGlobalIndex(8,ptbin)]*/;
726 okLcLpi = okLck0sp;
727 okLcLBarpi = okLck0sp;
728 break;
729 }
730
731 }
732
733 Int_t returnvalue = okLck0sp+2*okLcLBarpi+4*okLcLpi;
734 /*
735 retvalue case
736 1 Lc->K0S + p
737 2 Lc->LambdaBar + pi
738 3 Lc->K0S + p AND Lc->LambdaBar + pi
739 4 Lc->Lambda + pi
740 5 Lc->K0S + p AND Lc->Lambda + pi
741 6 Lc->LambdaBar + pi AND Lc->Lambda + pi
742 7 Lc->K0S + p AND Lc->LambdaBar + pi AND Lc->Lambda + pi
743 */
744
745
746 /*
747 Int_t returnvaluePID = 7;
748
749 // selection on PID
750 if (selectionLevel==AliRDHFCuts::kAll ||
751 //selectionLevel==AliRDHFCuts::kCandidate ||
752 selectionLevel==AliRDHFCuts::kPID )
753 returnvaluePID = IsSelectedPID(d);
754 */
755
756 Int_t returnvalueTot = 0;
757 //if ( fUsePID )
758 //returnvalueTot = CombinePIDCuts(returnvalue,returnvaluePID);
759 //else
760 returnvalueTot = returnvalue;
761
762 return returnvalueTot;
763
764}
765//----------------------------------
766void AliRDHFCutsLctoV0::SetStandardCutsPP2010() {
767
768 SetName("LctoV0ProductionCuts");
769 SetTitle("Production cuts for Lc->V0+bachelor analysis");
770
771 AliESDtrackCuts* esdTrackCuts=new AliESDtrackCuts();
772 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
773 //default
774 esdTrackCuts->SetRequireTPCRefit(kTRUE);
775 esdTrackCuts->SetRequireITSRefit(kTRUE);
776 esdTrackCuts->SetMinNClustersITS(0);//(4); // default is 5
777 esdTrackCuts->SetMinNClustersTPC(70);
778 //esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
779 // AliESDtrackCuts::kAny);
780 // default is kBoth, otherwise kAny
781 esdTrackCuts->SetMinDCAToVertexXY(0.);
782 esdTrackCuts->SetPtRange(0.3,1.e10);
783 //esdTrackCuts->SetEtaRange(-0.8,+0.8);
784 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
785 AddTrackCuts(esdTrackCuts);
786
787
788 AliESDtrackCuts* esdTrackCutsV0daughters=new AliESDtrackCuts();
789 esdTrackCutsV0daughters->SetRequireSigmaToVertex(kFALSE);
790 //default
791 esdTrackCutsV0daughters->SetRequireTPCRefit(kTRUE);
792 esdTrackCutsV0daughters->SetRequireITSRefit(kFALSE);//(kTRUE);
793 esdTrackCutsV0daughters->SetMinNClustersITS(0);//(4); // default is 5
794 esdTrackCutsV0daughters->SetMinNClustersTPC(70);
795 //esdTrackCutsV0daughters->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
796 // AliESDtrackCuts::kAny);
797 // default is kBoth, otherwise kAny
798 esdTrackCutsV0daughters->SetMinDCAToVertexXY(0.);
799 esdTrackCutsV0daughters->SetPtRange(0.,1.e10);
800 esdTrackCutsV0daughters->SetAcceptKinkDaughters(kFALSE);
801 AddTrackCutsV0daughters(esdTrackCutsV0daughters);
802
803 const Int_t nptbins=1;
804 Float_t* ptbins;
805 ptbins=new Float_t[nptbins+1];
806 ptbins[0]=0.;
807 ptbins[1]=99999999.;
808
809 SetPtBins(nptbins+1,ptbins);
810 SetPtBins(nptbins+1,ptbins);
811
812 const Int_t nvars=9 ;
813
814 Float_t** prodcutsval;
815 prodcutsval=new Float_t*[nvars];
816 for(Int_t ic=0;ic<nvars;ic++){prodcutsval[ic]=new Float_t[nptbins];}
817 for(Int_t ipt2=0;ipt2<nptbins;ipt2++){
818 prodcutsval[0][ipt2]=1.; // inv. mass if K0S [GeV/c2]
819 prodcutsval[1][ipt2]=1.; // inv. mass if Lambda [GeV/c2]
820 prodcutsval[2][ipt2]=0.05; // inv. mass V0 if K0S [GeV/c2]
821 prodcutsval[3][ipt2]=0.05; // inv. mass V0 if Lambda [GeV/c2]
822 prodcutsval[4][ipt2]=0.3; // pT min bachelor track [GeV/c] // AOD by construction
823 prodcutsval[5][ipt2]=0.; // pT min V0-positive track [GeV/c]
824 prodcutsval[6][ipt2]=0.; // pT min V0-negative track [GeV/c]
825 prodcutsval[7][ipt2]=1000.; // dca cascade cut [cm]
826 prodcutsval[8][ipt2]=1000.; // dca V0 cut [nSigma] // it's 1.5 x offline V0s
827 }
828 SetCuts(nvars,nptbins,prodcutsval);
829
830 SetGlobalIndex(nvars,nptbins);
831 SetPtBins(nptbins+1,ptbins);
832
833
834 //pid settings
835 //1. bachelor: default one
836 AliAODPidHF* pidObjBachelor = new AliAODPidHF();
837 Double_t sigmasBac[5]={3.,1.,1.,3.,3.}; // 0, 1(A), 2(A) -> TPC; 3 -> TOF; 4 -> ITS
838 pidObjBachelor->SetSigma(sigmasBac);
839 pidObjBachelor->SetAsym(kFALSE);
840 pidObjBachelor->SetMatch(1);
841 pidObjBachelor->SetTPC(kTRUE);
842 pidObjBachelor->SetTOF(kTRUE);
843 pidObjBachelor->SetTOFdecide(kFALSE);
844 SetPidHF(pidObjBachelor);
845
846 //2. V0pos
847 AliAODPidHF* pidObjV0pos = new AliAODPidHF();
848 Double_t sigmasV0pos[5]={3.,1.,1.,3.,3.}; // 0, 1(A), 2(A) -> TPC; 3 -> TOF; 4 -> ITS
849 pidObjV0pos->SetSigma(sigmasV0pos);
850 pidObjV0pos->SetAsym(kFALSE);
851 pidObjV0pos->SetMatch(1);
852 pidObjV0pos->SetTPC(kTRUE);
853 pidObjV0pos->SetTOF(kTRUE);
854 pidObjV0pos->SetTOFdecide(kFALSE);
855 SetPidV0pos(pidObjV0pos);
856
857 //2. V0neg
858 AliAODPidHF* pidObjV0neg = new AliAODPidHF();
859 Double_t sigmasV0neg[5]={3.,1.,1.,3.,3.}; // 0, 1(A), 2(A) -> TPC; 3 -> TOF; 4 -> ITS
860 pidObjV0neg->SetSigma(sigmasV0neg);
861 pidObjV0neg->SetAsym(kFALSE);
862 pidObjV0neg->SetMatch(1);
863 pidObjV0neg->SetTPC(kTRUE);
864 pidObjV0neg->SetTOF(kTRUE);
865 pidObjV0neg->SetTOFdecide(kFALSE);
866 SetPidV0neg(pidObjV0neg);
867
868 SetUsePID(kFALSE);//(kTRUE);
869
870 PrintAll();
871
872 for(Int_t iiv=0;iiv<nvars;iiv++){
873 delete [] prodcutsval[iiv];
874 }
875 delete [] prodcutsval;
876 prodcutsval=NULL;
877 delete [] ptbins;
878 ptbins=NULL;
879
880
881 delete pidObjBachelor;
882 pidObjBachelor=NULL;
883
884 delete pidObjV0pos;
885 pidObjV0pos=NULL;
886
887 delete pidObjV0neg;
888 pidObjV0neg=NULL;
889
890 return;
891}
892//------------------
893void AliRDHFCutsLctoV0::SetStandardCutsPbPb2010() {
894
895 SetName("LctoV0ProductionCuts");
896 SetTitle("Production cuts for Lc->V0+bachelor analysis");
897
898 SetStandardCutsPP2010();
899
900 return;
901}
902//------------------
903void AliRDHFCutsLctoV0::SetStandardCutsPbPb2011() {
904
905 // Default 2010 PbPb cut object
906 SetStandardCutsPbPb2010();
907
908 //
909 // Enable all 2011 PbPb run triggers
910 //
911 SetTriggerClass("");
912 ResetMaskAndEnableMBTrigger();
913 EnableCentralTrigger();
914 EnableSemiCentralTrigger();
915
916}
917//-----------------------
918Int_t AliRDHFCutsLctoV0::GetV0Type(){
919
920 const Int_t nvars = this->GetNVars() ;
921 //Float_t *vArray =GetCuts();
922 //fV0Type = vArray[nvars-1];
923 fV0Type = (this->GetCuts())[nvars-1];
924 //this->GetCuts(vArray);
925 TString *sVarNames=GetVarNames();
926
927 if(sVarNames[nvars-1].Contains("V0 type")) return (Int_t)fV0Type;
928 else {AliInfo("AliRDHFCutsLctoV0 Last variable is not the Vo type!!!"); return -999;}
929}