]> 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
Fix in the computetion of <pt>
[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
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"
e7af8919 33#include "AliESDVertex.h"
34#include "AliAODVertex.h"
a07ad8e0 35#include "AliAODv0.h"
36#include "AliESDv0.h"
37
c64cb1f6 38using std::cout;
39using std::endl;
40
a07ad8e0 41ClassImp(AliRDHFCutsLctoV0)
42
43//--------------------------------------------------------------------------
34595b3c 44 AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const char* name, Short_t /*v0channel*/) :
992ba7d8 45 AliRDHFCuts(name),
e7af8919 46 fPidSelectionFlag(0),
47 fPidHFV0pos(0),
48 fPidHFV0neg(0),
34595b3c 49 fV0daughtersCuts(0),
50 fV0Type(0)
a07ad8e0 51{
52 //
53 // Default Constructor
54 //
992ba7d8 55
34595b3c 56 const Int_t nvars=10;
a07ad8e0 57 SetNVars(nvars);
34595b3c 58 TString varNames[nvars]={"inv. mass if K0S [GeV/c2]",
992ba7d8 59 "inv. mass if Lambda [GeV/c2]",
60 "inv. mass V0 if K0S [GeV/c2]",
61 "inv. mass V0 if Lambda [GeV/c2]",
a07ad8e0 62 "pT min bachelor track [GeV/c]",
63 "pT min V0-positive track [GeV/c]",
64 "pT min V0-negative track [GeV/c]",
992ba7d8 65 "dca cascade cut [cm]",
34595b3c 66 "dca V0 cut [cm]",
67 "V0 type"
68 };
a07ad8e0 69
34595b3c 70 Bool_t isUpperCut[nvars]={kTRUE,
71 kTRUE,
72 kTRUE,
a07ad8e0 73 kTRUE,
74 kFALSE,
75 kFALSE,
76 kFALSE,
77 kTRUE,
34595b3c 78 kTRUE,
79 kTRUE
80 };
a07ad8e0 81 SetVarNames(nvars,varNames,isUpperCut);
34595b3c 82 Bool_t forOpt[nvars]={kFALSE,
a07ad8e0 83 kFALSE,
992ba7d8 84 kTRUE,
85 kTRUE,
86 kTRUE,
87 kTRUE,
88 kTRUE,
89 kTRUE,
34595b3c 90 kTRUE,
91 kTRUE
92 };
93 SetVarsForOpt(nvars,forOpt); // It was 5: why only 5? And which ones?
992ba7d8 94
a07ad8e0 95 Float_t limits[2]={0,999999999.};
96 SetPtBins(2,limits);
992ba7d8 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
a07ad8e0 112}
113//--------------------------------------------------------------------------
114AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const AliRDHFCutsLctoV0 &source) :
992ba7d8 115 AliRDHFCuts(source),
e7af8919 116 fPidSelectionFlag(0),
117 fPidHFV0pos(0),
118 fPidHFV0neg(0),
34595b3c 119 fV0daughtersCuts(0),
120 fV0Type(0)
121 /*
e7af8919 122 fV0channel(source.fV0channel)*/
a07ad8e0 123{
124 //
125 // Copy constructor
126 //
127
e7af8919 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
a07ad8e0 136}
137//--------------------------------------------------------------------------
138AliRDHFCutsLctoV0 &AliRDHFCutsLctoV0::operator=(const AliRDHFCutsLctoV0 &source)
139{
140 //
141 // assignment operator
142 //
a07ad8e0 143
992ba7d8 144 if (this != &source) {
145
146 AliRDHFCuts::operator=(source);
e7af8919 147 fPidSelectionFlag = source.fPidSelectionFlag;
992ba7d8 148 delete fPidHFV0pos;
149 fPidHFV0pos = new AliAODPidHF(*(source.fPidHFV0pos));
150 delete fPidHFV0neg;
151 fPidHFV0neg = new AliAODPidHF(*(source.fPidHFV0neg));
152
e7af8919 153 delete fV0daughtersCuts;
154 fV0daughtersCuts = new AliESDtrackCuts(*(source.fV0daughtersCuts));
155
34595b3c 156 fV0Type = source.fV0Type;
992ba7d8 157
158 }
a07ad8e0 159
160 return *this;
161}
162
163
992ba7d8 164//---------------------------------------------------------------------------
165AliRDHFCutsLctoV0::~AliRDHFCutsLctoV0() {
166 //
167 // // Default Destructor
34595b3c 168 //
992ba7d8 169
170 if (fPidHFV0pos) {
171 delete fPidHFV0pos;
172 fPidHFV0pos=0;
173 }
174 if (fPidHFV0neg) {
175 delete fPidHFV0neg;
176 fPidHFV0neg=0;
177 }
178
e7af8919 179 if (fV0daughtersCuts) {
180 delete fV0daughtersCuts;
181 fV0daughtersCuts=0;
182 }
183
992ba7d8 184}
185
a07ad8e0 186//---------------------------------------------------------------------------
187void AliRDHFCutsLctoV0::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) {
34595b3c 188 //
189 // Fills in vars the values of the variables
a07ad8e0 190 //
e654189e 191
992ba7d8 192 if (pdgdaughters[0]==-9999) return; // dummy
a07ad8e0 193
992ba7d8 194 if (nvars!=fnVarsForOpt) {
a07ad8e0 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
992ba7d8 202 AliAODTrack *bachelorTrack = (AliAODTrack*)dd->GetBachelor();
203 AliAODv0 *v0 = (AliAODv0*)dd->Getv0();
204 AliAODTrack *v0positiveTrack = (AliAODTrack*)dd->Getv0PositiveTrack();
34595b3c 205 AliAODTrack *v0negativeTrack = (AliAODTrack*)dd->Getv0NegativeTrack();
a07ad8e0 206
207 Int_t iter=-1;
992ba7d8 208 // cut on cascade mass, if K0S + p
209 if (fVarsForOpt[0]) {
a07ad8e0 210 iter++;
211 vars[iter]=dd->InvMassLctoK0sP();
212 }
992ba7d8 213 // cut on cascade mass, if Lambda + pi
214 if (fVarsForOpt[1]) {
a07ad8e0 215 iter++;
216 vars[iter]=dd->InvMassLctoLambdaPi();
217 }
218
992ba7d8 219 // cut on V0 mass if K0S
220 if (fVarsForOpt[2]) {
a07ad8e0 221 iter++;
222 vars[iter]=v0->MassK0Short();
223 }
224
992ba7d8 225 // cut on V0 mass if Lambda
a07ad8e0 226 // ----------------------------- pb with anti-lambda?? --------->>>>>>>>
992ba7d8 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 }
a07ad8e0 236
a07ad8e0 237 }
238
992ba7d8 239 // cut bachelor min pt
240 if (fVarsForOpt[4]) {
a07ad8e0 241 iter++;
992ba7d8 242 vars[iter]=bachelorTrack->Pt();
a07ad8e0 243 }
244
992ba7d8 245 // cut on V0-positive min pt
246 if (fVarsForOpt[5]) {
a07ad8e0 247 iter++;
992ba7d8 248 vars[iter]=v0positiveTrack->Pt();
a07ad8e0 249 }
250
992ba7d8 251 // cut on V0-negative min pt
252 if (fVarsForOpt[6]) {
a07ad8e0 253 iter++;
992ba7d8 254 vars[iter]=v0negativeTrack->Pt();
a07ad8e0 255 }
256
257 // cut on cascade dca
992ba7d8 258 if (fVarsForOpt[7]) {
259 iter++;
260 vars[iter]=dd->GetDCA(); // prong-to-prong DCA
261 }
34595b3c 262
992ba7d8 263 // cut on V0 dca
264 if (fVarsForOpt[8]) {
a07ad8e0 265 iter++;
992ba7d8 266 vars[iter]=v0->GetDCA(); // prong-to-prong DCA
a07ad8e0 267 }
268
269 return;
270}
271//---------------------------------------------------------------------------
272Int_t AliRDHFCutsLctoV0::IsSelected(TObject* obj,Int_t selectionLevel) {
273 //
274 // Apply selection
275 //
276
992ba7d8 277 if (!fCutsRD) {
a07ad8e0 278 cout<<"Cut matrice not inizialized. Exit..."<<endl;
279 return 0;
280 }
992ba7d8 281
a07ad8e0 282 //PrintAll();
a07ad8e0 283
992ba7d8 284 AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
285 if (!d) {
e7af8919 286 AliDebug(2,"AliAODRecoCascadeHF null");
a07ad8e0 287 return 0;
288 }
289
992ba7d8 290 // Get the bachelor track
291 AliAODTrack *bachelorTrack = (AliAODTrack*)d->GetBachelor();
e7af8919 292 if (!bachelorTrack) {
293 AliDebug(2,"No bachelor object");
294 return 0;
295 }
0dbd1d4f 296
297 // not used
298 //if ( fUseTrackSelectionWithFilterBits &&
299 //!(bachelorTrack->TestFilterMask(BIT(4))) ) return 0;
a07ad8e0 300
e7af8919 301 // Get V0
992ba7d8 302 AliAODv0 *v0 = (AliAODv0*)d->Getv0();
e7af8919 303 if (!v0) {
304 AliDebug(2,"No v0 object");
305 return 0;
306 }
307
34595b3c 308
309
e7af8919 310 // Get the V0 daughter tracks
992ba7d8 311 AliAODTrack *v0positiveTrack = (AliAODTrack*)d->Getv0PositiveTrack();
34595b3c 312 AliAODTrack *v0negativeTrack = (AliAODTrack*)d->Getv0NegativeTrack();
e7af8919 313 if (!v0positiveTrack || !v0negativeTrack ) {
314 AliDebug(2,"No V0 daughters' objects");
992ba7d8 315 return 0;
316 }
a07ad8e0 317
34595b3c 318 // selection on daughter tracks
319 if (selectionLevel==AliRDHFCuts::kAll ||
e7af8919 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 }
0dbd1d4f 334 //if (!AreDaughtersSelected(d)) return 0;
e7af8919 335 }
336
992ba7d8 337 Bool_t okLck0sp=kTRUE, okLcLpi=kTRUE, okLcLBarpi=kTRUE;
338 Bool_t okK0spipi=kTRUE, okLppi=kTRUE, okLBarpip=kTRUE;
a07ad8e0 339
340 // selection on candidate
34595b3c 341 if (selectionLevel==AliRDHFCuts::kAll ||
992ba7d8 342 selectionLevel==AliRDHFCuts::kCandidate) {
a07ad8e0 343
992ba7d8 344 Double_t pt = d->Pt();
992ba7d8 345 Int_t ptbin = PtBin(pt);
34595b3c 346
0dbd1d4f 347 Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
a07ad8e0 348 Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
0dbd1d4f 349 Double_t mLPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
a07ad8e0 350
992ba7d8 351 // K0S + p
0dbd1d4f 352 Double_t mk0s = v0->MassK0Short();
992ba7d8 353 Double_t mLck0sp = d->InvMassLctoK0sP();
0dbd1d4f 354
34595b3c 355 // Lambda + pi
0dbd1d4f 356 Double_t mlambda = v0->MassLambda();
357 Double_t malambda = v0->MassAntiLambda();
358 Double_t mLcLpi = d->InvMassLctoLambdaPi();
359
992ba7d8 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 }
a07ad8e0 365
992ba7d8 366 // cuts on the V0 mass: K0S case
34595b3c 367 if (TMath::Abs(mk0s-mk0sPDG)>fCutsRD[GetGlobalIndex(2,ptbin)]) {
0dbd1d4f 368 okK0spipi = kFALSE;
992ba7d8 369 AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to K0S cut",mk0s));
a07ad8e0 370 }
992ba7d8 371
992ba7d8 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));
a07ad8e0 377 }
378
992ba7d8 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));
a07ad8e0 383 }
992ba7d8 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));
a07ad8e0 388 }
389
992ba7d8 390 okLck0sp = okLck0sp && okK0spipi;
391 okLcLpi = okLcLpi && okLppi;
392 okLcLBarpi = okLcLBarpi && okLBarpip;
393
394 if (!okLck0sp && !okLcLpi && !okLcLBarpi) return 0;
a07ad8e0 395
34595b3c 396 // cuts on the minimum pt of the tracks
992ba7d8 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)]));
a07ad8e0 399 return 0;
400 }
992ba7d8 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)]));
a07ad8e0 403 return 0;
404 }
992ba7d8 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)]));
a07ad8e0 407 return 0;
408 }
409
992ba7d8 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"));
a07ad8e0 416 return 0;
417 }
418
992ba7d8 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"));
a07ad8e0 426 return 0;
427 }
428
992ba7d8 429 }
a07ad8e0 430
992ba7d8 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
0dbd1d4f 443 Int_t returnvaluePID = 7;
444
445 // selection on candidate
34595b3c 446 if (selectionLevel==AliRDHFCuts::kAll ||
447 //selectionLevel==AliRDHFCuts::kCandidate ||
0dbd1d4f 448 selectionLevel==AliRDHFCuts::kPID )
449 returnvaluePID = IsSelectedPID(d);
450
451 //if (fUsePID && returnvaluePID==0) return 0;
452
992ba7d8 453 Int_t returnvalueTot = 0;
e7af8919 454 if ( fUsePID )
992ba7d8 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);
a07ad8e0 483 }
484
992ba7d8 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
e7af8919 491 Bool_t okLcK0Sp = kTRUE; // K0S case
492 Bool_t okLcLambdaBarPi = kTRUE; // LambdaBar case
493 Bool_t okLcLambdaPi = kTRUE; // Lambda case
992ba7d8 494
e7af8919 495 CheckPID(bachelor,v0Neg,v0Pos,okLcK0Sp,okLcLambdaBarPi,okLcLambdaPi);
992ba7d8 496
497 Int_t returnvalue = okLcK0Sp+2*okLcLambdaBarPi+4*okLcLambdaPi;
498
a07ad8e0 499 return returnvalue;
500}
992ba7d8 501//-----------------------
e7af8919 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;
992ba7d8 508
e7af8919 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
0dbd1d4f 518 //Bool_t isBachelorID2 = (fPidHF->ApplyPidTPCRaw(bachelor,2)==2) && (fPidHF->ApplyPidTOFRaw(bachelor,2)==2); // LambdaBar case
e7af8919 519 //Bool_t isBachelorID4 = isBachelorID2; // Lambda case
520
521 // identify V0neg
0dbd1d4f 522 //Bool_t isV0NegID1 = (fPidHFV0neg->ApplyPidTPCRaw(v0Neg,2)==2) && (fPidHFV0neg->ApplyPidTOFRaw(v0Neg,2)==2); // K0S case
e7af8919 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
0dbd1d4f 530 //Bool_t isV0PosID1 = (fPidHFV0pos->ApplyPidTPCRaw(v0Pos,2)==2) && (fPidHFV0pos->ApplyPidTOFRaw(v0Pos,2)==2); // K0S case
e7af8919 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
0dbd1d4f 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
e7af8919 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
e7af8919 570 break;
571
572 }
573
574}
575//----------------
992ba7d8 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//----------------------------------
0dbd1d4f 585Int_t AliRDHFCutsLctoV0::IsSelectedSingleCut(TObject* obj, Int_t selectionLevel, Int_t cutIndex) {
992ba7d8 586 //
0dbd1d4f 587 // Apply selection on single cut
992ba7d8 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) {
0dbd1d4f 597 AliDebug(2,"AliAODRecoCascadeHF null");
992ba7d8 598 return 0;
599 }
600
992ba7d8 601 // Get the v0 and all daughter tracks
602 AliAODTrack *bachelorTrack = (AliAODTrack*)d->GetBachelor();
0dbd1d4f 603 if (!bachelorTrack) {
604 AliDebug(2,"No bachelor object");
605 return 0;
606 }
607
608 // not used
34595b3c 609 //if ( fUseTrackSelectionWithFilterBits &&
0dbd1d4f 610 //!(bachelorTrack->TestFilterMask(BIT(4))) ) return 0;
992ba7d8 611
612 AliAODv0 *v0 = (AliAODv0*)d->Getv0();
0dbd1d4f 613 if (!v0) {
614 AliDebug(2,"No v0 object");
615 return 0;
616 }
617
618 // Get the V0 daughter tracks
992ba7d8 619 AliAODTrack *v0positiveTrack = (AliAODTrack*)d->Getv0PositiveTrack();
34595b3c 620 AliAODTrack *v0negativeTrack = (AliAODTrack*)d->Getv0NegativeTrack();
0dbd1d4f 621 if (!v0positiveTrack || !v0negativeTrack ) {
622 AliDebug(2,"No V0 daughters' objects");
992ba7d8 623 return 0;
624 }
625
34595b3c 626 // selection on daughter tracks
627 if (selectionLevel==AliRDHFCuts::kAll ||
0dbd1d4f 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 }
992ba7d8 644
645 Bool_t okLck0sp=kFALSE, okLcLpi=kFALSE, okLcLBarpi=kFALSE;
646
647 // selection on candidate
34595b3c 648 if (selectionLevel==AliRDHFCuts::kAll ||
992ba7d8 649 selectionLevel==AliRDHFCuts::kCandidate) {
650
0dbd1d4f 651 Double_t pt = d->Pt();
652 Int_t ptbin = PtBin(pt);
653
654 Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
992ba7d8 655 Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
0dbd1d4f 656 Double_t mLPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
992ba7d8 657
0dbd1d4f 658 // K0S + p
992ba7d8 659 Double_t mk0s = v0->MassK0Short();
660 Double_t mLck0sp = d->InvMassLctoK0sP();
661
34595b3c 662 // Lambda + pi
992ba7d8 663 Double_t mlambda = v0->MassLambda();
664 Double_t malambda = v0->MassAntiLambda();
665 Double_t mLcLpi = d->InvMassLctoLambdaPi();
666
992ba7d8 667 switch (cutIndex) {
668 case 0:
0dbd1d4f 669 // cut on Lc mass with K0S+p hypothesis
992ba7d8 670 okLck0sp = TMath::Abs(mLck0sp-mLcPDG)<=fCutsRD[GetGlobalIndex(0,ptbin)];
671 okLcLpi = kFALSE;
672 okLcLBarpi = kFALSE;
673 break;
674 case 1:
0dbd1d4f 675 // cut on Lc mass with Lambda+pi hypothesis
992ba7d8 676 okLck0sp = kFALSE;
677 okLcLpi = TMath::Abs(mLcLpi-mLcPDG)<=fCutsRD[GetGlobalIndex(1,ptbin)];
678 okLcLBarpi = okLcLpi;
679 break;
680 case 2:
0dbd1d4f 681 // cuts on the V0 mass: K0S case
992ba7d8 682 okLck0sp = TMath::Abs(mk0s-mk0sPDG)<=fCutsRD[GetGlobalIndex(2,ptbin)];
683 okLcLpi = kFALSE;
684 okLcLBarpi = kFALSE;
685 break;
686 case 3:
0dbd1d4f 687 // cuts on the V0 mass: Lambda/LambdaBar case
992ba7d8 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:
0dbd1d4f 693 // cuts on the minimum pt of bachelor
992ba7d8 694 okLck0sp = TMath::Abs(bachelorTrack->Pt())>=fCutsRD[GetGlobalIndex(4,ptbin)];
695 okLcLpi = okLck0sp;
696 okLcLBarpi = okLck0sp;
697 break;
698 case 5:
0dbd1d4f 699 // cuts on the minimum pt of positive V0daughter
992ba7d8 700 okLck0sp = TMath::Abs(v0positiveTrack->Pt())>=fCutsRD[GetGlobalIndex(5,ptbin)];
701 okLcLpi = okLck0sp;
702 okLcLBarpi = okLck0sp;
703 break;
704 case 6:
0dbd1d4f 705 // cuts on the minimum pt of negative V0daughter
992ba7d8 706 okLck0sp = TMath::Abs(v0negativeTrack->Pt())>=fCutsRD[GetGlobalIndex(6,ptbin)];
707 okLcLpi = okLck0sp;
708 okLcLBarpi = okLck0sp;
709 break;
710 case 7:
0dbd1d4f 711 // cut on cascade dca
992ba7d8 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:
0dbd1d4f 720 // cut on V0 dca
992ba7d8 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
0dbd1d4f 746 /*
992ba7d8 747 Int_t returnvaluePID = 7;
748
749 // selection on PID
34595b3c 750 if (selectionLevel==AliRDHFCuts::kAll ||
751 //selectionLevel==AliRDHFCuts::kCandidate ||
e7af8919 752 selectionLevel==AliRDHFCuts::kPID )
992ba7d8 753 returnvaluePID = IsSelectedPID(d);
0dbd1d4f 754 */
992ba7d8 755
0dbd1d4f 756 Int_t returnvalueTot = 0;
757 //if ( fUsePID )
758 //returnvalueTot = CombinePIDCuts(returnvalue,returnvaluePID);
759 //else
760 returnvalueTot = returnvalue;
992ba7d8 761
762 return returnvalueTot;
763
764}
e7af8919 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);
0dbd1d4f 776 esdTrackCuts->SetMinNClustersITS(0);//(4); // default is 5
e7af8919 777 esdTrackCuts->SetMinNClustersTPC(70);
0dbd1d4f 778 //esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
34595b3c 779 // AliESDtrackCuts::kAny);
e7af8919 780 // default is kBoth, otherwise kAny
781 esdTrackCuts->SetMinDCAToVertexXY(0.);
782 esdTrackCuts->SetPtRange(0.3,1.e10);
0dbd1d4f 783 //esdTrackCuts->SetEtaRange(-0.8,+0.8);
784 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
e7af8919 785 AddTrackCuts(esdTrackCuts);
786
787
788 AliESDtrackCuts* esdTrackCutsV0daughters=new AliESDtrackCuts();
789 esdTrackCutsV0daughters->SetRequireSigmaToVertex(kFALSE);
790 //default
791 esdTrackCutsV0daughters->SetRequireTPCRefit(kTRUE);
0dbd1d4f 792 esdTrackCutsV0daughters->SetRequireITSRefit(kFALSE);//(kTRUE);
793 esdTrackCutsV0daughters->SetMinNClustersITS(0);//(4); // default is 5
e7af8919 794 esdTrackCutsV0daughters->SetMinNClustersTPC(70);
0dbd1d4f 795 //esdTrackCutsV0daughters->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
34595b3c 796 // AliESDtrackCuts::kAny);
e7af8919 797 // default is kBoth, otherwise kAny
798 esdTrackCutsV0daughters->SetMinDCAToVertexXY(0.);
799 esdTrackCutsV0daughters->SetPtRange(0.,1.e10);
0dbd1d4f 800 esdTrackCutsV0daughters->SetAcceptKinkDaughters(kFALSE);
e7af8919 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 }
0dbd1d4f 828 SetCuts(nvars,nptbins,prodcutsval);
e7af8919 829
0dbd1d4f 830 SetGlobalIndex(nvars,nptbins);
831 SetPtBins(nptbins+1,ptbins);
e7af8919 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
34595b3c 910 //
e7af8919 911 SetTriggerClass("");
912 ResetMaskAndEnableMBTrigger();
913 EnableCentralTrigger();
914 EnableSemiCentralTrigger();
915
916}
34595b3c 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}