Changes for task Optimization of V0 finder (2079) + plus fix for the bug number 47412...

diff --git a/ITS/AliITSRecoParam.cxx b/ITS/AliITSRecoParam.cxx
index 0b714f60e043cc4d86071a6b0f8b785c3abdd13d..cefa97babefdbf6dd9843a6a3eebabfe84fe7d91 100644 (file)
--- a/ITS/AliITSRecoParam.cxx
+++ b/ITS/AliITSRecoParam.cxx
@@ -214,12 +214,30 @@ fESDV0Params(NULL)
   fESDV0Params->SetMinPointAngle2(0.99);
   fESDV0Params->SetMinR(0.5);
   fESDV0Params->SetMaxR(220.);
+  fESDV0Params->SetMinPABestConst(0.9999);
+  fESDV0Params->SetMaxRBestConst(10.);
   fESDV0Params->SetCausality0Cut(0.19);
   fESDV0Params->SetLikelihood01Cut(0.45);
   fESDV0Params->SetLikelihood1Cut(0.5);  
   fESDV0Params->SetCombinedCut(0.55);
   fESDV0Params->SetMinClFullTrk(5.0);
   fESDV0Params->SetMinTgl0(1.05);
+  fESDV0Params->SetMinRTgl0(40.0);
+
+  fESDV0Params->SetMinNormDistForbTgl0(3.0);
+  fESDV0Params->SetMinClForb0(4.5);
+  fESDV0Params->SetMinNormDistForb1(3.0);
+  fESDV0Params->SetMinNormDistForb2(2.0);
+  fESDV0Params->SetMinNormDistForb3(1.0);
+  fESDV0Params->SetMinNormDistForb4(4.0);
+  fESDV0Params->SetMinNormDistForb5(5.0);
+
+  fESDV0Params->SetMinRTPCdensity(40.);
+  fESDV0Params->SetMaxRTPCdensity0(110.);
+  fESDV0Params->SetMaxRTPCdensity10(120.);
+  fESDV0Params->SetMaxRTPCdensity20(130.);
+  fESDV0Params->SetMaxRTPCdensity30(140.);
+
   fESDV0Params->SetMinTPCdensity(0.6);
   fESDV0Params->SetMinTgl1(1.1);
   fESDV0Params->SetMinTgl2(1.0);
@@ -236,6 +254,7 @@ fESDV0Params(NULL)
   fESDV0Params->SetSigpPar0(0.5);
   fESDV0Params->SetSigpPar1(0.6);
   fESDV0Params->SetSigpPar2(0.4);
+  fESDV0Params->SetMaxDcaLh0(0.5);
   fESDV0Params->SetStreamLevel(0);
   fESDV0Params->SetChi2KF(100);
   fESDV0Params->SetRobustChi2KF(100);
@@ -349,6 +368,8 @@ AliITSRecoParam *AliITSRecoParam::GetHighFluxParam()
   param->fSigmaXDeadZoneHit2 = 0.004/12.;
   param->fSigmaZDeadZoneHit2 = 0.001/12.;
   param->fXPassDeadZoneHits = 0.018;
+
+
   
   return param;
 }
@@ -452,6 +473,21 @@ AliITSRecoParam *AliITSRecoParam::GetLowFluxParam()
   param->SetNLoopsSA(20);
   param->fMaxPhiSA = 0.07;
   param->fMaxLambdaSA = 0.04;
+
+ 
+  param->GetESDV0Params()->SetMinRTgl0(0.5);
+  param->GetESDV0Params()->SetMaxDist(1.5);
+  param->GetESDV0Params()->SetMaxDcaLh0(1.5);
+  param->GetESDV0Params()->SetMaxRBestConst(80);
+  param->GetESDV0Params()->SetMinPABestConst(0.99);
+  param->GetESDV0Params()->SetMinNormDistForbTgl0(1.);
+  param->GetESDV0Params()->SetMinNormDistForb1(2.);
+  param->GetESDV0Params()->SetLikelihood01Cut(0.3);
+  param->GetESDV0Params()->SetLikelihood1Cut(0.35);
+  param->GetESDV0Params()->SetCombinedCut(0.4);
+
+
+
   return param;
 }
 //_____________________________________________________________________________

diff --git a/ITS/AliITSV0Finder.cxx b/ITS/AliITSV0Finder.cxx
index 60b4ffea59717486259a3a2f79a1ba6f57888232..113200de1b2cb7621ac5e6cde637f213105757bc 100644 (file)
--- a/ITS/AliITSV0Finder.cxx
+++ b/ITS/AliITSV0Finder.cxx
@@ -39,6 +39,7 @@
 #include "AliITStrackerMI.h"\r
 #include "AliITSV0Finder.h"\r
 #include "AliKFParticle.h"\r
+#include "AliKFVertex.h"\r
 \r
 ClassImp(AliITSV0Finder)\r
 \r
@@ -186,12 +187,31 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
   const Float_t kMinPointAngle2 = AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinPointAngle2();\r
   const Float_t kMinR = AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinR();\r
   const Float_t kMaxR = AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMaxR();\r
+  const Float_t kMinPABestConst = AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinPABestConst();\r
+  const Float_t kMaxRBestConst = AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMaxRBestConst();\r
   const Float_t kCausality0Cut = AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetCausality0Cut();\r
   const Float_t kLikelihood01Cut = AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetLikelihood01Cut();\r
   const Float_t kLikelihood1Cut = AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetLikelihood1Cut();\r
   const Float_t kCombinedCut = AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetCombinedCut();\r
   const Float_t kMinClFullTrk= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinClFullTrk();\r
   const Float_t kMinTgl0= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinTgl0();\r
+  const Float_t kMinRTgl0= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinRTgl0();\r
+\r
+  const Float_t kMinNormDistForbTgl0= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinNormDistForbTgl0();\r
+  const Float_t kMinClForb0= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinClForb0();\r
+  const Float_t kMinNormDistForb1= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinNormDistForb1();\r
+  const Float_t kMinNormDistForb2= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinNormDistForb2();\r
+  const Float_t kMinNormDistForb3= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinNormDistForb3();\r
+  const Float_t kMinNormDistForb4= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinNormDistForb4();\r
+  const Float_t kMinNormDistForb5= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinNormDistForb5();\r
+\r
+  const Float_t kMinRTPCdensity= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinRTPCdensity();\r
+  const Float_t kMaxRTPCdensity0= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMaxRTPCdensity0();\r
+  const Float_t kMaxRTPCdensity10= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMaxRTPCdensity10();\r
+  const Float_t kMaxRTPCdensity20= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMaxRTPCdensity20();\r
+  const Float_t kMaxRTPCdensity30= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMaxRTPCdensity30();\r
+\r
+\r
   const Float_t kMinTPCdensity= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinTPCdensity();\r
   const Float_t kMinTgl1= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMinTgl1();\r
 \r
@@ -210,7 +230,8 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
   const Float_t kSigpPar0= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetSigpPar0();\r
   const Float_t kSigpPar1= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetSigpPar1();\r
   const Float_t kSigpPar2= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetSigpPar2();\r
- \r
+  const Float_t kMaxDcaLh0= AliITSReconstructor::GetRecoParam()->GetESDV0Params()->GetMaxDcaLh0();\r
+\r
 \r
   TObjArray *trackHypothesys = tracker->GetTrackHypothesys();\r
   TObjArray *bestHypothesys  = tracker->GetBestHypothesys();\r
@@ -228,6 +249,9 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
   TObjArray trackarray(ntracks+2);     //array with tracks - with vertex constrain\r
   TObjArray trackarrayc(ntracks+2);    //array of "best    tracks" - without vertex constrain\r
   TObjArray trackarrayl(ntracks+2);    //array of "longest tracks" - without vertex constrain\r
+  //Change from Bool_t to Int_t for optimization\r
+  //  Int_t forbN=0;\r
+  //  Int_t * forbidden   = new Int_t [ntracks+2];\r
   Bool_t * forbidden   = new Bool_t [ntracks+2];\r
   Int_t   *itsmap      = new Int_t  [ntracks+2];\r
   Float_t *dist        = new Float_t[ntracks+2];\r
@@ -250,6 +274,7 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
   //\r
   for (Int_t itrack=0;itrack<ntracks+2;itrack++) {\r
     itsmap[itrack]        = -1;\r
+    //    forbidden[itrack]     = 0;\r
     forbidden[itrack]     = kFALSE;\r
     maxr[itrack]          = kMaxR;\r
     minr[itrack]          = kMinR;\r
@@ -298,7 +323,7 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
       AliITStrackMI * trackh = (AliITStrackMI*)array->At(ih);\r
       if (!trackh->GetConstrain()) continue;\r
       if (!bestConst) bestConst = trackh;\r
-      if (trackh->GetNumberOfClusters()>kMinClFullTrk){\r
+      if (trackh->GetNumberOfClusters()>kMinClFullTrk ){\r
        bestConst  = trackh;                         // full track -  with minimal chi2\r
        break;\r
       }\r
@@ -327,6 +352,8 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
     new (&trackat0) AliITStrackMI(*bestLong);\r
     Double_t xx,yy,zz,alpha; \r
     if (!bestLong->GetGlobalXYZat(bestLong->GetX(),xx,yy,zz)) continue;\r
+    \r
+\r
     alpha = TMath::ATan2(yy,xx);    \r
     //    if (!trackat0.Propagate(alpha,0)) continue;    \r
     trackat0.Propagate(alpha,0); //PH The check on the return value is temporarily disabled (bug 45751) \r
@@ -362,13 +389,19 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
        normdist1[itsindex] = TMath::Abs((trackat0.GetZ()-primvertex[2])/(ptfac*TMath::Sqrt(trackat0.GetSigmaZ2())));\r
        normdist[itsindex]  = TMath::Sqrt(normdist0[itsindex]*normdist0[itsindex]+normdist1[itsindex]*normdist1[itsindex]);\r
        if (TMath::Abs(trackat0.GetTgl())>kMinTgl0){\r
-         if (normdist[itsindex]<3) forbidden[itsindex]=kTRUE;\r
-         if (normdist[itsindex]>3) {\r
-           minr[itsindex] = TMath::Max(Float_t(40.),minr[itsindex]);\r
+         if (normdist[itsindex]<kMinNormDistForbTgl0){\r
+           //      forbN=1;\r
+           //      forbidden[itsindex]+=1<<forbN;\r
+           forbidden[itsindex]=kTRUE;\r
+         }\r
+         if (normdist[itsindex]>kMinNormDistForbTgl0) {\r
+           minr[itsindex] = TMath::Max(kMinRTgl0,minr[itsindex]);\r
          }\r
        }\r
       }\r
     }\r
+\r
+\r
     //\r
     //-----------------------------------------------------------\r
     //Forbid primary track candidates - \r
@@ -381,15 +414,39 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
     //treetr->SetAlias("forbidden5","ND<5&&Tr1.fNormChi2[0]<1");\r
     //-----------------------------------------------------------\r
     if (bestConst){\r
-      if (bestLong->GetNumberOfClusters()<4       && bestConst->GetNumberOfClusters()+bestConst->GetNDeadZone()>4.5)               forbidden[itsindex]=kTRUE;\r
-      if (normdist[itsindex]<3 && bestConst->GetNumberOfClusters()+bestConst->GetNDeadZone()>5.5)               forbidden[itsindex]=kTRUE;\r
-      if (normdist[itsindex]<2 && bestConst->GetClIndex(0)>=0 && bestConst->GetClIndex(1)>=0 ) forbidden[itsindex]=kTRUE;\r
-      if (normdist[itsindex]<1 && bestConst->GetClIndex(0)>=0)                              forbidden[itsindex]=kTRUE;\r
-      if (normdist[itsindex]<4 && bestConst->GetNormChi2(0)<2)                             forbidden[itsindex]=kTRUE;\r
-      if (normdist[itsindex]<5 && bestConst->GetNormChi2(0)<1)                             forbidden[itsindex]=kTRUE;      \r
+      if (bestLong->GetNumberOfClusters()<4 && bestConst->GetNumberOfClusters()+bestConst->GetNDeadZone()>kMinClForb0){\r
+       //      forbN=2;\r
+       //      forbidden[itsindex]+=1<<forbN;\r
+       forbidden[itsindex]=kTRUE;\r
+      }\r
+      if (normdist[itsindex]<kMinNormDistForb1 && bestConst->GetNumberOfClusters()+bestConst->GetNDeadZone()>5.5){\r
+       //      forbN=3;\r
+       //      forbidden[itsindex]+=1<<forbN;\r
+       forbidden[itsindex]=kTRUE;\r
+      }\r
+      if (normdist[itsindex]<kMinNormDistForb2 && bestConst->GetClIndex(0)>=0 && bestConst->GetClIndex(1)>=0 ){\r
+       //      forbN=4;\r
+       //      forbidden[itsindex]+=1<<forbN;\r
+       forbidden[itsindex]=kTRUE;\r
+      }\r
+      if (normdist[itsindex]<kMinNormDistForb3 && bestConst->GetClIndex(0)>=0){\r
+       //      forbN=5;\r
+       //      forbidden[itsindex]+=1<<forbN;\r
+       forbidden[itsindex]=kTRUE;\r
+      }\r
+      if (normdist[itsindex]<kMinNormDistForb4 && bestConst->GetNormChi2(0)<2){\r
+       //      forbN=6;\r
+       //      forbidden[itsindex]+=1<<forbN;\r
+       forbidden[itsindex]=kTRUE;\r
+      }\r
+      if (normdist[itsindex]<kMinNormDistForb5 && bestConst->GetNormChi2(0)<1){\r
+       //      forbN=7;\r
+       //      forbidden[itsindex]+=1<<forbN;\r
+       forbidden[itsindex]=kTRUE;\r
+      }\r
       if (bestConst->GetNormChi2(0)<2.5) {\r
-       minPointAngle[itsindex]= 0.9999;\r
-       maxr[itsindex]         = 10;\r
+       minPointAngle[itsindex]= kMinPABestConst;\r
+       maxr[itsindex]         = kMaxRBestConst;\r
       }\r
     }\r
     //\r
@@ -416,14 +473,15 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
     //\r
     // Causality cuts in TPC volume\r
     //\r
-    if (esdtrack->GetTPCdensity(0,10) >kMinTPCdensity)  maxr[itsindex] = TMath::Min(Float_t(110),maxr[itsindex]);\r
-    if (esdtrack->GetTPCdensity(10,30)>kMinTPCdensity)  maxr[itsindex] = TMath::Min(Float_t(120),maxr[itsindex]);\r
-    if (esdtrack->GetTPCdensity(20,40)>kMinTPCdensity)  maxr[itsindex] = TMath::Min(Float_t(130),maxr[itsindex]);\r
-    if (esdtrack->GetTPCdensity(30,50)>kMinTPCdensity)  maxr[itsindex] = TMath::Min(Float_t(140),maxr[itsindex]);\r
+    if (esdtrack->GetTPCdensity(0,10) >kMinTPCdensity)  maxr[itsindex] = TMath::Min(Float_t(kMaxRTPCdensity0),maxr[itsindex]);\r
+    if (esdtrack->GetTPCdensity(10,30)>kMinTPCdensity)  maxr[itsindex] = TMath::Min(Float_t(kMaxRTPCdensity10),maxr[itsindex]);\r
+    if (esdtrack->GetTPCdensity(20,40)>kMinTPCdensity)  maxr[itsindex] = TMath::Min(Float_t(kMaxRTPCdensity20),maxr[itsindex]);\r
+    if (esdtrack->GetTPCdensity(30,50)>kMinTPCdensity)  maxr[itsindex] = TMath::Min(Float_t(kMaxRTPCdensity30),maxr[itsindex]);\r
     //\r
-    if (esdtrack->GetTPCdensity(0,60)<0.4&&bestLong->GetNumberOfClusters()<3) minr[itsindex]=100;    \r
+    if (esdtrack->GetTPCdensity(0,60)<0.4&&bestLong->GetNumberOfClusters()<3) minr[itsindex]=kMinRTPCdensity;    \r
     //\r
     //\r
+\r
     if (AliITSReconstructor::GetRecoParam()->GetESDV0Params()->StreamLevel()>0){\r
       cstream<<"Track"<<\r
        "Tr0.="<<best<<\r
@@ -450,28 +508,33 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
   //\r
   // first iterration of V0 finder\r
   //\r
-\r
-\r
+  // AM Comment out for optimization\r
+  //  Int_t rejectBase=0;\r
+  //  Int_t cutN=0;\r
 \r
   for (Int_t iesd0=0;iesd0<ntracks;iesd0++){\r
     Int_t itrack0 = itsmap[iesd0];\r
+    //-AM comment for optimization and store the forbidden value in the debug streamer\r
     if (forbidden[itrack0]) continue;\r
     AliITStrackMI * btrack0 = (AliITStrackMI*)trackarray.At(itrack0);\r
     if (!btrack0) continue;    \r
-    if (btrack0->GetSign()>0 && !AliITSReconstructor::GetRecoParam()->GetStoreLikeSignV0s()) continue;\r
     AliITStrackMI *trackc0 = (AliITStrackMI*)trackarrayc.At(itrack0);\r
     //\r
     for (Int_t iesd1=iesd0+1;iesd1<ntracks;iesd1++){\r
       Int_t itrack1 = itsmap[iesd1];\r
+      //-AM comment for optimization and store the forbidden value in the debug streamer\r
       if (forbidden[itrack1]) continue;\r
 \r
       AliITStrackMI * btrack1 = (AliITStrackMI*)trackarray.At(itrack1); \r
       if (!btrack1) continue;\r
-      if (btrack1->GetSign()<0 && !AliITSReconstructor::GetRecoParam()->GetStoreLikeSignV0s()) continue;\r
+\r
+      if ( (btrack0->GetSign()==btrack1->GetSign()) && !AliITSReconstructor::GetRecoParam()->GetStoreLikeSignV0s()) continue;\r
+\r
       Bool_t isGold = kFALSE;\r
       if (TMath::Abs(TMath::Abs(btrack0->GetLabel())-TMath::Abs(btrack1->GetLabel()))==1){\r
        isGold = kTRUE;\r
       }\r
+      //      rejectBase=0;\r
       AliITStrackMI *trackc1 = (AliITStrackMI*)trackarrayc.At(itrack1);\r
       AliHelix &h1 = helixes[itrack0];\r
       AliHelix &h2 = helixes[itrack1];\r
@@ -483,7 +546,11 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
       //\r
       Double_t phase[2][2],radius[2];\r
       Int_t  points = h1.GetRPHIintersections(h2, phase, radius);\r
-      if    (points==0)  continue;\r
+      if    (points==0) {\r
+       //      cutN=1;\r
+       //      rejectBase+=1<<cutN;\r
+       continue;\r
+      }\r
       Double_t delta[2]={1000000,1000000};        \r
       rmin = radius[0];\r
       h1.ParabolicDCA(h2,phase[0][0],phase[0][1],radius[0],delta[0]);\r
@@ -503,12 +570,28 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
        radiusC  = TMath::Sqrt(radius[1]);\r
        iphase=1;\r
       }\r
-      if (radiusC<TMath::Max(minr[itrack0],minr[itrack1]))    continue;\r
-      if (radiusC>TMath::Min(maxr[itrack0],maxr[itrack1]))     continue; \r
+      if (radiusC<TMath::Max(minr[itrack0],minr[itrack1])){\r
+       //      cutN=2;\r
+       //rejectBase+=1<<cutN;\r
+       continue;\r
+      }\r
+      if (radiusC>TMath::Min(maxr[itrack0],maxr[itrack1])){\r
+       //      cutN=3;\r
+       //      rejectBase+=1<<cutN;\r
+       continue;\r
+      } \r
       Float_t maxDist  = TMath::Min(kMaxDist,Float_t(kMaxDist0+radiusC*kMaxDist1));      \r
-      if (distance>maxDist) continue;\r
+      if (distance>maxDist){\r
+       //      cutN=4;\r
+       //      rejectBase+=1<<cutN;\r
+       continue;\r
+      }\r
       Float_t pointAngle = h1.GetPointAngle(h2,phase[iphase],primvertex);\r
-      if (pointAngle<TMath::Max(minPointAngle[itrack0],minPointAngle[itrack1])) continue;\r
+      if (pointAngle<TMath::Max(minPointAngle[itrack0],minPointAngle[itrack1])) {\r
+       //      cutN=5;\r
+       //      rejectBase+=1<<cutN;\r
+       continue;\r
+      }\r
       //\r
       //\r
       //      Double_t distance = TestV0(h1,h2,pvertex,rmin);\r
@@ -534,18 +617,95 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
       pvertex->Update(primvertex);\r
       pvertex->SetClusters(track0->ClIndex(),track1->ClIndex());  // register clusters\r
 \r
-      AliKFParticle negKF( *(pvertex->GetParamN()) ,11);\r
-      AliKFParticle posKF( *(pvertex->GetParamP()) ,-11);\r
+      // Define gamma, K0, lambda and lambda_bar from the decay particles and calculate the chi2      \r
+      AliKFVertex vertexKF;\r
+\r
+      vertexKF.X() = tracker->GetX();\r
+      vertexKF.Y() = tracker->GetY();\r
+      vertexKF.Z() = tracker->GetZ();\r
+      vertexKF.Covariance(0,0) = tracker->GetSigmaX()*tracker->GetSigmaX();\r
+      vertexKF.Covariance(1,2) = tracker->GetSigmaY()*tracker->GetSigmaY();\r
+      vertexKF.Covariance(2,2) = tracker->GetSigmaZ()*tracker->GetSigmaZ();\r
+      \r
+      AliKFParticle elecKF( *(pvertex->GetParamN()) ,11);\r
+      AliKFParticle posiKF( *(pvertex->GetParamP()) ,-11);\r
+      AliKFParticle pipKF( *(pvertex->GetParamN()) , 211);\r
+      AliKFParticle pinKF( *(pvertex->GetParamP()) ,-211);\r
+      AliKFParticle protKF( *(pvertex->GetParamP()) ,2212);\r
+      AliKFParticle aproKF ( *(pvertex->GetParamN()) ,-2212);\r
+\r
+\r
+      // Gamma\r
+      AliKFParticle gamKF(elecKF,posiKF);\r
+      gamKF.SetProductionVertex(vertexKF);\r
+\r
+      Float_t gamKFchi2 = 1000;\r
+      if ( gamKF.GetNDF()!=0 ){\r
+       gamKFchi2 = gamKF.GetChi2()/gamKF.GetNDF();\r
+      }\r
+\r
+      Float_t massG=0.;\r
+      Float_t sigmaMG=0.001;\r
+      gamKF.SetMassConstraint(massG,sigmaMG);\r
+\r
+      Float_t gamKFchi2C = 1000;\r
+      if ( gamKF.GetNDF()!=0 ){\r
+       gamKFchi2C = gamKF.GetChi2()/gamKF.GetNDF();\r
+      }\r
+\r
+      //K0 short\r
+      AliKFParticle k0KF(pipKF,pinKF);\r
+      k0KF.SetProductionVertex(vertexKF);\r
+\r
+      Float_t k0KFchi2 = 1000;\r
+      if ( k0KF.GetNDF()!=0 ){\r
+       k0KFchi2 = k0KF.GetChi2()/k0KF.GetNDF();\r
+      }\r
+\r
+      //Lambda\r
+      AliKFParticle lambdaKF(protKF,pinKF);\r
+      lambdaKF.SetProductionVertex(vertexKF);\r
+\r
+      Float_t lambdaKFchi2 = 1000;\r
+      if ( lambdaKF.GetNDF()!=0 ){\r
+       lambdaKFchi2 = lambdaKF.GetChi2()/lambdaKF.GetNDF();\r
+      }\r
+\r
+      //Lambda_bar\r
+      AliKFParticle alambKF(aproKF,pipKF);\r
+      alambKF.SetProductionVertex(vertexKF);\r
+\r
+      Float_t alambKFchi2 = 1000;\r
+      if ( alambKF.GetNDF()!=0 ){\r
+       alambKFchi2 = alambKF.GetChi2()/alambKF.GetNDF();\r
+      }\r
 \r
-      AliKFParticle v0KF(negKF,posKF);\r
-      Float_t v0KFchi2= v0KF.GetChi2();\r
 \r
 \r
-      if (pvertex->GetRr()<kMinR) continue;\r
-      if (pvertex->GetRr()>kMaxR) continue;\r
-      if (pvertex->GetV0CosineOfPointingAngle()<kMinPointAngle) continue;\r
+\r
+\r
+      if (pvertex->GetRr()<kMinR){\r
+       //      cutN=6;\r
+       //      rejectBase+=1<<cutN;\r
+       continue;\r
+      }\r
+      if (pvertex->GetRr()>kMaxR){\r
+       //      cutN=7;\r
+       //      rejectBase+=1<<cutN;\r
+       continue;\r
+      }\r
+      if (pvertex->GetV0CosineOfPointingAngle()<kMinPointAngle){\r
+       //      cutN=8;\r
+       //      rejectBase+=1<<cutN;\r
+       continue;\r
+      }\r
 //Bo:      if (pvertex->GetDist2()>maxDist) continue;\r
-      if (pvertex->GetDcaV0Daughters()>maxDist) continue;\r
+\r
+      if (pvertex->GetDcaV0Daughters()>maxDist){\r
+       //      cutN=9;\r
+       //      rejectBase+=1<<cutN;\r
+       continue;\r
+      }\r
 //Bo:        pvertex->SetLab(0,track0->GetLabel());\r
 //Bo:        pvertex->SetLab(1,track1->GetLabel());\r
       pvertex->SetIndex(0,track0->GetESDtrack()->GetID());\r
@@ -741,7 +901,13 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
       //\r
       //  Likelihood calculations  - apply cuts\r
       //         \r
+ \r
+      // AM - Comment out for optimization and store the v0OK value\r
+      //      Int_t v0OK = 0;\r
+      //      Int_t cutOKN=0;\r
       Bool_t v0OK = kTRUE;\r
+\r
+\r
       Float_t p12 = pvertex->GetParamP()->GetParameter()[4]*pvertex->GetParamP()->GetParameter()[4];\r
       p12        += pvertex->GetParamN()->GetParameter()[4]*pvertex->GetParamN()->GetParameter()[4];\r
       p12         = TMath::Sqrt(p12);                             // "mean" momenta\r
@@ -756,18 +922,33 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
       //\r
       //Bo:      Float_t likelihood0 = (TMath::Exp(-pvertex->GetDistNorm())+0.1) *(pvertex->GetDist2()<0.5)*(pvertex->GetDistNorm()<5);\r
       Float_t lDistNorm = pvertex->GetDcaV0Daughters()/pvertex->GetDistSigma();\r
-      Float_t likelihood0 = (TMath::Exp(-lDistNorm)+0.1) *(pvertex->GetDcaV0Daughters()<0.5)*(lDistNorm<5);\r
+      Float_t likelihood0 = (TMath::Exp(-lDistNorm)+0.1) *(pvertex->GetDcaV0Daughters()<kMaxDcaLh0)*(lDistNorm<5);\r
 \r
       Float_t likelihood1 = TMath::Exp(-(1.0001-pvertex->GetV0CosineOfPointingAngle())/sigmap)+\r
        0.4*TMath::Exp(-(1.0001-pvertex->GetV0CosineOfPointingAngle())/(4.*sigmap))+\r
        0.4*TMath::Exp(-(1.0001-pvertex->GetV0CosineOfPointingAngle())/(8.*sigmap))+\r
        0.1*TMath::Exp(-(1.0001-pvertex->GetV0CosineOfPointingAngle())/0.01);\r
       //\r
-      if (causalityA<kCausality0Cut)                                          v0OK = kFALSE;\r
-      if (TMath::Sqrt(likelihood0*likelihood1)<kLikelihood01Cut)              v0OK = kFALSE;\r
-      if (likelihood1<kLikelihood1Cut)                                        v0OK = kFALSE;\r
-      if (TMath::Power(likelihood0*likelihood1*causalityB,0.33)<kCombinedCut) v0OK = kFALSE;\r
-      \r
+      if (causalityA<kCausality0Cut){\r
+       //      cutOKN=1;\r
+       //      v0OK += 1<<cutOKN;\r
+       v0OK = kFALSE;\r
+      }\r
+      if (TMath::Sqrt(likelihood0*likelihood1)<kLikelihood01Cut){\r
+       //      cutOKN=2;\r
+       //      v0OK += 1<<cutOKN;\r
+       v0OK = kFALSE;\r
+      }\r
+      if (likelihood1<kLikelihood1Cut){\r
+       //      cutOKN=3;\r
+       //      v0OK += 1<<cutOKN;\r
+       v0OK = kFALSE;\r
+      }\r
+      if (TMath::Power(likelihood0*likelihood1*causalityB,0.33)<kCombinedCut){\r
+       //      cutOKN=4;\r
+       //      v0OK += 1<<cutOKN;\r
+       v0OK = kFALSE;\r
+      }\r
       //\r
       //\r
       if (AliITSReconstructor::GetRecoParam()->GetESDV0Params()->StreamLevel()>0){     \r
@@ -775,8 +956,8 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
        cstream<<"It0"<<\r
          "Tr0.="<<track0<<                       //best without constrain\r
          "Tr1.="<<track1<<                       //best without constrain  \r
-         "posKF.="<<&posKF<<                       //KF from track0\r
-         "negKF.="<<&negKF<<                       //KF from track1\r
+         "posiKF.="<<&posiKF<<                       //KF from track0\r
+         "elecKF.="<<&elecKF<<                       //KF from track1\r
          "Tr0B.="<<track0b<<                     //best without constrain  after vertex\r
          "Tr1B.="<<track1b<<                     //best without constrain  after vertex \r
          "Tr0C.="<<htrackc0<<                    //best with constrain     if exist\r
@@ -787,18 +968,28 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
          "Esd1.="<<track1->GetESDtrack()<<           // esd track1 params\r
          "V0.="<<pvertex<<                       //vertex properties\r
          "V0b.="<<&vertex2<<                       //vertex properties at "best" track\r
-         "v0KF.="<<&v0KF<<                          //KF from pvertex\r
-         "chiKF.="<<v0KFchi2<<              // chi2 from KF\r
+         "gamKF.="<<&gamKF<<                          //KF from pvertex\r
+         "k0KF.="<<&k0KF<<                          //KF from pvertex\r
+         "lambdaKF.="<<&lambdaKF<<                          //KF from pvertex\r
+         "alambKF.="<<&lambdaKF<<                          //KF from pvertex\r
+         "gamKFchi2="<<gamKFchi2<<    //Normalized chi2 from KF assuming gamma momther\r
+         "gamKFchi2C="<<gamKFchi2C<<    //Normalized chi2 from KF assuming gamma mother+mass constraint\r
+         "k0KFchi2="<<k0KFchi2<<    //Normalized chi2 from KF assuming K0 mother\r
+         "lambdaKFchi2="<<lambdaKFchi2<<    //Normalized chi2 from KF assuming Lambda mother\r
+         "alambKFchi2="<<alambKFchi2<<    //Normalized chi2 from KF assuming lambda_bar mother\r
          "ND0="<<normdist[itrack0]<<             //normalize distance for track0\r
          "ND1="<<normdist[itrack1]<<             //normalize distance for track1\r
          "Gold="<<gold<<                         //\r
-         //      "RejectBase="<<rejectBase<<             //rejection in First itteration\r
+         // "RejectBase="<<rejectBase<<             //rejection in First itteration\r
          "OK="<<v0OK<<\r
          "rmin="<<rmin<<\r
          "sigmad="<<sigmad<<\r
+         "Forbid0="<<forbidden[itrack0]<<\r
+         "Forbid1="<<forbidden[itrack1]<<\r
          "\n";\r
       }      \r
-      //if (rejectBase) continue;\r
+      //      if (rejectBase>0) continue;\r
+      //if (forbidden[itrack0]>0 ||forbidden[itrack1]>0) continue; \r
       //\r
       pvertex->SetStatus(0);\r
       //      if (rejectBase) {\r
@@ -808,6 +999,7 @@ void AliITSV0Finder::FindV02(AliESDEvent *event,
        //Bo:     pvertex->SetESDindexes(track0->GetESDtrack()->GetID(),track1->GetESDtrack()->GetID());\r
        pvertex->SetIndex(0,track0->GetESDtrack()->GetID());//Bo: consistency 0 for neg\r
        pvertex->SetIndex(1,track1->GetESDtrack()->GetID());//Bo: consistency 1 for pos\r
+       //      if (v0OK==0){\r
        if (v0OK){\r
          //      AliV0vertex vertexjuri(*track0,*track1);\r
          //      vertexjuri.SetESDindexes(track0->fESDtrack->GetID(),track1->fESDtrack->GetID());\r

diff --git a/ITS/AliITSV0Finder.h b/ITS/AliITSV0Finder.h
index ff6ac450baf90503addccbeed0d7c9a679a659ef..294c1ddf03cad987d383112d4fcc73d13a033cdb 100644 (file)
--- a/ITS/AliITSV0Finder.h
+++ b/ITS/AliITSV0Finder.h
@@ -1,46 +1,46 @@
-#ifndef ALIITSV0FINDER_H\r
-#define ALIITSV0FINDER_H\r
-/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *\r
- * See cxx source for full Copyright notice                               */\r
-\r
-\r
-//-------------------------------------------------------------------------\r
-//                V0 finder on-the-fly during ITS tracking\r
-//           Origin: Marian Ivanov, CERN, Marian.Ivanov@cern.ch\r
-//           Extraction to a separate class: Andrea Dainese\r
-//           Current support and development: \r
-//-------------------------------------------------------------------------\r
-\r
-/* $Id$ */\r
-\r
-class TTree;\r
-class TTreeSRedirector;\r
-class AliESDEvent;\r
-class AliITStrackerMI;\r
-\r
-//-------------------------------------------------------------------------\r
-class AliITSV0Finder : public TObject {\r
-public:\r
-  AliITSV0Finder(); \r
-  virtual ~AliITSV0Finder();\r
-\r
-  //try to find V0\r
-  static void FindV02(AliESDEvent *event,AliITStrackerMI *tracker);  \r
-  //try to refit  V0's\r
-  static void RefitV02(const AliESDEvent *event,AliITStrackerMI *tracker);\r
-  //try to update, or reject TPC  V0s\r
-  static void UpdateTPCV0(const AliESDEvent *event,AliITStrackerMI *tracker);  \r
-\r
-  TTreeSRedirector *GetDebugStreamer() {return fDebugStreamer;}\r
-\r
-  TTreeSRedirector *fDebugStreamer;      //!debug streamer\r
- \r
-\r
-private:\r
-\r
-  AliITSV0Finder(const AliITSV0Finder & itsV0finder);\r
-  AliITSV0Finder & operator=(const AliITSV0Finder & itsV0finder);\r
-  \r
-  ClassDef(AliITSV0Finder,0)   // on-the-fly V0 finder for AliITStrackerMI\r
-};\r
-#endif\r
+#ifndef ALIITSV0FINDER_H
+#define ALIITSV0FINDER_H
+/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+
+//-------------------------------------------------------------------------
+//                V0 finder on-the-fly during ITS tracking
+//           Origin: Marian Ivanov, CERN, Marian.Ivanov@cern.ch
+//           Extraction to a separate class: Andrea Dainese
+//           Current support and development: 
+//-------------------------------------------------------------------------
+
+/* $Id$ */
+
+class TTree;
+class TTreeSRedirector;
+class AliESDEvent;
+class AliITStrackerMI;
+
+//-------------------------------------------------------------------------
+class AliITSV0Finder : public TObject {
+public:
+  AliITSV0Finder();
+  //AliITSV0Finder(const AliITSV0Finder &/*v0Finder*/) {;}
+  //AliITSV0Finder & operator=(const AliITSV0Finder &/*v0Finder*/) {;}
+ 
+  virtual ~AliITSV0Finder();
+
+  //try to find V0
+  static void FindV02(AliESDEvent *event,AliITStrackerMI *tracker);  
+  //try to refit  V0's
+  static void RefitV02(const AliESDEvent *event,AliITStrackerMI *tracker);
+  //try to update, or reject TPC  V0s
+  static void UpdateTPCV0(const AliESDEvent *event,AliITStrackerMI *tracker);  
+
+  TTreeSRedirector *GetDebugStreamer() {return fDebugStreamer;}
+
+  TTreeSRedirector *fDebugStreamer;      //!debug streamer
+ 
+
+private:
+ 
+  ClassDef(AliITSV0Finder,0)   // on-the-fly V0 finder for AliITStrackerMI
+};
+#endif

diff --git a/STEER/AliESDV0Params.cxx b/STEER/AliESDV0Params.cxx
index d47ee034d3007c0862609ad67aed5dce2a619b91..9517a4d19e75933c389a17cdce8fd75f00f8a0e0 100644 (file)
--- a/STEER/AliESDV0Params.cxx
+++ b/STEER/AliESDV0Params.cxx
@@ -31,7 +31,7 @@
 
 ClassImp(AliESDV0Params)
 
-Int_t    AliESDV0Params::fgStreamLevel     = 0;        // stream (debug) level
+
 
 
 AliESDV0Params::AliESDV0Params() :
@@ -66,7 +66,61 @@ AliESDV0Params::AliESDV0Params() :
   fPMinAP0(0.003),
   fPMinFractionD0(0.5),
   fPMaxFractionD0(1.5),
-  fPMinD0(0.05)
+  fPMinD0(0.05),
+  fkMaxDist0(0.1),
+  fkMaxDist1(0.1),
+  fkMaxDist(1.),
+  fkMinPointAngle(0.85),
+  fkMinPointAngle2(0.99),
+  fkMinR(0.5),
+  fkMaxR(220.),
+  fkMinPABestConst(0.9999),
+  fkMaxRBestConst(10.),
+  fkCausality0Cut(0.19),
+  fkLikelihood01Cut(0.45),
+  fkLikelihood1Cut(0.5),
+  fkCombinedCut(0.55),
+  fkMinClFullTrk(5.0),
+  fkMinTgl0(1.05),
+  
+  fkMinClForb0(4.5),
+  fkMinRTgl0(40.), 
+  fkMinNormDistForbTgl0(3.0),
+  fkMinNormDistForb1(3.0),
+  fkMinNormDistForb2(2.0),
+  fkMinNormDistForb3(1.0),
+  fkMinNormDistForb4(4.0),
+  fkMinNormDistForb5(5.0),
+  
+  fkMinRTPCdensity(40.),
+  fkMaxRTPCdensity0(110.),
+  fkMaxRTPCdensity10(120.),
+  fkMaxRTPCdensity20(130.),
+  fkMaxRTPCdensity30(140.),
+  
+  fkMinTPCdensity(0.6),
+  fkMinTgl1(1.1),
+  fkMinTgl2(1.),
+  fkMinchi2before0(16.),
+  fkMinchi2before1(16.),
+  fkMinchi2after0(16.),
+  fkMinchi2after1(16.),
+  fkAddchi2SharedCl(18.),
+  fkAddchi2NegCl0(25.),
+  fkAddchi2NegCl1(30.),
+  
+  fkSigp0Par0(0.0001),
+  fkSigp0Par1(0.001),
+  fkSigp0Par2(0.1),
+  fkSigpPar0(0.5),
+  fkSigpPar1(0.6),
+  fkSigpPar2(0.4),
+  fkMaxDcaLh0(0.5),
+  
+  fkChi2KF(100.),
+  fkRobustChi2KF(100.),
+  fgStreamLevel(0)
+
   //
 
 {

diff --git a/STEER/AliESDV0Params.h b/STEER/AliESDV0Params.h
index 608995330a9147eb0e7340a9649b350cd1e83086..9cb6ed94bcc198203568fbf9f3a68347368f37bb 100644 (file)
--- a/STEER/AliESDV0Params.h
+++ b/STEER/AliESDV0Params.h
@@ -24,12 +24,31 @@ class AliESDV0Params : public TObject{
   void SetMinPointAngle2(Float_t kMinPointAngle2=0.99){fkMinPointAngle2=kMinPointAngle2;}
   void SetMinR(Float_t kMinR= 0.5){fkMinR= kMinR;}
   void SetMaxR(Float_t kMaxR= 220.){fkMaxR= kMaxR;}
+  void SetMinPABestConst(Float_t kMinPABestConst= 0.9999){fkMinPABestConst= kMinPABestConst;}
+  void SetMaxRBestConst(Float_t kMaxRBestConst= 10.){fkMaxRBestConst= kMaxRBestConst;}
+
   void SetCausality0Cut(Float_t kCausality0Cut= 0.19){fkCausality0Cut= kCausality0Cut;}
   void SetLikelihood01Cut(Float_t kLikelihood01Cut = 0.45) {fkLikelihood01Cut=kLikelihood01Cut;}
   void SetLikelihood1Cut(Float_t kLikelihood1Cut = 0.5) {fkLikelihood1Cut=kLikelihood1Cut;}
   void SetCombinedCut(Float_t kCombinedCut= 0.55) {fkCombinedCut=kCombinedCut;}
   void SetMinClFullTrk(Float_t kMinClFullTrk=5.0){fkMinClFullTrk=kMinClFullTrk;}
   void SetMinTgl0(Float_t kMinTgl0=1.05){fkMinTgl0=kMinTgl0;}
+  void SetMinRTgl0(Float_t kMinRTgl0=40.0){fkMinRTgl0=kMinRTgl0;}
+
+  void SetMinNormDistForbTgl0(Float_t kMinNormDistForbTgl0=3.0){fkMinNormDistForbTgl0=kMinNormDistForbTgl0;}
+  void SetMinClForb0(Float_t kMinClForb0=4.5){fkMinClForb0=kMinClForb0;}
+  void SetMinNormDistForb1(Float_t kMinNormDistForb1=3.0){fkMinNormDistForb1=kMinNormDistForb1;}
+  void SetMinNormDistForb2(Float_t kMinNormDistForb2=2.0){fkMinNormDistForb2=kMinNormDistForb2;}
+  void SetMinNormDistForb3(Float_t kMinNormDistForb3=1.0){fkMinNormDistForb3=kMinNormDistForb3;}
+  void SetMinNormDistForb4(Float_t kMinNormDistForb4=4.0){fkMinNormDistForb4=kMinNormDistForb4;}
+  void SetMinNormDistForb5(Float_t kMinNormDistForb5=5.0){fkMinNormDistForb5=kMinNormDistForb5;}
+
+  void SetMinRTPCdensity(Float_t kMinRTPCdensity=40.0){fkMinRTPCdensity=kMinRTPCdensity;}
+  void SetMaxRTPCdensity0( Float_t kMaxRTPCdensity0=110.0){fkMaxRTPCdensity0=kMaxRTPCdensity0;}
+  void SetMaxRTPCdensity10(Float_t kMaxRTPCdensity10=120.0){fkMaxRTPCdensity10=kMaxRTPCdensity10;}
+  void SetMaxRTPCdensity20(Float_t kMaxRTPCdensity20=130.0){fkMaxRTPCdensity20=kMaxRTPCdensity20;}
+  void SetMaxRTPCdensity30(Float_t kMaxRTPCdensity30=140.0){fkMaxRTPCdensity30=kMaxRTPCdensity30;}
+
   void SetMinTPCdensity(Float_t kMinTPCdensity=0.6){fkMinTPCdensity=kMinTPCdensity;}
   void SetMinTgl1(Float_t kMinTgl1=1.1){fkMinTgl1=kMinTgl1;}
   void SetMinTgl2(Float_t kMinTgl2=1.){fkMinTgl1=kMinTgl2;}
@@ -47,6 +66,8 @@ class AliESDV0Params : public TObject{
   void SetSigpPar0(Float_t kSigpPar0=0.5){fkSigpPar0=kSigpPar0;}
   void SetSigpPar1(Float_t kSigpPar1=0.6){fkSigpPar1=kSigpPar1;}
   void SetSigpPar2(Float_t kSigpPar2=0.4){fkSigpPar2=kSigpPar2;}
+  void SetMaxDcaLh0(Float_t kMaxDcaLh0=0.5) {fkMaxDcaLh0=kMaxDcaLh0;}
+
   void SetChi2KF(Float_t kChi2KF=100.){fkChi2KF=kChi2KF;}
   void SetRobustChi2KF(Float_t kRobustChi2KF=100.){fkRobustChi2KF=kRobustChi2KF;}
 
@@ -58,12 +79,30 @@ class AliESDV0Params : public TObject{
   Float_t GetMinPointAngle2() const {return fkMinPointAngle2;}
   Float_t GetMinR() const {return fkMinR;}
   Float_t GetMaxR() const {return fkMaxR;}
+  Float_t GetMinPABestConst() const {return fkMinPABestConst;}
+  Float_t GetMaxRBestConst() const {return fkMaxRBestConst;}
   Float_t GetCausality0Cut() const {return fkCausality0Cut;}
   Float_t GetLikelihood01Cut() const {return fkLikelihood01Cut;}
   Float_t GetLikelihood1Cut() const {return fkLikelihood1Cut;}
   Float_t GetCombinedCut() const {return fkCombinedCut;}
   Float_t GetMinClFullTrk() const {return fkMinClFullTrk;}
   Float_t GetMinTgl0() const {return fkMinTgl0;}
+  Float_t GetMinRTgl0() const {return fkMinRTgl0;}
+
+  Float_t GetMinNormDistForbTgl0() const {return fkMinNormDistForbTgl0;} 
+  Float_t GetMinClForb0() const {return fkMinClForb0;}
+  Float_t GetMinNormDistForb1() const {return fkMinNormDistForb1;}
+  Float_t GetMinNormDistForb2() const {return fkMinNormDistForb2;}
+  Float_t GetMinNormDistForb3() const {return fkMinNormDistForb3;}
+  Float_t GetMinNormDistForb4() const {return fkMinNormDistForb4;}
+  Float_t GetMinNormDistForb5() const {return fkMinNormDistForb5;}
+
+  Float_t GetMinRTPCdensity() const  {return fkMinRTPCdensity;}
+  Float_t GetMaxRTPCdensity0() const {return fkMaxRTPCdensity0;}
+  Float_t GetMaxRTPCdensity10() const {return fkMaxRTPCdensity10;}
+  Float_t GetMaxRTPCdensity20() const {return fkMaxRTPCdensity20;}
+  Float_t GetMaxRTPCdensity30() const {return fkMaxRTPCdensity30;}
+
   Float_t GetMinTPCdensity() const {return fkMinTPCdensity;}
   Float_t GetMinTgl1() const {return fkMinTgl1;}
   Float_t GetMinTgl2() const {return fkMinTgl2;}
@@ -80,12 +119,14 @@ class AliESDV0Params : public TObject{
   Float_t GetSigpPar0() const{return fkSigpPar0;}
   Float_t GetSigpPar1() const{return fkSigpPar1;}
   Float_t GetSigpPar2() const{return fkSigpPar2;}
+  Float_t GetMaxDcaLh0() const{return fkMaxDcaLh0;}
+
   Float_t GetChi2KF() const{return fkChi2KF;}
   Float_t GetRobustChi2KF() const{return fkRobustChi2KF;}
 
-  static Int_t StreamLevel()               { return fgStreamLevel;}
-  static void  SetStreamLevel(Int_t level) { fgStreamLevel = level;}
-  static Int_t               fgStreamLevel; // flag for streaming - for ITS V0
+  Int_t StreamLevel()               { return fgStreamLevel;}
+  void  SetStreamLevel(Int_t level=0) { fgStreamLevel = level;}
+  
 
  private:
   Double_t  fPSigmaOffsetD0;        // sigma offset DCA
@@ -122,12 +163,30 @@ class AliESDV0Params : public TObject{
   Float_t fkMinPointAngle2;
   Float_t fkMinR;
   Float_t fkMaxR;
+  Float_t fkMinPABestConst;
+  Float_t fkMaxRBestConst;
   Float_t fkCausality0Cut;
   Float_t fkLikelihood01Cut;
   Float_t fkLikelihood1Cut;
   Float_t fkCombinedCut;
   Float_t fkMinClFullTrk;
   Float_t fkMinTgl0;
+
+  Float_t fkMinClForb0;
+  Float_t fkMinRTgl0; 
+  Float_t fkMinNormDistForbTgl0;
+  Float_t fkMinNormDistForb1;
+  Float_t fkMinNormDistForb2;
+  Float_t fkMinNormDistForb3;
+  Float_t fkMinNormDistForb4;
+  Float_t fkMinNormDistForb5;
+
+  Float_t fkMinRTPCdensity;
+  Float_t fkMaxRTPCdensity0;
+  Float_t fkMaxRTPCdensity10;
+  Float_t fkMaxRTPCdensity20;
+  Float_t fkMaxRTPCdensity30;
+
   Float_t fkMinTPCdensity;
   Float_t fkMinTgl1;
   Float_t fkMinTgl2;
@@ -145,10 +204,11 @@ class AliESDV0Params : public TObject{
   Float_t fkSigpPar0;
   Float_t fkSigpPar1;
   Float_t fkSigpPar2;
+  Float_t fkMaxDcaLh0;
 
   Float_t fkChi2KF;
   Float_t fkRobustChi2KF;
-
+  Int_t   fgStreamLevel; // flag for streaming - for ITS V0