Changes to the DEtaDPhi corr fun (making 0 in the center of the bin in the histogram...
[u/mrichter/AliRoot.git] / ANALYSIS / AliESDv0KineCuts.cxx
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
40 ClassImp(AliESDv0KineCuts)\r
41 \r
42 //____________________________________________________________________\r
43 AliESDv0KineCuts::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
57   , fUseExternalVertex(kFALSE)\r
58   , fDeleteVertex(kFALSE)\r
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
106 AliESDv0KineCuts::~AliESDv0KineCuts(){\r
107   //\r
108   // Destructor\r
109   //\r
110 \r
111 \r
112 }\r
113 //____________________________________________________________________\r
114 AliESDv0KineCuts::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
129   , fUseExternalVertex(kFALSE)\r
130   , fDeleteVertex(kFALSE)\r
131 {\r
132   //\r
133   // Copy operator\r
134   //\r
135 \r
136   ref.Copy(*this);\r
137 }\r
138 //____________________________________________________________________\r
139 AliESDv0KineCuts &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
148 void 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
163   target.fUseExternalVertex = fUseExternalVertex;  //added december 2nd 2011\r
164   target.fDeleteVertex = fDeleteVertex;  //added december 2nd 2011\r
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
188 Bool_t  AliESDv0KineCuts::ProcessV0(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN) const \r
189 {\r
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
224 Bool_t  AliESDv0KineCuts::ProcessV0(AliESDv0* const v0, Int_t &pdgP, Int_t &pdgN) const \r
225 {\r
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
241 Int_t AliESDv0KineCuts::PreselectV0(AliESDv0* const v0) const \r
242 {\r
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
313 Bool_t  AliESDv0KineCuts::SingleTrackCuts(AliESDv0 * const v0) const \r
314 {\r
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
358 Bool_t AliESDv0KineCuts::CaseGamma(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN) const \r
359 {\r
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
446 Bool_t  AliESDv0KineCuts::CaseK0(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN) const {\r
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
523 Bool_t  AliESDv0KineCuts::CaseLambda(AliESDv0* const v0, Int_t &pdgV0, Int_t &pdgP, Int_t &pdgN, Int_t id) const {\r
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
666 Bool_t  AliESDv0KineCuts::V0CutsCommon(const AliESDv0 * const v0) const \r
667 {\r
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
687 void AliESDv0KineCuts::Armenteros(AliESDv0* const v0, Float_t val[2]) const \r
688 {\r
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
724 Bool_t AliESDv0KineCuts::CheckSigns(AliESDv0* const v0) const \r
725 {\r
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
755 Double_t AliESDv0KineCuts::PsiPair(AliESDv0* const v0) const \r
756 {\r
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
827 Bool_t  AliESDv0KineCuts::GetConvPosXY(AliESDtrack * const ptrack, AliESDtrack * const ntrack, Double_t convpos[2]) const\r
828 {\r
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
860 Bool_t  AliESDv0KineCuts::GetHelixCenter(AliESDtrack * const track, Double_t b,Int_t charge, Double_t center[2]) const\r
861 {\r
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
889     /* avoid self assignment\r
890     if(charge < 0){\r
891       xpoint =  xpoint;\r
892       ypoint =  ypoint;\r
893     }\r
894     */\r
895   }\r
896   if(b>0){\r
897     /* avoid self assignment\r
898     if(charge > 0){\r
899       xpoint =  xpoint;\r
900       ypoint =  ypoint;\r
901     }\r
902     */\r
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
914 AliKFParticle *AliESDv0KineCuts::CreateMotherParticle(const AliVTrack* const pdaughter, const AliVTrack* const ndaughter, Int_t pspec, Int_t nspec) const\r
915 {\r
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
925   m->SetField(fEvent->GetMagneticField());\r
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
948 void  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
957 if (fUseExternalVertex) return;\r
958 else{\r
959         if(fPrimaryVertex && fDeleteVertex){\r
960                 delete  fPrimaryVertex;\r
961                 fPrimaryVertex=0x0;\r
962                 }\r
963         fPrimaryVertex = new AliKFVertex(*(fEvent->GetPrimaryVertex()));\r
964         fDeleteVertex=kTRUE;\r
965         }\r
966 \r
967 \r
968 \r
969 }\r
970 //____________________________________________________________________\r
971 void  AliESDv0KineCuts::SetEvent(AliVEvent* const event){\r
972   //\r
973   // direct setter of ESD event\r
974   //\r
975 \r
976   fEvent = dynamic_cast<AliESDEvent*>(event);\r
977   if(!fEvent){\r
978     AliErrorClass("Invalid input event pointer");\r
979     return;\r
980   }\r
981   \r
982   if (fUseExternalVertex) return;\r
983   else{\r
984     if(fPrimaryVertex && fDeleteVertex){\r
985       delete    fPrimaryVertex;\r
986       fPrimaryVertex=0x0;\r
987       }\r
988     fPrimaryVertex = new AliKFVertex(*(fEvent->GetPrimaryVertex()));\r
989     fDeleteVertex=kTRUE;\r
990   }\r
991 }\r
992 \r
993 \r
994 //________________________________________________________________\r
995 void     AliESDv0KineCuts::UseExternalVertex(Bool_t use_external){\r
996         //\r
997         // Reenable primary Vertex from ESD event\r
998         //\r
999         if (use_external) fUseExternalVertex =kTRUE;\r
1000         else fUseExternalVertex =kFALSE;\r
1001 }\r
1002 \r
1003 \r
1004 \r
1005 \r
1006 //________________________________________________________________\r
1007 void AliESDv0KineCuts::SetPrimaryVertex(AliKFVertex* const v){\r
1008   //\r
1009   // set the primary vertex of the event\r
1010   //\r
1011         if(fPrimaryVertex && fDeleteVertex){   \r
1012                 delete  fPrimaryVertex;\r
1013                 fPrimaryVertex =0x0;\r
1014                 fDeleteVertex = kFALSE;\r
1015                 }  \r
1016   fUseExternalVertex=kTRUE; \r
1017   fPrimaryVertex = v; // set primary Vertex\r
1018   if(!fPrimaryVertex){\r
1019     AliErrorClass("Failed to initialize the primary vertex");\r
1020     return;\r
1021   }\r
1022 }\r
1023 //___________________________________________________________________\r
1024 void AliESDv0KineCuts::SetMode(Int_t mode, Int_t type){\r
1025   //\r
1026   // this function allows the user to select (prior running the 'ProcessV0' function)\r
1027   // to select different approaches to V0 selection - the 'mode'\r
1028   // - and -\r
1029   // different systems (pp, PbPb) - 'type' \r
1030   //\r
1031   // To see the cut values for different modes please refer to the\r
1032   // function SetCuts()\r
1033   //\r
1034   // Important notice: based on the parameters particular sets of cuts will\r
1035   // be activated for teh V0 selection. If some additional changes to single\r
1036   // cuts are needed please us the SetXXXcut function (see the header file)\r
1037   // \r
1038 \r
1039   switch(mode){\r
1040   case kPurity:\r
1041     fMode = kPurity;  // used to obtain highest purity possible - the efficiency may be low\r
1042     break;\r
1043   case kEffGamma:\r
1044     fMode = kEffGamma; // used to obtain highes efficiency possible - the purity may be worse\r
1045     break;\r
1046   default:\r
1047     AliError("V0 selection mode not recognozed, setting 'kPurity'");\r
1048     fMode = kPurity;\r
1049   }\r
1050 \r
1051   switch(type){\r
1052   case kPP:\r
1053     fType = kPP;  // cuts optimized for low multiplicity \r
1054     break;\r
1055   case kPbPb:\r
1056     fType = kPbPb;  // cuts optimized for high multiplicity\r
1057     break;\r
1058   }\r
1059   \r
1060   // setup the cut values for selected mode & type\r
1061   SetCuts();\r
1062 \r
1063 }\r
1064 //___________________________________________________________________\r
1065 void AliESDv0KineCuts::SetMode(Int_t mode, const char* type){\r
1066   //\r
1067   // overloaded function - please see above\r
1068   // \r
1069   \r
1070   Int_t t = -1;\r
1071 \r
1072   if(!strcmp("pp", type)) t = kPP;\r
1073   else if(!(strcmp("PbPb", type))) t = kPbPb;\r
1074   else{\r
1075     AliError("data type not recognized, setting 'pp'");\r
1076     t = kPP;    \r
1077   }\r
1078 \r
1079   SetMode(mode, t);\r
1080 \r
1081 }\r
1082 //___________________________________________________________________\r
1083 void AliESDv0KineCuts::SetCuts(){\r
1084   //\r
1085   // this funciton sets the default cut values based on the selected\r
1086   // fMode and fType.\r
1087   // please note that only the cuts that have different values than the default\r
1088   // cuts are updated here\r
1089   //\r
1090   \r
1091   // last update: 14/02/2011\r
1092   // as a very preliminary  - the only change to default cuts is to apply\r
1093   // less restricting gamma conversion selection in PreselectV0() function\r
1094   \r
1095 \r
1096   \r
1097 }\r