]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ANALYSIS/AliESDv0KineCuts.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
o AliTRDTenderSupply: updates from Markus Fasel
[u/mrichter/AliRoot.git] / ANALYSIS / AliESDv0KineCuts.cxx
CommitLineData
7cd657f1 1/**************************************************************************\r
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
3 * *\r
4 * Author: The ALICE Off-line Project. *\r
5 * Contributors are mentioned in the code where appropriate. *\r
6 * *\r
7 * Permission to use, copy, modify and distribute this software and its *\r
8 * documentation strictly for non-commercial purposes is hereby granted *\r
9 * without fee, provided that the above copyright notice appears in all *\r
10 * copies and that both the copyright notice and this permission notice *\r
11 * appear in the supporting documentation. The authors make no claims *\r
12 * about the suitability of this software for any purpose. It is *\r
13 * provided "as is" without express or implied warranty. *\r
14 **************************************************************************/\r
15\r
16/*\r
17 * author: M.Kalisky@gsi.de\r
18 * 08/Dec/2010\r
19 *\r
20 * Description: This class allows with purely kinematical cuts\r
21 * to select clean samples of electrons, pions and protons from the\r
22 * V0 online finder ESD V0 candidates for PID and dectector resonse\r
23 * studies.\r
24 */\r
25\r
26#include <TVector3.h>\r
27#include <TDatabasePDG.h>\r
28\r
29#include "AliESDv0.h"\r
30#include "AliESDtrack.h"\r
31#include "AliESDEvent.h"\r
32#include "AliVEvent.h"\r
33#include "AliLog.h"\r
34#include "AliKFParticle.h"\r
35#include "AliVTrack.h"\r
36#include "AliKFVertex.h"\r
37\r
38#include "AliESDv0KineCuts.h"\r
39\r
40ClassImp(AliESDv0KineCuts)\r
41\r
42//____________________________________________________________________\r
43AliESDv0KineCuts::AliESDv0KineCuts() :\r
44 fEvent(0x0)\r
45 , fPrimaryVertex(0x0)\r
46 , fType(0)\r
47 , fMode(0)\r
48 , fTPCNcls(1)\r
49 , fTPCrefit(kTRUE)\r
50 , fTPCchi2perCls(4.0)\r
51 , fTPCclsRatio(0.6)\r
52 , fNoKinks(kTRUE)\r
53 , fGcutChi2NDF(10)\r
54 , fGcutInvMass(0.05)\r
55 , fK0cutChi2NDF(10)\r
56 , fLcutChi2NDF(10)\r
11fd38f5 57 , fUseExternalVertex(kFALSE)
58 , fDeleteVertex(kFALSE)
7cd657f1 59{\r
60 //\r
61 // Default constructor\r
62 //\r
63\r
64 // default single track cuts\r
65 fTPCNcls = 1; // minimal number of the TPC clusters\r
66 fTPCrefit = kTRUE; // TPC refit\r
67 fTPCchi2perCls = 4.0; // chi2 per TPC cluster\r
68 fTPCclsRatio = 0.6; // minimal foun/findable TPC cluster ratio\r
69 fNoKinks = kTRUE; // kinks - no [kTRUE] or do not care [kFalse]\r
70\r
71\r
72 // default gamma cuts values\r
73 fGcutChi2NDF = 10; // Chi2NF cut value for the AliKFparticle gamma\r
74 fGcutCosPoint[0] = 0; // cos of the pointing angle [min, max]\r
75 fGcutCosPoint[1] = 0.02; // cos of the pointing angle [min, max]\r
76 fGcutDCA[0] = 0.; // DCA between the daughter tracks [min, max]\r
77 fGcutDCA[1] = 0.25; // DCA between the daughter tracks [min, max]\r
78 fGcutVertexR[0] = 3.; // radius of the conversion point [min, max]\r
79 fGcutVertexR[1] = 90.; // radius of the conversion point [min, max]\r
80 fGcutPsiPair[0] = 0.; // value of the psi pair cut [min, max]\r
81 fGcutPsiPair[1] = 0.05; // value of the psi pair cut [min, max]\r
82 fGcutInvMass = 0.05; // upper value on the gamma invariant mass\r
83 // default K0 cuts\r
84 fK0cutChi2NDF = 10; // Chi2NF cut value for the AliKFparticle K0\r
85 fK0cutCosPoint[0] = 0.; // cos of the pointing angle [min, max]\r
86 fK0cutCosPoint[1] = 0.02; // cos of the pointing angle [min, max]\r
87 fK0cutDCA[0] = 0.; // DCA between the daughter tracks [min, max]\r
88 fK0cutDCA[1] = 0.2; // DCA between the daughter tracks [min, max]\r
89 fK0cutVertexR[0] = 2.0; // radius of the decay point [min, max]\r
90 fK0cutVertexR[1] = 30.0; // radius of the decay point [min, max]\r
91 fK0cutInvMass[0] = 0.486; // invariant mass window\r
92 fK0cutInvMass[1] = 0.508; // invariant mass window\r
93 // Lambda & anti-Lambda cut values\r
94 fLcutChi2NDF = 10; // Chi2NF cut value for the AliKFparticle K0\r
95 fLcutCosPoint[0] = 0.; // cos of the pointing angle [min, max]\r
96 fLcutCosPoint[1] = 0.02; // cos of the pointing angle [min, max]\r
97 fLcutDCA[0] = 0.; // DCA between the daughter tracks [min, max]\r
98 fLcutDCA[1] = 0.2; // DCA between the daughter tracks [min, max]\r
99 fLcutVertexR[0] = 2.0; // radius of the decay point [min, max]\r
100 fLcutVertexR[1] = 40.0; // radius of the decay point [min, max]\r
101 fLcutInvMass[0] = 1.11; // invariant mass window\r
102 fLcutInvMass[1] = 1.12; // invariant mass window\r
103 \r
104}\r
105//____________________________________________________________________\r
106AliESDv0KineCuts::~AliESDv0KineCuts(){\r
107 //\r
108 // Destructor\r
109 //\r
110\r
111\r
112}\r
113//____________________________________________________________________\r
114AliESDv0KineCuts::AliESDv0KineCuts(const AliESDv0KineCuts &ref):\r
115 TObject(ref)\r
116 , fEvent(0x0)\r
117 , fPrimaryVertex(0x0)\r
118 , fType(0)\r
119 , fMode(0)\r
120 , fTPCNcls(1)\r
121 , fTPCrefit(kTRUE)\r
122 , fTPCchi2perCls(4.0)\r
123 , fTPCclsRatio(0.6)\r
124 , fNoKinks(kTRUE)\r
125 , fGcutChi2NDF(10)\r
126 , fGcutInvMass(0.05)\r
127 , fK0cutChi2NDF(10)\r
128 , fLcutChi2NDF(10)\r
11fd38f5 129 , fUseExternalVertex(kFALSE)
130 , fDeleteVertex(kFALSE)
7cd657f1 131{\r
132 //\r
133 // Copy operator\r
134 //\r
135\r
136 ref.Copy(*this);\r
137}\r
138//____________________________________________________________________\r
139AliESDv0KineCuts &AliESDv0KineCuts::operator=(const AliESDv0KineCuts &ref){\r
140 //\r
141 // assignment operator\r
142 //\r
143 if(this != &ref)\r
144 ref.Copy(*this);\r
145 return *this; \r
146}\r
147//____________________________________________________________________\r
148void AliESDv0KineCuts::Copy(TObject &ref) const {\r
149 //\r
150 // Performs the copying of the object\r
151 //\r
152\r
153 TObject::Copy(ref);\r
154\r
155 AliESDv0KineCuts &target = dynamic_cast<AliESDv0KineCuts &>(ref);\r
156\r
157 // default single track cuts\r
158 target.fTPCNcls = fTPCNcls;\r
159 target.fTPCrefit = fTPCrefit;\r
160 target.fTPCchi2perCls = fTPCchi2perCls;\r
161 target.fTPCclsRatio = fTPCclsRatio;\r
162 target.fNoKinks = fNoKinks;\r
11fd38f5 163 target.fUseExternalVertex = fUseExternalVertex; //added december 2nd 2011
164 target.fDeleteVertex = fDeleteVertex; //added december 2nd 2011
7cd657f1 165\r
166 // default gamma cuts values\r
167 target.fGcutChi2NDF = fGcutChi2NDF;\r
168 memcpy(target.fGcutCosPoint, fGcutCosPoint, sizeof(Float_t) * 2);\r
169 memcpy(target.fGcutDCA, fGcutDCA, sizeof(Float_t) * 2); \r
170 memcpy(target.fGcutVertexR, fGcutVertexR, sizeof(Float_t) * 2);\r
171 memcpy(target.fGcutPsiPair, fGcutPsiPair, sizeof(Float_t) * 2);\r
172 target.fGcutInvMass = fGcutInvMass;\r
173 // default K0 cuts\r
174 target.fK0cutChi2NDF = fK0cutChi2NDF;\r
175 memcpy(target.fK0cutCosPoint, fK0cutCosPoint, sizeof(Float_t) * 2);\r
176 memcpy(target.fK0cutDCA, fK0cutDCA, sizeof(Float_t) * 2);\r
177 memcpy(target.fK0cutVertexR, fK0cutVertexR, sizeof(Float_t) * 2);\r
178 memcpy(target.fK0cutInvMass, fK0cutInvMass, sizeof(Float_t) * 2);\r
179 // Lambda & anti-Lambda cut values\r
180 target.fLcutChi2NDF = fLcutChi2NDF;\r
181 memcpy(target.fLcutCosPoint, fLcutCosPoint, sizeof(Float_t) * 2);\r
182 memcpy(target.fLcutDCA, fLcutDCA, sizeof(Float_t) * 2);\r
183 memcpy(target.fLcutVertexR, fLcutVertexR, sizeof(Float_t) * 2);\r
184 memcpy(target.fLcutInvMass, fLcutInvMass, sizeof(Float_t) * 2);\r
185 \r
186}\r
187//____________________________________________________________________\r
5abc3dfe 188Bool_t AliESDv0KineCuts::ProcessV0(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN) const \r
189{\r
7cd657f1 190 //\r
191 // main user function\r
192 //\r
193\r
194 if(!v0) return kFALSE;\r
195 if(!fEvent){\r
196 AliErrorClass("No valid Event pointer available, provide it first");\r
197 return kFALSE;\r
198 }\r
199\r
200 if(!V0CutsCommon(v0)) return kFALSE;\r
201\r
202 const Int_t id = PreselectV0(v0);\r
203\r
204 if(!SingleTrackCuts(v0)) return kFALSE;\r
205\r
206 switch(id){\r
207 case kUndef:\r
208 return kFALSE;\r
209 case kGamma:\r
210 return CaseGamma(v0, pdgV0, pdgP, pdgN);\r
211 case kK0:\r
212 return CaseK0(v0, pdgV0, pdgP, pdgN);\r
213 case kLambda:\r
214 return CaseLambda(v0, pdgV0, pdgP, pdgN, 0);\r
215 case kALambda:\r
216 return CaseLambda(v0, pdgV0, pdgP, pdgN, 1);\r
217 default:\r
218 return kFALSE; \r
219 }\r
220\r
221 return kFALSE;\r
222}\r
223//____________________________________________________________________\r
5abc3dfe 224Bool_t AliESDv0KineCuts::ProcessV0(AliESDv0* const v0, Int_t &pdgP, Int_t &pdgN) const \r
225{\r
7cd657f1 226 //\r
227 // main user function, simplified if the V0 identity is not necessary\r
228 //\r
229\r
230 if(!v0) return kFALSE;\r
231 if(!fEvent){\r
232 AliErrorClass("No valid Event pointer available, provide it first");\r
233 return kFALSE;\r
234 }\r
235\r
236 Int_t idV0 = -1;\r
237 return ProcessV0(v0, idV0, pdgP, pdgN);\r
238\r
239}\r
240//____________________________________________________________________\r
5abc3dfe 241Int_t AliESDv0KineCuts::PreselectV0(AliESDv0* const v0) const \r
242{\r
7cd657f1 243 //\r
244 // Make a preselection (exclusive) of the V0 cadidates based on\r
245 // Armenteros plot\r
246 // the armenteros cut values are currently fixed and user is not able to set them via\r
247 // set funcions. The reason is that these cuts are optimized and furneter changes should \r
248 // not be necessary. To prove otherwise please study in detail before changing the values\r
249 //\r
250 \r
251 Float_t ap[2] = {-1., -1.};\r
252 Armenteros(v0, ap);\r
253 // for clarity\r
254 const Float_t alpha = ap[0];\r
255 const Float_t qt = ap[1];\r
256\r
257 // selection cuts \r
258 // - the reagions for different candidates must not overlap \r
259\r
260 // Gamma cuts\r
261 const Double_t cutAlphaG = 0.35; \r
262 const Double_t cutQTG = 0.05;\r
263 const Double_t cutAlphaG2[2] = {0.6, 0.8};\r
264 const Double_t cutQTG2 = 0.04;\r
265\r
266 // K0 cuts\r
267 const Float_t cutQTK0[2] = {0.1075, 0.215};\r
268 const Float_t cutAPK0[2] = {0.199, 0.8}; // parameters for curved QT cut\r
269 \r
270 // Lambda & A-Lambda cuts\r
271 const Float_t cutQTL = 0.03;\r
272 const Float_t cutAlphaL[2] = {0.35, 0.7};\r
273 const Float_t cutAlphaAL[2] = {-0.7, -0.35};\r
274 const Float_t cutAPL[3] = {0.107, -0.69, 0.5}; // parameters fir curved QT cut\r
275\r
276\r
277 if(kPurity == fMode){\r
278 // Check for Gamma candidates\r
279 if(qt < cutQTG){\r
280 if( (TMath::Abs(alpha) < cutAlphaG) ) return kGamma;\r
281 }\r
282 // additional region - should help high pT gammas\r
283 if(qt < cutQTG2){\r
284 if( (TMath::Abs(alpha) > cutAlphaG2[0]) && (TMath::Abs(alpha) < cutAlphaG2[1]) ) return kGamma;\r
285 }\r
286 }\r
287 if(kEffGamma == fMode){\r
288 if(qt < cutQTG) return kGamma;\r
289 }\r
290\r
291 \r
292 // Check for K0 candidates\r
293 Float_t q = cutAPK0[0] * TMath::Sqrt(TMath::Abs(1 - alpha*alpha/(cutAPK0[1]*cutAPK0[1])));\r
294 if( (qt > cutQTK0[0]) && (qt < cutQTK0[1]) && (qt > q) ){\r
295 return kK0;\r
296 }\r
297\r
298 // Check for Lambda candidates\r
299 q = cutAPL[0] * TMath::Sqrt(TMath::Abs(1 - ( (alpha + cutAPL[1]) * (alpha + cutAPL[1]) ) / (cutAPL[2]*cutAPL[2]) ));\r
300 if( (alpha > cutAlphaL[0]) && (alpha < cutAlphaL[1]) && (qt > cutQTL) && (qt < q) ){\r
301 return kLambda;\r
302 }\r
303\r
304 // Check for A-Lambda candidates\r
305 q = cutAPL[0] * TMath::Sqrt(TMath::Abs(1 - ( (alpha - cutAPL[1]) * (alpha - cutAPL[1]) ) / (cutAPL[2]*cutAPL[2]) ));\r
306 if( (alpha > cutAlphaAL[0]) && (alpha < cutAlphaAL[1]) && (qt > cutQTL) && (qt < q) ){\r
307 return kALambda;\r
308 }\r
309 \r
310 return kUndef;\r
311}\r
312//____________________________________________________________________\r
5abc3dfe 313Bool_t AliESDv0KineCuts::SingleTrackCuts(AliESDv0 * const v0) const \r
314{\r
7cd657f1 315 //\r
316 // apply single track cuts\r
317 // correct sign not relevat here\r
318 //\r
319\r
320 if(!v0) return kFALSE;\r
321 \r
322 Int_t pIndex = 0, nIndex = 0;\r
323 pIndex = v0->GetPindex();\r
324 nIndex = v0->GetNindex();\r
325 AliESDtrack* d[2];\r
326 d[0] = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(pIndex));\r
327 d[1] = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(nIndex));\r
328 \r
329 for(Int_t i=0; i<2; ++i){\r
330 if(!d[i]) return kFALSE;\r
331 \r
332 // status word\r
333 ULong_t status = d[i]->GetStatus();\r
334\r
335 // No. of TPC clusters leave to the users\r
336 if(d[i]->GetTPCNcls() < 1) return kFALSE;\r
337\r
338 // TPC refit\r
339 if(!(status & AliESDtrack::kTPCrefit)) return kFALSE;\r
340 \r
341 // Chi2 per TPC cluster\r
342 Int_t nTPCclusters = d[i]->GetTPCNcls();\r
343 Float_t chi2perTPCcluster = d[i]->GetTPCchi2()/Float_t(nTPCclusters);\r
344 if(chi2perTPCcluster > 4) return kFALSE;\r
345\r
346 // TPC cluster ratio\r
347 Float_t cRatioTPC = d[i]->GetTPCNclsF() > 0. ? static_cast<Float_t>(d[i]->GetTPCNcls())/static_cast<Float_t> (d[i]->GetTPCNclsF()) : 1.;\r
348 if(cRatioTPC < 0.6) return kFALSE;\r
349 \r
350 // kinks\r
351 if(d[i]->GetKinkIndex(0) != 0) return kFALSE;\r
352 \r
353 }\r
354\r
355 return kTRUE;\r
356}\r
357//____________________________________________________________________\r
5abc3dfe 358Bool_t AliESDv0KineCuts::CaseGamma(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN) const \r
359{\r
7cd657f1 360 //\r
361 // process the gamma conversion candidate\r
362 //\r
363\r
364 if(!v0) return kFALSE;\r
365\r
366 AliVTrack* daughter[2];\r
367 Int_t pIndex = 0, nIndex = 0;\r
368\r
369 Bool_t sign = CheckSigns(v0);\r
370 if(sign){\r
371 pIndex = v0->GetPindex();\r
372 nIndex = v0->GetNindex();\r
373 }\r
374 else{\r
375 pIndex = v0->GetNindex();\r
376 nIndex = v0->GetPindex(); \r
377 }\r
378 daughter[0] = dynamic_cast<AliVTrack *>(fEvent->GetTrack(pIndex));\r
379 daughter[1] = dynamic_cast<AliVTrack *>(fEvent->GetTrack(nIndex));\r
380 if(!daughter[0] || !daughter[1]) return kFALSE;\r
381\r
382 AliKFParticle *kfMother = CreateMotherParticle(daughter[0], daughter[1], TMath::Abs(kElectron), TMath::Abs(kElectron));\r
383 if(!kfMother) return kFALSE;\r
384\r
385 AliESDtrack* d[2];\r
386 d[0] = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(pIndex));\r
387 d[1] = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(nIndex));\r
388\r
389 Float_t iMass = v0->GetEffMass(0, 0);\r
390\r
391 // cos pointing angle\r
392 Double_t cosPoint = v0->GetV0CosineOfPointingAngle();\r
393 cosPoint = TMath::ACos(cosPoint);\r
394\r
395 // DCA between daughters\r
396 Double_t dca = v0->GetDcaV0Daughters();\r
397\r
398 // Production vertex\r
399 Double_t x, y, z; \r
400 v0->GetXYZ(x,y,z);\r
401 Double_t r = TMath::Sqrt(x*x + y*y);\r
402\r
403 Double_t xy[2];\r
404 Double_t r2 = -1.;\r
405 if ( GetConvPosXY(d[0], d[1], xy) ){\r
406 r2 = TMath::Sqrt(xy[0]*xy[0] + xy[1]*xy[1]);\r
407 }\r
408\r
409 // psi pair \r
410 Double_t psiPair = PsiPair(v0);\r
411 \r
412 // V0 chi2/ndf\r
413 Double_t chi2ndf = kfMother->GetChi2()/kfMother->GetNDF();\r
414\r
415 if(kfMother) delete kfMother; \r
416 \r
417 // apply the cuts\r
418\r
419 if(iMass > fGcutInvMass) return kFALSE;\r
420\r
421 if(chi2ndf > fGcutChi2NDF) return kFALSE;\r
422\r
423 if(cosPoint < fGcutCosPoint[0] || cosPoint > fGcutCosPoint[1]) return kFALSE;\r
424\r
425 if(dca < fGcutDCA[0] || dca > fGcutDCA[1]) return kFALSE;\r
426\r
427 if(r < fGcutVertexR[0] || r > fGcutVertexR[1]) return kFALSE;\r
428\r
429 if(psiPair < fGcutPsiPair[0] || psiPair > fGcutPsiPair[1]) return kFALSE;\r
430 \r
431 // all cuts passed\r
432\r
433 pdgV0 = 22;\r
434 if(sign){\r
435 pdgP = -11;\r
436 pdgN = 11;\r
437 }\r
438 else{\r
439 pdgP = 11;\r
440 pdgN = -11;\r
441 }\r
442\r
443 return kTRUE;\r
444}\r
445//____________________________________________________________________\r
5abc3dfe 446Bool_t AliESDv0KineCuts::CaseK0(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN) const {\r
7cd657f1 447 //\r
448 // process the K0 candidate\r
449 //\r
450\r
451 if(!v0) return kFALSE;\r
452 \r
453 AliVTrack* daughter[2];\r
454 Int_t pIndex = 0, nIndex = 0;\r
455 Bool_t sign = CheckSigns(v0);\r
456 if(sign){\r
457 pIndex = v0->GetPindex();\r
458 nIndex = v0->GetNindex();\r
459 }\r
460 else{\r
461 pIndex = v0->GetNindex();\r
462 nIndex = v0->GetPindex(); \r
463 }\r
464 \r
465 daughter[0] = dynamic_cast<AliVTrack *>(fEvent->GetTrack(pIndex));\r
466 daughter[1] = dynamic_cast<AliVTrack *>(fEvent->GetTrack(nIndex));\r
467 if(!daughter[0] || !daughter[1]) return kFALSE;\r
468\r
469 AliKFParticle *kfMother = CreateMotherParticle(daughter[0], daughter[1], TMath::Abs(kPiPlus), TMath::Abs(kPiPlus));\r
470 if(!kfMother) return kFALSE;\r
471\r
472 AliESDtrack* d[2];\r
473 d[0] = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(pIndex));\r
474 d[1] = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(nIndex));\r
475\r
476 Float_t iMass = v0->GetEffMass(2, 2);\r
477\r
478 // cos pointing angle\r
479 Double_t cosPoint = v0->GetV0CosineOfPointingAngle();\r
480 cosPoint = TMath::ACos(cosPoint);\r
481\r
482 // DCA between daughters\r
483 Double_t dca = v0->GetDcaV0Daughters();\r
484\r
485 // Production vertex\r
486 Double_t x, y, z; \r
487 v0->GetXYZ(x,y,z);\r
488\r
489 Double_t r = TMath::Sqrt(x*x + y*y); \r
490\r
491 // V0 chi2/ndf\r
492 Double_t chi2ndf = kfMother->GetChi2()/kfMother->GetNDF();\r
493 \r
494 if(kfMother) delete kfMother; \r
495\r
496 //\r
497 // apply the cuts\r
498 //\r
499 if(iMass < fK0cutInvMass[0] || iMass > fK0cutInvMass[1]) return kFALSE;\r
500\r
501 if(chi2ndf > fK0cutChi2NDF) return kFALSE;\r
502\r
503 if(cosPoint < fK0cutCosPoint[0] || cosPoint > fK0cutCosPoint[1]) return kFALSE;\r
504\r
505 if(dca < fK0cutDCA[0] || dca > fK0cutDCA[1]) return kFALSE;\r
506\r
507 if(r < fK0cutVertexR[0] || r > fK0cutVertexR[1]) return kFALSE;\r
508\r
509 // all cuts passed\r
510 pdgV0 = 310;\r
511 if(sign){\r
512 pdgP = 211;\r
513 pdgN = -211;\r
514 }\r
515 else{\r
516 pdgP = -211;\r
517 pdgN = 211;\r
518 }\r
519\r
520 return kTRUE;\r
521}\r
522//____________________________________________________________________\r
5abc3dfe 523Bool_t AliESDv0KineCuts::CaseLambda(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN, Int_t id) const {\r
7cd657f1 524 //\r
525 // process teh Lambda and Anti-Lambda candidate\r
526 //\r
527 \r
528 if(!v0) return kFALSE;\r
529\r
530 const Double_t cL0mass=TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass(); // PDG lambda mass\r
531\r
532 AliVTrack* daughter[2];\r
533 Int_t pIndex = 0, nIndex = 0;\r
534 Float_t mMass[2] = {-1., -1.};\r
535 Bool_t sign = CheckSigns(v0);\r
536 if(sign){\r
537 pIndex = v0->GetPindex();\r
538 nIndex = v0->GetNindex();\r
539 mMass[0] = v0->GetEffMass(4, 2);\r
540 mMass[1] = v0->GetEffMass(2, 4);\r
541 }\r
542 else{\r
543 pIndex = v0->GetNindex();\r
544 nIndex = v0->GetPindex(); \r
545 mMass[0] = v0->GetEffMass(2, 4);\r
546 mMass[1] = v0->GetEffMass(4, 2);\r
547 }\r
548 \r
549 daughter[0] = dynamic_cast<AliVTrack *>(fEvent->GetTrack(pIndex));\r
550 daughter[1] = dynamic_cast<AliVTrack *>(fEvent->GetTrack(nIndex));\r
551 if(!daughter[0] || !daughter[1]) return kFALSE;\r
552\r
553 AliKFParticle *kfMother[2] = {0x0, 0x0};\r
554 // Lambda\r
555 kfMother[0] = CreateMotherParticle(daughter[0], daughter[1], TMath::Abs(kProton), TMath::Abs(kPiPlus));\r
556 if(!kfMother[0]) return kFALSE;\r
557 \r
558 // Anti-Lambda\r
559 kfMother[1] = CreateMotherParticle(daughter[0], daughter[1], TMath::Abs(kPiPlus), TMath::Abs(kProton));\r
560 if(!kfMother[1]) return kFALSE;\r
561\r
562 Float_t dMass[2] = {TMath::Abs(mMass[0] - cL0mass), TMath::Abs(mMass[1] - cL0mass)};\r
563 \r
564 AliESDtrack* d[2];\r
565 d[0] = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(pIndex));\r
566 d[1] = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(nIndex));\r
567 if(!d[0] || !d[1]) return kFALSE;\r
568 \r
569 Float_t p[2] = {d[0]->GetP(), d[1]->GetP()}; \r
570\r
571 // check the 3 lambda - antilambda variables\r
572 Int_t check[2] = {-1, -1}; // 0 : lambda, 1 : antilambda\r
573 // 1) momentum of the daughter particles - proton is expected to have higher momentum than pion\r
574 check[0] = (p[0] > p[1]) ? 0 : 1;\r
575 // 2) mass of the mother particle\r
576 check[1] = (dMass[0] < dMass[1]) ? 0 : 1;\r
577 \r
578 // require positive correlation of (1) and (2)\r
579 if(check[0] != check[1]){\r
580 if(kfMother[0]) delete kfMother[0]; \r
581 if(kfMother[1]) delete kfMother[1]; \r
582 return kFALSE;\r
583 }\r
584\r
585 // now that the check[0] == check[1]\r
586 const Int_t type = check[0];\r
587\r
588 // require that the input armenteros preselection agree:\r
589 if(type != id) return kFALSE;\r
590\r
591 Float_t iMass =0.;\r
592 if(sign){\r
593 iMass = (type == 0) ? v0->GetEffMass(4, 2) : v0->GetEffMass(2, 4);\r
594 }\r
595 else{\r
596 iMass = (type == 0) ? v0->GetEffMass(2, 4) : v0->GetEffMass(4, 2);\r
597 }\r
598\r
599 // cos pointing angle\r
600 Double_t cosPoint = v0->GetV0CosineOfPointingAngle();\r
601 cosPoint = TMath::ACos(cosPoint);\r
602\r
603 // DCA between daughters\r
604 Double_t dca = v0->GetDcaV0Daughters();\r
605 \r
606 // Production vertex\r
607 Double_t x, y, z; \r
608 v0->GetXYZ(x,y,z);\r
609 Double_t r = TMath::Sqrt(x*x + y*y);\r
610\r
611 // proton - pion indices\r
612 Int_t ix[2] = {0, 1};\r
613 if(1 == type){\r
614 ix[0] = 1;\r
615 ix[1] = 0;\r
616 }\r
617\r
618 // V0 chi2/ndf\r
619 Double_t chi2ndf = kfMother[type]->GetChi2()/kfMother[type]->GetNDF();\r
620\r
621 if(kfMother[0]) delete kfMother[0]; \r
622 if(kfMother[1]) delete kfMother[1]; \r
623\r
624 //\r
625 // apply the cuts\r
626 //\r
627\r
628 if(iMass < fLcutInvMass[0] || iMass > fLcutInvMass[1]) return kFALSE;\r
629\r
630 if(chi2ndf > fLcutChi2NDF) return kFALSE;\r
631\r
632 if(cosPoint < fLcutCosPoint[0] || cosPoint > fLcutCosPoint[1]) return kFALSE;\r
633\r
634 if(dca < fLcutDCA[0] || dca > fLcutDCA[1]) return kFALSE;\r
635\r
636 if(r < fLcutVertexR[0] || r > fLcutVertexR[1]) return kFALSE;\r
637\r
638 // all cuts passed\r
639\r
640 if(0 == type){\r
641 pdgV0 = 3122;\r
642 if(sign){\r
643 pdgP = 2212;\r
644 pdgN = -211;\r
645 }\r
646 else{\r
647 pdgP = -211;\r
648 pdgN = 2212;\r
649 }\r
650 }\r
651 else{\r
652 pdgV0 = -3122;\r
653 if(sign){\r
654 pdgP = 211;\r
655 pdgN = -2212;\r
656 }\r
657 else{\r
658 pdgP = -2212;\r
659 pdgN = 211;\r
660 }\r
661 }\r
662\r
663 return kTRUE;\r
664}\r
665//____________________________________________________________________\r
5abc3dfe 666Bool_t AliESDv0KineCuts::V0CutsCommon(AliESDv0 * const v0) const \r
667{\r
7cd657f1 668 //\r
669 // V0 cuts common to all V0s\r
670 //\r
671\r
672 AliESDtrack* dN, *dP; \r
673 \r
674 dP = dynamic_cast<AliESDtrack *>(fEvent->GetTrack(v0->GetPindex()));\r
675 dN = dynamic_cast<AliESDtrack *>(fEvent->GetTrack(v0->GetNindex())); \r
676 \r
677 if(!dN || !dP) return kFALSE;\r
678\r
679 Int_t qP = dP->Charge();\r
680 Int_t qN = dN->Charge();\r
681\r
682 if((qP*qN) != -1) return kFALSE;\r
683\r
684 return kTRUE;\r
685}\r
686//____________________________________________________________________\r
5abc3dfe 687void AliESDv0KineCuts::Armenteros(AliESDv0* const v0, Float_t val[2]) const \r
688{\r
7cd657f1 689 //\r
690 // computes the Armenteros variables for given V0\r
691 // fills the histogram\r
692 // returns the values via "val"\r
693 //\r
694 \r
695 Double_t mn[3] = {0,0,0};\r
696 Double_t mp[3] = {0,0,0}; \r
697 Double_t mm[3] = {0,0,0}; \r
698\r
699 if(CheckSigns(v0)){\r
700 v0->GetNPxPyPz(mn[0],mn[1],mn[2]); //reconstructed cartesian momentum components of negative daughter\r
701 v0->GetPPxPyPz(mp[0],mp[1],mp[2]); //reconstructed cartesian momentum components of positive daughter\r
702 }\r
703 else{\r
704 v0->GetPPxPyPz(mn[0],mn[1],mn[2]); //reconstructed cartesian momentum components of negative daughter\r
705 v0->GetNPxPyPz(mp[0],mp[1],mp[2]); //reconstructed cartesian momentum components of positive daughter\r
706 }\r
707 v0->GetPxPyPz(mm[0],mm[1],mm[2]); //reconstructed cartesian momentum components of mother\r
708\r
709 TVector3 vecN(mn[0],mn[1],mn[2]);\r
710 TVector3 vecP(mp[0],mp[1],mp[2]);\r
711 TVector3 vecM(mm[0],mm[1],mm[2]);\r
712 \r
713 Double_t thetaP = acos((vecP * vecM)/(vecP.Mag() * vecM.Mag()));\r
714 Double_t thetaN = acos((vecN * vecM)/(vecN.Mag() * vecM.Mag()));\r
715 \r
716 Double_t alfa = ((vecP.Mag())*cos(thetaP)-(vecN.Mag())*cos(thetaN))/\r
717 ((vecP.Mag())*cos(thetaP)+(vecN.Mag())*cos(thetaN)) ;\r
718 Double_t qt = vecP.Mag()*sin(thetaP);\r
719\r
720 val[0] = alfa;\r
721 val[1] = qt;\r
722}\r
723//____________________________________________________________________\r
5abc3dfe 724Bool_t AliESDv0KineCuts::CheckSigns(AliESDv0* const v0) const \r
725{\r
7cd657f1 726 //\r
727 // check wheter the sign was correctly applied to \r
728 // V0 daughter tracks\r
729 //\r
730 \r
731 Bool_t correct = kFALSE;\r
732\r
733 Int_t pIndex = 0, nIndex = 0;\r
734 pIndex = v0->GetPindex();\r
735 nIndex = v0->GetNindex();\r
736 \r
737 AliESDtrack* d[2];\r
738 d[0] = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(pIndex));\r
739 d[1] = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(nIndex));\r
740\r
741 Int_t sign[2];\r
742 sign[0] = (int)d[0]->GetSign();\r
743 sign[1] = (int)d[1]->GetSign();\r
744 \r
745 if(-1 == sign[0] && 1 == sign[1]){\r
746 correct = kFALSE;\r
747 }\r
748 else{\r
749 correct = kTRUE;\r
750 }\r
751 \r
752 return correct;\r
753}\r
754//________________________________________________________________\r
5abc3dfe 755Double_t AliESDv0KineCuts::PsiPair(AliESDv0* const v0) const \r
756{\r
7cd657f1 757 //\r
758 // Angle between daughter momentum plane and plane \r
759 // \r
760\r
761 if(!fEvent) return -1.;\r
762\r
763 Float_t magField = fEvent->GetMagneticField();\r
764\r
765 Int_t pIndex = -1;\r
766 Int_t nIndex = -1;\r
767 if(CheckSigns(v0)){\r
768 pIndex = v0->GetPindex();\r
769 nIndex = v0->GetNindex();\r
770 }\r
771 else{\r
772 pIndex = v0->GetNindex();\r
773 nIndex = v0->GetPindex(); \r
774 }\r
775 \r
776\r
777 AliESDtrack* daughter[2];\r
778\r
779 daughter[0] = dynamic_cast<AliESDtrack *>(fEvent->GetTrack(pIndex));\r
780 daughter[1] = dynamic_cast<AliESDtrack *>(fEvent->GetTrack(nIndex));\r
781\r
782 Double_t x, y, z;\r
783 v0->GetXYZ(x,y,z);//Reconstructed coordinates of V0; to be replaced by Markus Rammler's method in case of conversions!\r
784 \r
785 Double_t mn[3] = {0,0,0};\r
786 Double_t mp[3] = {0,0,0};\r
787 \r
788\r
789 v0->GetNPxPyPz(mn[0],mn[1],mn[2]);//reconstructed cartesian momentum components of negative daughter;\r
790 v0->GetPPxPyPz(mp[0],mp[1],mp[2]);//reconstructed cartesian momentum components of positive daughter; \r
791\r
792\r
793 Double_t deltat = 1.;\r
794 deltat = TMath::ATan(mp[2]/(TMath::Sqrt(mp[0]*mp[0] + mp[1]*mp[1])+1.e-13)) - TMath::ATan(mn[2]/(TMath::Sqrt(mn[0]*mn[0] + mn[1]*mn[1])+1.e-13));//difference of angles of the two daughter tracks with z-axis\r
795\r
796 Double_t radiussum = TMath::Sqrt(x*x + y*y) + 50;//radius to which tracks shall be propagated\r
797\r
798 Double_t momPosProp[3];\r
799 Double_t momNegProp[3];\r
800 \r
801 AliExternalTrackParam pt(*daughter[0]), nt(*daughter[1]);\r
802 \r
803 Double_t psiPair = 4.;\r
804\r
805 if(nt.PropagateTo(radiussum,magField) == 0)//propagate tracks to the outside\r
806 psiPair = -5.;\r
807 if(pt.PropagateTo(radiussum,magField) == 0)\r
808 psiPair = -5.;\r
809 pt.GetPxPyPz(momPosProp);//Get momentum vectors of tracks after propagation\r
810 nt.GetPxPyPz(momNegProp);\r
811 \r
812 Double_t pEle =\r
813 TMath::Sqrt(momNegProp[0]*momNegProp[0]+momNegProp[1]*momNegProp[1]+momNegProp[2]*momNegProp[2]);//absolute momentum value of negative daughter\r
814 Double_t pPos =\r
815 TMath::Sqrt(momPosProp[0]*momPosProp[0]+momPosProp[1]*momPosProp[1]+momPosProp[2]*momPosProp[2]);//absolute momentum value of positive daughter\r
816 \r
817 Double_t scalarproduct =\r
818 momPosProp[0]*momNegProp[0]+momPosProp[1]*momNegProp[1]+momPosProp[2]*momNegProp[2];//scalar product of propagated positive and negative daughters' momenta\r
819 \r
820 Double_t chipair = TMath::ACos(scalarproduct/(pEle*pPos));//Angle between propagated daughter tracks\r
821\r
822 psiPair = TMath::Abs(TMath::ASin(deltat/chipair)); \r
823\r
824 return psiPair; \r
825}\r
826//___________________________________________________________________\r
5abc3dfe 827Bool_t AliESDv0KineCuts::GetConvPosXY(AliESDtrack * const ptrack, AliESDtrack * const ntrack, Double_t convpos[2]) const\r
828{\r
7cd657f1 829 //\r
830 // recalculate the gamma conversion XY postition\r
831 //\r
832\r
833 const Double_t b = fEvent->GetMagneticField();\r
834\r
835 Double_t helixcenterpos[2];\r
836 GetHelixCenter(ptrack,b,ptrack->Charge(),helixcenterpos);\r
837\r
838 Double_t helixcenterneg[2];\r
839 GetHelixCenter(ntrack,b,ntrack->Charge(),helixcenterneg);\r
840\r
841 Double_t poshelix[6];\r
842 ptrack->GetHelixParameters(poshelix,b);\r
843 Double_t posradius = TMath::Abs(1./poshelix[4]);\r
844\r
845 Double_t neghelix[6];\r
846 ntrack->GetHelixParameters(neghelix,b);\r
847 Double_t negradius = TMath::Abs(1./neghelix[4]);\r
848\r
849 Double_t xpos = helixcenterpos[0];\r
850 Double_t ypos = helixcenterpos[1];\r
851 Double_t xneg = helixcenterneg[0];\r
852 Double_t yneg = helixcenterneg[1];\r
853\r
854 convpos[0] = (xpos*negradius + xneg*posradius)/(negradius+posradius);\r
855 convpos[1] = (ypos*negradius+ yneg*posradius)/(negradius+posradius);\r
856\r
857 return 1;\r
858}\r
859//___________________________________________________________________\r
5abc3dfe 860Bool_t AliESDv0KineCuts::GetHelixCenter(AliESDtrack * const track, Double_t b,Int_t charge, Double_t center[2]) const\r
861{\r
7cd657f1 862 //\r
863 // computes the center of the track helix\r
864 //\r
865 \r
866 Double_t pi = TMath::Pi();\r
867 \r
868 Double_t helix[6];\r
869 track->GetHelixParameters(helix,b);\r
870 \r
871 Double_t xpos = helix[5];\r
872 Double_t ypos = helix[0];\r
873 Double_t radius = TMath::Abs(1./helix[4]);\r
874 Double_t phi = helix[2];\r
875\r
876 if(phi < 0){\r
877 phi = phi + 2*pi;\r
878 }\r
879\r
880 phi -= pi/2.;\r
881 Double_t xpoint = radius * TMath::Cos(phi);\r
882 Double_t ypoint = radius * TMath::Sin(phi);\r
883\r
884 if(b<0){\r
885 if(charge > 0){\r
886 xpoint = - xpoint;\r
887 ypoint = - ypoint;\r
888 }\r
04152663 889 /* avoid self assignment\r
7cd657f1 890 if(charge < 0){\r
891 xpoint = xpoint;\r
892 ypoint = ypoint;\r
893 }\r
04152663 894 */\r
7cd657f1 895 }\r
896 if(b>0){\r
04152663 897 /* avoid self assignment\r
7cd657f1 898 if(charge > 0){\r
899 xpoint = xpoint;\r
900 ypoint = ypoint;\r
901 }\r
04152663 902 */\r
7cd657f1 903 if(charge < 0){\r
904 xpoint = - xpoint;\r
905 ypoint = - ypoint;\r
906 }\r
907 }\r
908 center[0] = xpos + xpoint;\r
909 center[1] = ypos + ypoint;\r
910\r
911 return 1;\r
912}\r
913//___________________________________________________________________\r
5abc3dfe 914AliKFParticle *AliESDv0KineCuts::CreateMotherParticle(const AliVTrack* const pdaughter, const AliVTrack* const ndaughter, Int_t pspec, Int_t nspec) const\r
915{\r
7cd657f1 916 //\r
917 // Creates a mother particle\r
918 //\r
919 AliKFParticle pkfdaughter(*pdaughter, pspec);\r
920 AliKFParticle nkfdaughter(*ndaughter, nspec);\r
921 \r
922 \r
923 // Create the mother particle \r
924 AliKFParticle *m = new AliKFParticle(pkfdaughter, nkfdaughter);\r
5abc3dfe 925 m->SetField(fEvent->GetMagneticField());\r
7cd657f1 926 if(TMath::Abs(kElectron) == pspec && TMath::Abs(kElectron) == nspec) m->SetMassConstraint(0, 0.001);\r
927 else if(TMath::Abs(kPiPlus) == pspec && TMath::Abs(kPiPlus) == nspec) m->SetMassConstraint(TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass(), 0.);\r
928 else if(TMath::Abs(kProton) == pspec && TMath::Abs(kPiPlus) == nspec) m->SetMassConstraint(TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass(), 0.);\r
929 else if(TMath::Abs(kPiPlus) == pspec && TMath::Abs(kProton) == nspec) m->SetMassConstraint(TDatabasePDG::Instance()->GetParticle(kLambda0)->Mass(), 0.);\r
930 else{\r
931 AliErrorClass("Wrong daughter ID - mass constraint can not be set");\r
932 }\r
933\r
934 AliKFVertex improvedVertex = *fPrimaryVertex;\r
935 improvedVertex += *m;\r
936 m->SetProductionVertex(improvedVertex);\r
937 \r
938 // update 15/06/2010\r
939 // mother particle will not be added to primary vertex but only to its copy \r
940 // as this confilcts with calling\r
941 // m->SetPrimaryVertex() function and\r
942 // subsequently removing the mother particle afterwards\r
943 // Source: Sergey Gorbunov\r
944\r
945 return m;\r
946}\r
947//____________________________________________________________________\r
948void AliESDv0KineCuts::SetEvent(AliESDEvent* const event){\r
949 //\r
950 // direct setter of ESD event\r
951 //\r
952 fEvent = event;\r
953 if(!fEvent){\r
954 AliErrorClass("Invalid input event pointer");\r
955 return;\r
956 }\r
11fd38f5 957if (fUseExternalVertex) return;
958else{
959 if(fPrimaryVertex && fDeleteVertex){
960 delete fPrimaryVertex;
961 fPrimaryVertex=0x0;
962 }
963 fPrimaryVertex = new AliKFVertex(*(event->GetPrimaryVertex()));
964 fDeleteVertex=kTRUE;
965 }
966
967
7cd657f1 968\r
969}\r
970//____________________________________________________________________\r
971void AliESDv0KineCuts::SetEvent(AliVEvent* const event){\r
972 //\r
973 // direct setter of ESD event\r
974 //\r
975 if(event)\r
976 fEvent = static_cast<AliESDEvent*>(event);\r
977 if(!fEvent){\r
978 AliErrorClass("Invalid input event pointer");\r
979 return;\r
980 }\r
981\r
11fd38f5 982if (fUseExternalVertex) return;
983else{
984 if(fPrimaryVertex && fDeleteVertex){
985 delete fPrimaryVertex;
986 fPrimaryVertex=0x0;
987 }
988 fPrimaryVertex = new AliKFVertex(*(event->GetPrimaryVertex()));
989 fDeleteVertex=kTRUE;
7cd657f1 990}\r
11fd38f5 991
992}
993
994
995//________________________________________________________________
996void AliESDv0KineCuts::UseExternalVertex(Bool_t use_external){
997 //
998 // Reenable primary Vertex from ESD event
999 //
1000 if (use_external) fUseExternalVertex =kTRUE;
1001 else fUseExternalVertex =kFALSE;
1002}
1003
1004
1005
1006
7cd657f1 1007//________________________________________________________________\r
1008void AliESDv0KineCuts::SetPrimaryVertex(AliKFVertex* const v){\r
1009 //\r
1010 // set the primary vertex of the event\r
1011 //\r
11fd38f5 1012 if(fPrimaryVertex && fDeleteVertex){
1013 delete fPrimaryVertex;
1014 fPrimaryVertex =0x0;
1015 fDeleteVertex = kFALSE;
1016 }
1017 fUseExternalVertex=kTRUE;
1018 fPrimaryVertex = v; // set primary Vertex
7cd657f1 1019 if(!fPrimaryVertex){\r
1020 AliErrorClass("Failed to initialize the primary vertex");\r
1021 return;\r
1022 }\r
1023}\r
1024//___________________________________________________________________\r
1025void AliESDv0KineCuts::SetMode(Int_t mode, Int_t type){\r
1026 //\r
1027 // this function allows the user to select (prior running the 'ProcessV0' function)\r
1028 // to select different approaches to V0 selection - the 'mode'\r
1029 // - and -\r
1030 // different systems (pp, PbPb) - 'type' \r
1031 //\r
1032 // To see the cut values for different modes please refer to the\r
1033 // function SetCuts()\r
1034 //\r
1035 // Important notice: based on the parameters particular sets of cuts will\r
1036 // be activated for teh V0 selection. If some additional changes to single\r
1037 // cuts are needed please us the SetXXXcut function (see the header file)\r
1038 // \r
1039\r
1040 switch(mode){\r
1041 case kPurity:\r
1042 fMode = kPurity; // used to obtain highest purity possible - the efficiency may be low\r
cfaa4361 1043 break;\r
7cd657f1 1044 case kEffGamma:\r
1045 fMode = kEffGamma; // used to obtain highes efficiency possible - the purity may be worse\r
cfaa4361 1046 break;\r
7cd657f1 1047 default:\r
1048 AliError("V0 selection mode not recognozed, setting 'kPurity'");\r
1049 fMode = kPurity;\r
1050 }\r
1051\r
1052 switch(type){\r
1053 case kPP:\r
1054 fType = kPP; // cuts optimized for low multiplicity \r
cfaa4361 1055 break;\r
7cd657f1 1056 case kPbPb:\r
1057 fType = kPbPb; // cuts optimized for high multiplicity\r
cfaa4361 1058 break;\r
7cd657f1 1059 }\r
1060 \r
1061 // setup the cut values for selected mode & type\r
1062 SetCuts();\r
1063\r
1064}\r
1065//___________________________________________________________________\r
1066void AliESDv0KineCuts::SetMode(Int_t mode, const char* type){\r
1067 //\r
1068 // overloaded function - please see above\r
1069 // \r
1070 \r
1071 Int_t t = -1;\r
1072\r
1073 if(!strcmp("pp", type)) t = kPP;\r
1074 else if(!(strcmp("PbPb", type))) t = kPbPb;\r
1075 else{\r
1076 AliError("data type not recognized, setting 'pp'");\r
1077 t = kPP; \r
1078 }\r
1079\r
1080 SetMode(mode, t);\r
1081\r
1082}\r
1083//___________________________________________________________________\r
1084void AliESDv0KineCuts::SetCuts(){\r
1085 //\r
1086 // this funciton sets the default cut values based on the selected\r
1087 // fMode and fType.\r
1088 // please note that only the cuts that have different values than the default\r
1089 // cuts are updated here\r
1090 //\r
1091 \r
1092 // last update: 14/02/2011\r
1093 // as a very preliminary - the only change to default cuts is to apply\r
1094 // less restricting gamma conversion selection in PreselectV0() function\r
1095 \r
1096\r
1097 \r
1098}\r