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