X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TPC%2FAliTPCtrackerMI.cxx;h=774149b8bbcb139ec88bac39bd76ff88940e7cbc;hb=bf1911d56f460b9c1565b6acbe1f34f45f74fa20;hp=5bbb6ead3e4f0180fa5f3f11ed2b54827d1b021d;hpb=77f886333622e8bcadf3b7375cabe0ba1d500e86;p=u%2Fmrichter%2FAliRoot.git

diff --git a/TPC/AliTPCtrackerMI.cxx b/TPC/AliTPCtrackerMI.cxx
index 5bbb6ead3e4..774149b8bbc 100644
--- a/TPC/AliTPCtrackerMI.cxx
+++ b/TPC/AliTPCtrackerMI.cxx
@@ -67,7 +67,7 @@
 //
 // The tracker itself can be debugged  - the information about tracks can be stored in several // phases of the reconstruction
 // To enable storage of the TPC tracks in the ESD friend track
-// use AliTPCReconstructor::SetStreamLevel(n); where nis bigger 0
+// use AliTPCReconstructor::SetStreamLevel(n); 
 //
 // The debug level -  different procedure produce tree for numerical debugging
 //                    To enable them set AliTPCReconstructor::SetStreamLevel(n); where nis bigger 1
@@ -95,12 +95,14 @@
 // There are several places in the code which can be numerically debuged
 // This code is keeped in order to enable code development and to check the calibration implementtion
 //
-//      1. ErrParam stream (Log level 9) - dump information about 
+//      1. ErrParam stream  - dump information about 
 //         1.a) cluster
 //         2.a) cluster error estimate
 //         3.a) cluster shape estimate
 //
 //
+//  Debug streamer levels:
+//  
 //-------------------------------------------------------
 
 
@@ -131,8 +133,6 @@
 #include "AliTPCtrackerMI.h"
 #include "TStopwatch.h"
 #include "AliTPCReconstructor.h"
-#include "AliPID.h"
-#include "TTreeStream.h"
 #include "AliAlignObj.h"
 #include "AliTrackPointArray.h"
 #include "TRandom.h"
@@ -196,7 +196,7 @@ AliTPCtrackerMI::AliTPCtrackerMI()
 		 fNtracks(0),
 		 fSeeds(0),
 		 fIteration(0),
-		 fParam(0),
+		 fkParam(0),
 		 fDebugStreamer(0)
 {
   //
@@ -222,7 +222,7 @@ Int_t AliTPCtrackerMI::UpdateTrack(AliTPCseed * track, Int_t accept){
   track->SetRow((i&0x00ff0000)>>16);
   track->SetSector(sec);
   //  Int_t index = i&0xFFFF;
-  if (sec>=fParam->GetNInnerSector()) track->SetRow(track->GetRow()+fParam->GetNRowLow()); 
+  if (sec>=fkParam->GetNInnerSector()) track->SetRow(track->GetRow()+fkParam->GetNRowLow()); 
   track->SetClusterIndex2(track->GetRow(), i);  
   //track->fFirstPoint = row;
   //if ( track->fLastPoint<row) track->fLastPoint =row;
@@ -289,39 +289,46 @@ Int_t AliTPCtrackerMI::AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluste
   //
   // decide according desired precision to accept given 
   // cluster for tracking
+  Double_t  yt=0,zt=0;
+  seed->GetProlongation(cluster->GetX(),yt,zt);
   Double_t sy2=ErrY2(seed,cluster);
   Double_t sz2=ErrZ2(seed,cluster);
   
   Double_t sdistancey2 = sy2+seed->GetSigmaY2();
   Double_t sdistancez2 = sz2+seed->GetSigmaZ2();
-  
-  Double_t rdistancey2 = (seed->GetCurrentCluster()->GetY()-seed->GetY())*
-    (seed->GetCurrentCluster()->GetY()-seed->GetY())/sdistancey2;
-  Double_t rdistancez2 = (seed->GetCurrentCluster()->GetZ()-seed->GetZ())*
-    (seed->GetCurrentCluster()->GetZ()-seed->GetZ())/sdistancez2;
+  Double_t dy=seed->GetCurrentCluster()->GetY()-yt;
+  Double_t dz=seed->GetCurrentCluster()->GetY()-zt;
+  Double_t rdistancey2 = (seed->GetCurrentCluster()->GetY()-yt)*
+    (seed->GetCurrentCluster()->GetY()-yt)/sdistancey2;
+  Double_t rdistancez2 = (seed->GetCurrentCluster()->GetZ()-zt)*
+    (seed->GetCurrentCluster()->GetZ()-zt)/sdistancez2;
   
   Double_t rdistance2  = rdistancey2+rdistancez2;
   //Int_t  accept =0;
   
-  if (AliTPCReconstructor::StreamLevel()>5 && seed->GetNumberOfClusters()>20) {
+  if (AliTPCReconstructor::StreamLevel()>2 && seed->GetNumberOfClusters()>20) {
     Float_t rmsy2 = seed->GetCurrentSigmaY2();
     Float_t rmsz2 = seed->GetCurrentSigmaZ2();
     Float_t rmsy2p30 = seed->GetCMeanSigmaY2p30();
     Float_t rmsz2p30 = seed->GetCMeanSigmaZ2p30();
     Float_t rmsy2p30R  = seed->GetCMeanSigmaY2p30R();
     Float_t rmsz2p30R  = seed->GetCMeanSigmaZ2p30R();
-
-    AliExternalTrackParam param(*seed); 
+    AliExternalTrackParam param(*seed);
     static TVectorD gcl(3),gtr(3);
     Float_t gclf[3];
     param.GetXYZ(gcl.GetMatrixArray());
     cluster->GetGlobalXYZ(gclf);
     gcl[0]=gclf[0];    gcl[1]=gclf[1];    gcl[2]=gclf[2];
+
     
-    if (AliTPCReconstructor::StreamLevel()>0) {
+    if (AliTPCReconstructor::StreamLevel()>2) {
     (*fDebugStreamer)<<"ErrParam"<<
       "Cl.="<<cluster<<
       "T.="<<&param<<
+      "dy="<<dy<<
+      "dz="<<dz<<
+      "yt="<<yt<<
+      "zt="<<zt<<
       "gcl.="<<&gcl<<
       "gtr.="<<&gtr<<
       "erry2="<<sy2<<
@@ -335,8 +342,8 @@ Int_t AliTPCtrackerMI::AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluste
       "\n";
     }
   }
-  
-  if (rdistance2>16) return 3;
+  //return 0;  // temporary
+  if (rdistance2>32) return 3;
   
   
   if ((rdistancey2>9. || rdistancez2>9.) && cluster->GetType()==0)  
@@ -357,6 +364,7 @@ Int_t AliTPCtrackerMI::AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluste
 
 
 
+
 //_____________________________________________________________________________
 AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCParam *par): 
 AliTracker(), 
@@ -376,7 +384,7 @@ AliTracker(),
 		 fNtracks(0),
 		 fSeeds(0),
 		 fIteration(0),
-		 fParam(0),
+		 fkParam(0),
 		 fDebugStreamer(0)
 {
   //---------------------------------------------------------------------
@@ -389,7 +397,7 @@ AliTracker(),
   for (i=0; i<fkNIS; i++) fInnerSec[i].Setup(par,0);
   for (i=0; i<fkNOS; i++) fOuterSec[i].Setup(par,1);
 
-  fParam = par;  
+  fkParam = par;  
   Int_t nrowlow = par->GetNRowLow();
   Int_t nrowup = par->GetNRowUp();
 
@@ -430,7 +438,7 @@ AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCtrackerMI &t):
 		 fNtracks(0),
 		 fSeeds(0),
 		 fIteration(0),
-		 fParam(0),
+		 fkParam(0),
 		 fDebugStreamer(0)
 {
   //------------------------------------
@@ -438,7 +446,8 @@ AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCtrackerMI &t):
   //------------------------------------------------------------------
   fOutput=t.fOutput;
 }
-AliTPCtrackerMI & AliTPCtrackerMI::operator=(const AliTPCtrackerMI& /*r*/){
+AliTPCtrackerMI & AliTPCtrackerMI::operator=(const AliTPCtrackerMI& /*r*/)
+{
   //------------------------------
   // dummy 
   //--------------------------------------------------------------
@@ -459,7 +468,7 @@ AliTPCtrackerMI::~AliTPCtrackerMI() {
 }
 
 
-void AliTPCtrackerMI::FillESD(TObjArray* arr)
+void AliTPCtrackerMI::FillESD(const TObjArray* arr)
 {
   //
   //
@@ -479,9 +488,9 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr)
 	  "Tr0.="<<pt<<
 	  "\n";       
       }
-      //      pt->PropagateTo(fParam->GetInnerRadiusLow());
+      //      pt->PropagateTo(fkParam->GetInnerRadiusLow());
       if (pt->GetKinkIndex(0)<=0){  //don't propagate daughter tracks 
-	pt->PropagateTo(fParam->GetInnerRadiusLow());
+	pt->PropagateTo(fkParam->GetInnerRadiusLow());
       }
  
       if (( pt->GetPoints()[2]- pt->GetPoints()[0])>5 && pt->GetPoints()[3]>0.8){
@@ -579,6 +588,23 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr)
 	continue;
       }   
     }
+    // >> account for suppressed tracks in the kink indices (RS)
+    int nESDtracks = fEvent->GetNumberOfTracks();
+    for (int it=nESDtracks;it--;) {
+      AliESDtrack* esdTr = fEvent->GetTrack(it);
+      if (!esdTr || !esdTr->GetKinkIndex(0)) continue;
+      for (int ik=0;ik<3;ik++) {
+	int knkId=0;
+	if (!(knkId=esdTr->GetKinkIndex(ik))) break; // no more kinks for this track
+	AliESDkink* kink = fEvent->GetKink(TMath::Abs(knkId)-1);
+	if (!kink) {
+	  AliError(Form("ESDTrack%d refers to non-existing kink %d",it,TMath::Abs(knkId)-1));
+	  continue;
+	}
+	kink->SetIndex(it, knkId<0 ? 0:1); // update track index of the kink: mother at 0, daughter at 1
+      }
+    }
+    // << account for suppressed tracks in the kink indices (RS)
   }
   printf("Number of filled ESDs-\t%d\n",fEvent->GetNumberOfTracks());
 }
@@ -587,14 +613,14 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr)
 
 
 
-Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){
+Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, const AliTPCclusterMI * cl){
   //
   //
   // Use calibrated cluster error from OCDB
   //
   AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
   //
-  Float_t z = TMath::Abs(fParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
+  Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
   Int_t ctype = cl->GetType();  
   Int_t    type = (cl->GetRow()<63) ? 0: (cl->GetRow()>126) ? 1:2;
   Double_t angle = seed->GetSnp()*seed->GetSnp();
@@ -642,7 +668,7 @@ Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){
 //       gnoise1 = 0.0004/padlength;
 //       Float_t nel     = 0.268*amp;
 //       Float_t nprim   = 0.155*amp;
-//       ggg1[i]          = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.001*nel/(padlength*padlength))/nel;
+//       ggg1[i]          = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.001*nel/(padlength*padlength))/nel;
 //       glandau1[i]      = (2.+0.12*nprim)*0.5* (2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
 //       if (glandau1[i]>1) glandau1[i]=1;
 //       glandau1[i]*=padlength*padlength/12.;      
@@ -652,7 +678,7 @@ Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){
 //       gnoise2   = 0.0004/padlength;
 //       nel       = 0.3*amp;
 //       nprim     = 0.133*amp;
-//       ggg2[i]      = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
+//       ggg2[i]      = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
 //       glandau2[i]  = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
 //       if (glandau2[i]>1) glandau2[i]=1;
 //       glandau2[i]*=padlength*padlength/12.;
@@ -663,7 +689,7 @@ Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){
 //       gnoise3   = 0.0004/padlength;
 //       nel       = 0.3*amp;
 //       nprim     = 0.133*amp;
-//       ggg3[i]      = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
+//       ggg3[i]      = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
 //       glandau3[i]  = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
 //       if (glandau3[i]>1) glandau3[i]=1;
 //       glandau3[i]*=padlength*padlength/12.;
@@ -680,7 +706,7 @@ Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){
 //     return 1.;
 //   }
 //   Float_t snoise2;
-//   Float_t z = TMath::Abs(fParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
+//   Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
 //   Int_t ctype = cl->GetType();  
 //   Float_t padlength= GetPadPitchLength(seed->GetRow());
 //   Double_t angle2 = seed->GetSnp()*seed->GetSnp();
@@ -737,14 +763,14 @@ Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){
 
 
 
-Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){
+Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, const AliTPCclusterMI * cl){
   //
   //
   // Use calibrated cluster error from OCDB
   //
   AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
   //
-  Float_t z = TMath::Abs(fParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
+  Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
   Int_t ctype = cl->GetType();  
   Int_t    type = (cl->GetRow()<63) ? 0: (cl->GetRow()>126) ? 1:2;
   //
@@ -798,7 +824,7 @@ Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){
 //       gnoise1 = 0.0004/padlength;
 //       Float_t nel     = 0.268*amp;
 //       Float_t nprim   = 0.155*amp;
-//       ggg1[i]          = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.001*nel/(padlength*padlength))/nel;
+//       ggg1[i]          = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.001*nel/(padlength*padlength))/nel;
 //       glandau1[i]      = (2.+0.12*nprim)*0.5* (2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
 //       if (glandau1[i]>1) glandau1[i]=1;
 //       glandau1[i]*=padlength*padlength/12.;      
@@ -808,7 +834,7 @@ Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){
 //       gnoise2   = 0.0004/padlength;
 //       nel       = 0.3*amp;
 //       nprim     = 0.133*amp;
-//       ggg2[i]      = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
+//       ggg2[i]      = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
 //       glandau2[i]  = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
 //       if (glandau2[i]>1) glandau2[i]=1;
 //       glandau2[i]*=padlength*padlength/12.;
@@ -819,7 +845,7 @@ Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){
 //       gnoise3   = 0.0004/padlength;
 //       nel       = 0.3*amp;
 //       nprim     = 0.133*amp;
-//       ggg3[i]      = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
+//       ggg3[i]      = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel;
 //       glandau3[i]  = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim;
 //       if (glandau3[i]>1) glandau3[i]=1;
 //       glandau3[i]*=padlength*padlength/12.;
@@ -836,7 +862,7 @@ Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){
 //     return 1.;
 //   }
 //   Float_t snoise2;
-//   Float_t z = TMath::Abs(fParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
+//   Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
 //   Int_t ctype = cl->GetType();  
 //   Float_t padlength= GetPadPitchLength(seed->GetRow());
 //   //
@@ -922,7 +948,7 @@ void AliTPCtrackerMI::RotateToLocal(AliTPCseed *seed)
 //_____________________________________________________________________________
 Double_t AliTPCtrackerMI::F1old(Double_t x1,Double_t y1,
                    Double_t x2,Double_t y2,
-                   Double_t x3,Double_t y3) 
+                   Double_t x3,Double_t y3) const
 {
   //-----------------------------------------------------------------
   // Initial approximation of the track curvature
@@ -943,7 +969,7 @@ Double_t AliTPCtrackerMI::F1old(Double_t x1,Double_t y1,
 //_____________________________________________________________________________
 Double_t AliTPCtrackerMI::F1(Double_t x1,Double_t y1,
                    Double_t x2,Double_t y2,
-                   Double_t x3,Double_t y3) 
+                   Double_t x3,Double_t y3) const
 {
   //-----------------------------------------------------------------
   // Initial approximation of the track curvature
@@ -954,7 +980,7 @@ Double_t AliTPCtrackerMI::F1(Double_t x1,Double_t y1,
   y2 -=y1;
   //  
   Double_t det = x3*y2-x2*y3;
-  if (det==0) {
+  if (TMath::Abs(det)<1e-16){
     return 100;
   }
   //
@@ -969,7 +995,7 @@ Double_t AliTPCtrackerMI::F1(Double_t x1,Double_t y1,
 
 Double_t AliTPCtrackerMI::F2(Double_t x1,Double_t y1,
                    Double_t x2,Double_t y2,
-                   Double_t x3,Double_t y3) 
+                   Double_t x3,Double_t y3) const 
 {
   //-----------------------------------------------------------------
   // Initial approximation of the track curvature
@@ -980,7 +1006,7 @@ Double_t AliTPCtrackerMI::F2(Double_t x1,Double_t y1,
   y2 -=y1;
   //  
   Double_t det = x3*y2-x2*y3;
-  if (det==0) {
+  if (TMath::Abs(det)<1e-16) {
     return 100;
   }
   //
@@ -999,7 +1025,7 @@ Double_t AliTPCtrackerMI::F2(Double_t x1,Double_t y1,
 //_____________________________________________________________________________
 Double_t AliTPCtrackerMI::F2old(Double_t x1,Double_t y1,
                    Double_t x2,Double_t y2,
-                   Double_t x3,Double_t y3) 
+                   Double_t x3,Double_t y3) const
 {
   //-----------------------------------------------------------------
   // Initial approximation of the track curvature times center of curvature
@@ -1018,7 +1044,7 @@ Double_t AliTPCtrackerMI::F2old(Double_t x1,Double_t y1,
 //_____________________________________________________________________________
 Double_t AliTPCtrackerMI::F3(Double_t x1,Double_t y1, 
                    Double_t x2,Double_t y2,
-                   Double_t z1,Double_t z2) 
+                   Double_t z1,Double_t z2) const
 {
   //-----------------------------------------------------------------
   // Initial approximation of the tangent of the track dip angle
@@ -1029,7 +1055,7 @@ Double_t AliTPCtrackerMI::F3(Double_t x1,Double_t y1,
 
 Double_t AliTPCtrackerMI::F3n(Double_t x1,Double_t y1, 
                    Double_t x2,Double_t y2,
-                   Double_t z1,Double_t z2, Double_t c) 
+                   Double_t z1,Double_t z2, Double_t c) const
 {
   //-----------------------------------------------------------------
   // Initial approximation of the tangent of the track dip angle
@@ -1049,7 +1075,7 @@ Double_t AliTPCtrackerMI::F3n(Double_t x1,Double_t y1,
   return angle2;
 }
 
-Bool_t   AliTPCtrackerMI::GetProlongation(Double_t x1, Double_t x2, Double_t x[5], Double_t &y, Double_t &z)
+Bool_t   AliTPCtrackerMI::GetProlongation(Double_t x1, Double_t x2, Double_t x[5], Double_t &y, Double_t &z) const
 {//-----------------------------------------------------------------
   // This function find proloncation of a track to a reference plane x=x2.
   //-----------------------------------------------------------------
@@ -1060,8 +1086,8 @@ Bool_t   AliTPCtrackerMI::GetProlongation(Double_t x1, Double_t x2, Double_t x[5
     return kFALSE;
   }
 
-  Double_t c1=x[4]*x1 - x[2], r1=sqrt(1.- c1*c1);
-  Double_t c2=x[4]*x2 - x[2], r2=sqrt(1.- c2*c2);  
+  Double_t c1=x[4]*x1 - x[2], r1=TMath::Sqrt((1.-c1)*(1.+c1));
+  Double_t c2=x[4]*x2 - x[2], r2=TMath::Sqrt((1.-c2)*(1.+c2));  
   y = x[0];
   z = x[1];
   
@@ -1084,7 +1110,7 @@ Bool_t   AliTPCtrackerMI::GetProlongation(Double_t x1, Double_t x2, Double_t x[5
   return kTRUE;  
 }
 
-Int_t  AliTPCtrackerMI::LoadClusters (TTree *tree)
+Int_t  AliTPCtrackerMI::LoadClusters (TTree *const tree)
 {
   //
   //
@@ -1093,7 +1119,7 @@ Int_t  AliTPCtrackerMI::LoadClusters (TTree *tree)
 }
 
 
-Int_t  AliTPCtrackerMI::LoadClusters(TObjArray *arr)
+Int_t  AliTPCtrackerMI::LoadClusters(const TObjArray *arr)
 {
   //
   // load clusters to the memory
@@ -1108,7 +1134,7 @@ Int_t  AliTPCtrackerMI::LoadClusters(TObjArray *arr)
     
     //  
     Int_t sec,row;
-    fParam->AdjustSectorRow(clrow->GetID(),sec,row);
+    fkParam->AdjustSectorRow(clrow->GetID(),sec,row);
     
     for (Int_t icl=0; icl<clrow->GetArray()->GetEntriesFast(); icl++){
       Transform((AliTPCclusterMI*)(clrow->GetArray()->At(icl)));
@@ -1145,7 +1171,7 @@ Int_t  AliTPCtrackerMI::LoadClusters(TObjArray *arr)
   return 0;
 }
 
-Int_t  AliTPCtrackerMI::LoadClusters(TClonesArray *arr)
+Int_t  AliTPCtrackerMI::LoadClusters(const TClonesArray *arr)
 {
   //
   // load clusters to the memory from one 
@@ -1186,11 +1212,11 @@ Int_t  AliTPCtrackerMI::LoadClusters(TClonesArray *arr)
     Int_t left=0;
     if (sec<fkNIS*2){
       left = sec/fkNIS;
-      fInnerSec[sec%fkNIS].InsertCluster(clust, count[sec][row], fParam);    
+      fInnerSec[sec%fkNIS].InsertCluster(clust, count[sec][row], fkParam);    
     }
     else{
       left = (sec-fkNIS*2)/fkNOS;
-      fOuterSec[(sec-fkNIS*2)%fkNOS].InsertCluster(clust, count[sec][row], fParam);
+      fOuterSec[(sec-fkNIS*2)%fkNOS].InsertCluster(clust, count[sec][row], fkParam);
     }
   }
 
@@ -1223,7 +1249,7 @@ Int_t  AliTPCtrackerMI::LoadClusters()
     br->GetEntry(i);
     //  
     Int_t sec,row;
-    fParam->AdjustSectorRow(clrow->GetID(),sec,row);
+    fkParam->AdjustSectorRow(clrow->GetID(),sec,row);
     for (Int_t icl=0; icl<clrow->GetArray()->GetEntriesFast(); icl++){
       Transform((AliTPCclusterMI*)(clrow->GetArray()->At(icl)));
     }
@@ -1323,6 +1349,7 @@ void   AliTPCtrackerMI::Transform(AliTPCclusterMI * cluster){
   if (!transform) {
     AliFatal("Tranformations not in calibDB");
   }
+  transform->SetCurrentRecoParam((AliTPCRecoParam*)AliTPCReconstructor::GetRecoParam());
   Double_t x[3]={cluster->GetRow(),cluster->GetPad(),cluster->GetTimeBin()};
   Int_t i[1]={cluster->GetDetector()};
   transform->Transform(x,i,0,1);  
@@ -1333,7 +1360,7 @@ void   AliTPCtrackerMI::Transform(AliTPCclusterMI * cluster){
   //
   // in debug mode  check the transformation
   //
-  if (AliTPCReconstructor::StreamLevel()>1) {
+  if (AliTPCReconstructor::StreamLevel()>2) {
     Float_t gx[3];
     cluster->GetGlobalXYZ(gx);
     Int_t event = (fEvent==NULL)? 0: fEvent->GetEventNumberInFile();
@@ -1357,8 +1384,8 @@ void   AliTPCtrackerMI::Transform(AliTPCclusterMI * cluster){
   //
   // 
   //
-  //if (!fParam->IsGeoRead()) fParam->ReadGeoMatrices();
-  TGeoHMatrix  *mat = fParam->GetClusterMatrix(cluster->GetDetector());
+  //if (!fkParam->IsGeoRead()) fkParam->ReadGeoMatrices();
+  TGeoHMatrix  *mat = fkParam->GetClusterMatrix(cluster->GetDetector());
   //TGeoHMatrix  mat;
   Double_t pos[3]= {cluster->GetX(),cluster->GetY(),cluster->GetZ()};
   Double_t posC[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()};
@@ -1531,6 +1558,8 @@ Int_t AliTPCtrackerMI::FollowToNext(AliTPCseed& t, Int_t nr) {
   //-----------------------------------------------------------------
   //
   Double_t  x= GetXrow(nr), ymax=GetMaxY(nr);
+  //
+  //
   AliTPCclusterMI *cl=0;
   Int_t tpcindex= t.GetClusterIndex2(nr);
   //
@@ -1580,7 +1609,7 @@ Int_t AliTPCtrackerMI::FollowToNext(AliTPCseed& t, Int_t nr) {
     }
   }
   if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()) return 0;  // cut on angle
-  if (fIteration>1){
+  if (fIteration>1 && IsFindable(t)){
     // not look for new cluster during refitting    
     t.SetNFoundable(t.GetNFoundable()+1);
     return 0;
@@ -1633,7 +1662,8 @@ Int_t AliTPCtrackerMI::FollowToNext(AliTPCseed& t, Int_t nr) {
   } 
   else
     {
-      if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*x+10) && TMath::Abs(z)<fParam->GetZLength(0) && (TMath::Abs(t.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker())) 
+      if (IsFindable(t))
+	  //      if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*x+10) && TMath::Abs(z)<fkParam->GetZLength(0) && (TMath::Abs(t.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker())) 
 	t.SetNFoundable(t.GetNFoundable()+1);
       else
 	return 0;
@@ -1676,83 +1706,6 @@ Int_t AliTPCtrackerMI::FollowToNext(AliTPCseed& t, Int_t nr) {
   return 1;
 }
 
-Int_t AliTPCtrackerMI::FollowToNextFast(AliTPCseed& t, Int_t nr) {
-  //-----------------------------------------------------------------
-  // This function tries to find a track prolongation to next pad row
-  //-----------------------------------------------------------------
-  //
-  Double_t  x= GetXrow(nr), ymax=GetMaxY(nr);
-  Double_t y,z; 
-  if (!t.GetProlongation(x,y,z)) {
-    t.SetRemoval(10);
-    return 0;
-  }
-  //
-  //
-  if (TMath::Abs(y)>ymax){
-    
-    if (y > ymax) {
-      t.SetRelativeSector((t.GetRelativeSector()+1) % fN);
-      if (!t.Rotate(fSectors->GetAlpha())) 
-	return 0;
-    } else if (y <-ymax) {
-      t.SetRelativeSector((t.GetRelativeSector()-1+fN) % fN);
-      if (!t.Rotate(-fSectors->GetAlpha())) 
-	return 0;
-    }
-    if (!t.PropagateTo(x)) {
-      return 0;
-    } 
-    t.GetProlongation(x,y,z);
-  }
-  //
-  // update current shape info every 2 pad-row
-  if ( (nr%2==0) || t.GetNumberOfClusters()<2 || (t.GetCurrentSigmaY2()<0.0001) ){
-    //    t.fCurrentSigmaY = GetSigmaY(&t);
-    //t.fCurrentSigmaZ = GetSigmaZ(&t);
-    GetShape(&t,nr);
-  }
-  //  
-  AliTPCclusterMI *cl=0;
-  UInt_t index=0;
-  
-  
-  //Int_t nr2 = nr;
-  const AliTPCtrackerRow &krow=GetRow(t.GetRelativeSector(),nr);
-  if ( (t.GetSigmaY2()<0) || t.GetSigmaZ2()<0) return 0;
-  Double_t  roady  =1.;
-  Double_t  roadz = 1.;
-  //
-  Int_t row = nr;
-  if (TMath::Abs(TMath::Abs(y)-ymax)<krow.GetDeadZone()){
-    t.SetInDead(kTRUE);
-    t.SetClusterIndex2(row,-1); 
-    return 0;
-  } 
-  else
-    {
-      if (TMath::Abs(z)>(AliTPCReconstructor::GetCtgRange()*x+10)) t.SetClusterIndex2(row,-1);
-    }   
-  //calculate 
-  
-  if ((cl==0)&&(krow)) {
-    //    cl = krow.FindNearest2(y+10,z,roady,roadz,index);    
-    cl = krow.FindNearest2(y,z,roady,roadz,index);    
-
-    if (cl) t.SetCurrentClusterIndex1(krow.GetIndex(index));       
-  }  
-
-  if (cl) {
-    t.SetCurrentCluster(cl); 
-    //    Int_t accept = AcceptCluster(&t,t.fCurrentCluster);        
-    //if (accept<3){
-      t.SetClusterIndex2(row,index);
-      t.SetClusterPointer(row, cl);
-      //}
-  }
-  return 1;
-}
-
 
 
 //_________________________________________________________________________
@@ -1765,19 +1718,19 @@ Bool_t AliTPCtrackerMI::GetTrackPoint(Int_t index, AliTrackPoint &p ) const
   Int_t sector = (index&0xff000000)>>24;
   //  Int_t row = (index&0x00ff0000)>>16;
   Float_t xyz[3];
-  //  xyz[0] = fParam->GetPadRowRadii(sector,row);
+  //  xyz[0] = fkParam->GetPadRowRadii(sector,row);
   xyz[0] = cl->GetX();
   xyz[1] = cl->GetY();
   xyz[2] = cl->GetZ();
   Float_t sin,cos;
-  fParam->AdjustCosSin(sector,cos,sin);
+  fkParam->AdjustCosSin(sector,cos,sin);
   Float_t x = cos*xyz[0]-sin*xyz[1];
   Float_t y = cos*xyz[1]+sin*xyz[0];
   Float_t cov[6];
   Float_t sigmaY2 = 0.027*cl->GetSigmaY2();
-  if (sector < fParam->GetNInnerSector()) sigmaY2 *= 2.07;
+  if (sector < fkParam->GetNInnerSector()) sigmaY2 *= 2.07;
   Float_t sigmaZ2 = 0.066*cl->GetSigmaZ2();
-  if (sector < fParam->GetNInnerSector()) sigmaZ2 *= 1.77;
+  if (sector < fkParam->GetNInnerSector()) sigmaZ2 *= 1.77;
   cov[0] = sin*sin*sigmaY2;
   cov[1] = -sin*cos*sigmaY2;
   cov[2] = 0.;
@@ -1787,13 +1740,13 @@ Bool_t AliTPCtrackerMI::GetTrackPoint(Int_t index, AliTrackPoint &p ) const
   p.SetXYZ(x,y,xyz[2],cov);
   AliGeomManager::ELayerID iLayer;
   Int_t idet;
-  if (sector < fParam->GetNInnerSector()) {
+  if (sector < fkParam->GetNInnerSector()) {
     iLayer = AliGeomManager::kTPC1;
     idet = sector;
   }
   else {
     iLayer = AliGeomManager::kTPC2;
-    idet = sector - fParam->GetNInnerSector();
+    idet = sector - fkParam->GetNInnerSector();
   }
   UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,idet);
   p.SetVolumeID(volid);
@@ -1869,7 +1822,9 @@ Int_t AliTPCtrackerMI::UpdateClusters(AliTPCseed& t,  Int_t nr) {
   } 
   else
     {
-      if (TMath::Abs(t.GetZ())<(AliTPCReconstructor::GetCtgRange()*t.GetX()+10) && (TMath::Abs(t.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker())) t.SetNFoundable(t.GetNFoundable()+1);
+
+      //      if (TMath::Abs(t.GetZ())<(AliTPCReconstructor::GetCtgRange()*t.GetX()+10) && (TMath::Abs(t.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker())) 
+      if (IsFindable(t)) t.SetNFoundable(t.GetNFoundable()+1);
       else
 	return 0;      
     }
@@ -2006,27 +1961,6 @@ Int_t AliTPCtrackerMI::FollowProlongation(AliTPCseed& t, Int_t rf, Int_t step) {
 }
 
 
-//_____________________________________________________________________________
-Int_t AliTPCtrackerMI::FollowProlongationFast(AliTPCseed& t, Int_t rf, Int_t step) {
-  //-----------------------------------------------------------------
-  // This function tries to find a track prolongation.
-  //-----------------------------------------------------------------
-  Double_t xt=t.GetX();
-  //
-  Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift();
-  if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();  
-  if (alpha < 0.            ) alpha += 2.*TMath::Pi();  
-  t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
-    
-  for (Int_t nr=GetRowNumber(xt)-1; nr>=rf; nr-=step) {
-    
-    if (FollowToNextFast(t,nr)==0) 
-      if (!t.IsActive()) return 0;
-    
-  }   
-  return 1;
-}
-
 
 
 
@@ -2329,7 +2263,7 @@ void AliTPCtrackerMI::RemoveUsed2(TObjArray * arr, Float_t factor1,  Float_t fac
       //
       if (Float_t(shared+1)/Float_t(found+1)>factor){
 	if (pt->GetKinkIndexes()[0]!=0) continue;  //don't remove tracks  - part of the kinks
-	if( AliTPCReconstructor::StreamLevel()>15){
+	if( AliTPCReconstructor::StreamLevel()>3){
 	  TTreeSRedirector &cstream = *fDebugStreamer;
 	  cstream<<"RemoveUsed"<<
 	    "iter="<<fIteration<<
@@ -2341,7 +2275,7 @@ void AliTPCtrackerMI::RemoveUsed2(TObjArray * arr, Float_t factor1,  Float_t fac
       }      
       if (pt->GetNumberOfClusters()<50&&(found-0.5*shared)<minimal){  //remove short tracks
 	if (pt->GetKinkIndexes()[0]!=0) continue;  //don't remove tracks  - part of the kinks
-	if( AliTPCReconstructor::StreamLevel()>15){
+	if( AliTPCReconstructor::StreamLevel()>3){
 	  TTreeSRedirector &cstream = *fDebugStreamer;
 	  cstream<<"RemoveShort"<<
 	    "iter="<<fIteration<<
@@ -2412,7 +2346,7 @@ void AliTPCtrackerMI::UnsignClusters()
 
 
 
-void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fdensity)
+void AliTPCtrackerMI::SignClusters(const TObjArray * arr, Float_t fnumber, Float_t fdensity)
 {
   //
   //sign clusters to be "used"
@@ -2578,7 +2512,7 @@ void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fde
 }
 
 
-void  AliTPCtrackerMI::StopNotActive(TObjArray * arr, Int_t row0, Float_t th0, Float_t th1, Float_t th2) const
+void  AliTPCtrackerMI::StopNotActive(const TObjArray * arr, Int_t row0, Float_t th0, Float_t th1, Float_t th2) const
 {
   // stop not active tracks
   // take th1 as threshold for number of founded to number of foundable on last 10 active rows
@@ -2653,6 +2587,7 @@ Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event)
   SignShared(&arraySeed);
   //  FindCurling(fSeeds, event,2); // find multi found tracks
   FindSplitted(fSeeds, event,2); // find multi found tracks
+  if (AliTPCReconstructor::StreamLevel()>5)  FindMultiMC(fSeeds, fEvent,2); // find multi found tracks
 
   Int_t ntracks=0;
   Int_t nseed = fSeeds->GetEntriesFast();
@@ -2666,7 +2601,7 @@ Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event)
       AliExternalTrackParam paramIn;
       AliExternalTrackParam paramOut;
       Int_t ncl = seed->RefitTrack(seed,&paramIn,&paramOut);
-      if (AliTPCReconstructor::StreamLevel()>0) {
+      if (AliTPCReconstructor::StreamLevel()>2) {
 	(*fDebugStreamer)<<"RecoverIn"<<
 	  "seed.="<<seed<<
 	  "esd.="<<esd<<
@@ -2681,7 +2616,7 @@ Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event)
       }
     }
 
-    seed->PropagateTo(fParam->GetInnerRadiusLow());
+    seed->PropagateTo(fkParam->GetInnerRadiusLow());
     seed->UpdatePoints();
     AddCovariance(seed);
     MakeBitmaps(seed);
@@ -2702,8 +2637,8 @@ Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event)
       esd->UpdateTrackParams(seed,AliESDtrack::kTPCrefit); 
       esd->SetTPCPoints(seed->GetPoints());
       esd->SetTPCPointsF(seed->GetNFoundable());
-      Int_t ndedx   = seed->GetNCDEDX(0)+seed->GetNCDEDX(1)+seed->GetNCDEDX(2)+seed->GetNCDEDX(3);
-      Float_t sdedx = (seed->GetSDEDX(0)+seed->GetSDEDX(1)+seed->GetSDEDX(2)+seed->GetSDEDX(3))*0.25;
+      Int_t   ndedx = seed->GetNCDEDX(0);
+      Float_t sdedx = seed->GetSDEDX(0);
       Float_t dedx  = seed->GetdEdx();
       esd->SetTPCsignal(dedx, sdedx, ndedx);
       //
@@ -2739,6 +2674,7 @@ Int_t AliTPCtrackerMI::PropagateBack(AliESDEvent *event)
   RemoveUsed2(fSeeds,0.4,0.4,20);
   //FindCurling(fSeeds, fEvent,1);  
   FindSplitted(fSeeds, event,1); // find multi found tracks
+  if (AliTPCReconstructor::StreamLevel()>5)  FindMultiMC(fSeeds, fEvent,1); // find multi found tracks
 
   //
   Int_t nseed = fSeeds->GetEntriesFast();
@@ -2754,7 +2690,7 @@ Int_t AliTPCtrackerMI::PropagateBack(AliESDEvent *event)
       AliExternalTrackParam paramIn;
       AliExternalTrackParam paramOut;
       Int_t ncl = seed->RefitTrack(seed,&paramIn,&paramOut);
-      if (AliTPCReconstructor::StreamLevel()>0) {
+      if (AliTPCReconstructor::StreamLevel()>2) {
 	(*fDebugStreamer)<<"RecoverBack"<<
 	  "seed.="<<seed<<
 	  "esd.="<<esd<<
@@ -2774,8 +2710,8 @@ Int_t AliTPCtrackerMI::PropagateBack(AliESDEvent *event)
       esd->UpdateTrackParams(seed,AliESDtrack::kTPCout);
       esd->SetTPCPoints(seed->GetPoints());
       esd->SetTPCPointsF(seed->GetNFoundable());
-      Int_t ndedx   = seed->GetNCDEDX(0)+seed->GetNCDEDX(1)+seed->GetNCDEDX(2)+seed->GetNCDEDX(3);
-      Float_t sdedx = (seed->GetSDEDX(0)+seed->GetSDEDX(1)+seed->GetSDEDX(2)+seed->GetSDEDX(3))*0.25;
+      Int_t   ndedx = seed->GetNCDEDX(0);
+      Float_t sdedx = seed->GetSDEDX(0);
       Float_t dedx  = seed->GetdEdx();
       esd->SetTPCsignal(dedx, sdedx, ndedx);
       ntracks++;
@@ -2813,7 +2749,7 @@ void AliTPCtrackerMI::DeleteSeeds()
   fSeeds =0;
 }
 
-void AliTPCtrackerMI::ReadSeeds(AliESDEvent *event, Int_t direction)
+void AliTPCtrackerMI::ReadSeeds(AliESDEvent *const event, Int_t direction)
 {
   //
   //read seeds from the event
@@ -3751,7 +3687,7 @@ void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,
 }
 
 
-AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1, Float_t r2)
+AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *const track, Float_t r0, Float_t r1, Float_t r2)
 {
   //
   //
@@ -3883,7 +3819,7 @@ AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1,
 }
 
 
-AliTPCseed *AliTPCtrackerMI::ReSeed(AliTPCseed *track, Float_t r0, Float_t r1, Float_t r2)
+AliTPCseed *AliTPCtrackerMI::ReSeed(const AliTPCseed *track, Float_t r0, Float_t r1, Float_t r2)
 {
   //
   //
@@ -4150,7 +4086,7 @@ AliTPCseed *AliTPCtrackerMI::ReSeed(AliTPCseed *track,Int_t r0, Bool_t forward)
 
 
 
-void  AliTPCtrackerMI::FindMultiMC(TObjArray * array, AliESDEvent */*esd*/, Int_t iter)
+void  AliTPCtrackerMI::FindMultiMC(const TObjArray * array, AliESDEvent */*esd*/, Int_t iter)
 {
   //
   //  find multi tracks - THIS FUNCTION IS ONLY FOR DEBUG PURPOSES
@@ -4279,7 +4215,7 @@ void  AliTPCtrackerMI::FindMultiMC(TObjArray * array, AliESDEvent */*esd*/, Int_
 	}
       }
       //
-      if (AliTPCReconstructor::StreamLevel()>0) {
+      if (AliTPCReconstructor::StreamLevel()>5) {
       TTreeSRedirector &cstream = *fDebugStreamer;
       cstream<<"Multi"<<
 	"iter="<<iter<<
@@ -4328,43 +4264,36 @@ void  AliTPCtrackerMI::FindMultiMC(TObjArray * array, AliESDEvent */*esd*/, Int_
 }
 
 
-void  AliTPCtrackerMI::FindSplitted(TObjArray * array, AliESDEvent */*esd*/, Int_t iter)
-{
-  //
-  //
-  //  Two reasons to have multiple find tracks
-  //  1. Curling tracks can be find more than once
-  //  2. Splitted tracks 
-  //     a.) Multiple seeding to increase tracking efficiency - (~ 100% reached)        
-  //     b.) Edge effect on the sector boundaries
-  //
-  //  This function tries to find tracks closed in the parametric space
-  //
-  // cut logic if distance is bigger than cut continue - Do Nothing
-  const Float_t kMaxdTheta    = 0.05;  // maximal distance in theta
-  const Float_t kMaxdPhi      = 0.05;   // maximal deistance in phi
-  const Float_t kdelta        = 40.;   //delta r to calculate track distance
-  //
-  //  const Float_t kMaxDist0     = 1.;    // maximal distance 0 
-  //const Float_t kMaxDist1     = 0.3;   // maximal distance 1 - cut if track in separate rows 
-  //
-  /*
-    TCut csec("csec","abs(Tr0.fRelativeSector-Tr1.fRelativeSector)<2");
-    TCut cdtheta("cdtheta","abs(dtheta)<0.05");
-  */ 
-  //
+
+void  AliTPCtrackerMI::FindSplitted(TObjArray * array, AliESDEvent */*esd*/, Int_t /*iter*/){
   //
+  // Find Splitted tracks and remove the one with worst quality  
+  // Corresponding debug streamer to tune selections - "Splitted2"
+  // Algorithm:
+  // 0. Sort tracks according quility
+  // 1. Propagate the tracks to the reference radius
+  // 2. Double_t loop to select close tracks (only to speed up process)
+  // 3. Calculate cluster overlap ratio - and remove the track if bigger than a threshold
+  // 4. Delete temporary parameters
+  // 
+  const Double_t xref=GetXrow(63);  // reference radius -IROC/OROC boundary
+  //    rough cuts
+  const Double_t kCutP1=10;       // delta Z cut 10 cm 
+  const Double_t kCutP2=0.15;     // delta snp(fi) cut 0.15 
+  const Double_t kCutP3=0.15;     // delta tgl(theta) cut 0.15
+  const Double_t kCutAlpha=0.15;  // delta alpha cut
+  Int_t firstpoint = 0;
+  Int_t lastpoint = 160;
   //
   Int_t nentries = array->GetEntriesFast();  
-  AliHelix *helixes      = new AliHelix[nentries];
-  Float_t  *xm           = new Float_t[nentries];
+  AliExternalTrackParam *params      = new AliExternalTrackParam[nentries];
   //
   //
   TStopwatch timer;
   timer.Start();
   //
-  //Sort tracks according quality
-  //
+  //0.  Sort tracks according quality
+  //1.  Propagate the ext. param to reference radius
   Int_t nseed = array->GetEntriesFast();  
   Float_t * quality = new Float_t[nseed];
   Int_t   * indexes = new Int_t[nseed];
@@ -4379,155 +4308,113 @@ void  AliTPCtrackerMI::FindSplitted(TObjArray * array, AliESDEvent */*esd*/, Int
     if (points[3]<0.8) quality[i] =-1;
     quality[i] = (points[2]-points[0])+pt->GetNumberOfClusters();
     //prefer high momenta tracks if overlaps
-    quality[i] *= TMath::Sqrt(TMath::Abs(pt->Pt())+0.5); 
+    quality[i] *= TMath::Sqrt(TMath::Abs(pt->Pt())+0.5);
+    params[i]=(*pt);
+    AliTracker::PropagateTrackToBxByBz(&(params[i]),xref,pt->GetMass(),5.,kTRUE);
+    AliTracker::PropagateTrackToBxByBz(&(params[i]),xref,pt->GetMass(),1.,kTRUE);
   }
   TMath::Sort(nseed,quality,indexes);
-
-
-  //
-  // Find track COG in x direction - point with best defined parameters
-  //
-  for (Int_t i=0;i<nentries;i++){
-    AliTPCseed* track = (AliTPCseed*)array->At(i);    
-    if (!track) continue;
-    track->SetCircular(0);
-    new (&helixes[i]) AliHelix(*track);
-    Int_t ncl=0;
-    xm[i]=0;
-    for (Int_t icl=0; icl<160; icl++){
-      AliTPCclusterMI * cl =  track->GetClusterPointer(icl);
-      if (cl) {
-	xm[i]+=cl->GetX();
-	ncl++;
-      }
-    }
-    if (ncl>0) xm[i]/=Float_t(ncl);
-  }  
   //
-  for (Int_t is0=0;is0<nentries;is0++){
-    Int_t i0 = indexes[is0];
-    AliTPCseed * track0 = (AliTPCseed*)array->At(i0);
-    if (!track0) continue;     
-    if (track0->GetKinkIndexes()[0]!=0) continue;
-    Float_t xc0 = helixes[i0].GetHelix(6);
-    Float_t yc0 = helixes[i0].GetHelix(7);
-    Float_t fi0 = TMath::ATan2(yc0,xc0);
-    
-    for (Int_t is1=is0+1;is1<nentries;is1++){
-      Int_t i1 = indexes[is1];
-      AliTPCseed * track1 = (AliTPCseed*)array->At(i1);
-      if (!track1) continue;      
-      //
-      if (TMath::Abs(track0->GetRelativeSector()-track1->GetRelativeSector())>1) continue;
-      if (track1->GetKinkIndexes()[0]>0 &&track0->GetKinkIndexes()[0]<0) continue;
-      if (track1->GetKinkIndexes()[0]!=0) continue;
-
-      Float_t dtheta = TMath::Abs(track0->GetTgl()-track1->GetTgl())<TMath::Abs(track0->GetTgl()+track1->GetTgl())? track0->GetTgl()-track1->GetTgl():track0->GetTgl()+track1->GetTgl();
-      if (TMath::Abs(dtheta)>kMaxdTheta) continue;      
+  // 3. Loop over pair of tracks
+  //
+  for (Int_t i0=0; i0<nseed; i0++) {
+    Int_t index0=indexes[i0];
+    if (!(array->UncheckedAt(index0))) continue;
+    AliTPCseed *s1 = (AliTPCseed*)array->UncheckedAt(index0);  
+    if (!s1->IsActive()) continue;
+    AliExternalTrackParam &par0=params[index0];
+    for (Int_t i1=i0+1; i1<nseed; i1++) {
+      Int_t index1=indexes[i1];
+      if (!(array->UncheckedAt(index1))) continue;
+      AliTPCseed *s2 = (AliTPCseed*)array->UncheckedAt(index1);  
+      if (!s2->IsActive()) continue;
+      if (s2->GetKinkIndexes()[0]!=0)
+	if (s2->GetKinkIndexes()[0] == -s1->GetKinkIndexes()[0]) continue;
+      AliExternalTrackParam &par1=params[index1];
+      if (TMath::Abs(par0.GetParameter()[3]-par1.GetParameter()[3])>kCutP3) continue;
+      if (TMath::Abs(par0.GetParameter()[1]-par1.GetParameter()[1])>kCutP1) continue;
+      if (TMath::Abs(par0.GetParameter()[2]-par1.GetParameter()[2])>kCutP2) continue;
+      Double_t dAlpha= TMath::Abs(par0.GetAlpha()-par1.GetAlpha());
+      if (dAlpha>TMath::Pi()) dAlpha-=TMath::Pi();
+      if (TMath::Abs(dAlpha)>kCutAlpha) continue;
       //
-      Float_t xc1 = helixes[i1].GetHelix(6);
-      Float_t yc1 = helixes[i1].GetHelix(7);
-      Float_t fi1 = TMath::ATan2(yc1,xc1);
+      Int_t sumShared=0;
+      Int_t nall0=0;
+      Int_t nall1=0;
+      Int_t firstShared=lastpoint, lastShared=firstpoint;
+      Int_t firstRow=lastpoint, lastRow=firstpoint;
       //
-      Float_t dfi = fi0-fi1;
-      if (dfi>1.5*TMath::Pi())  dfi-=TMath::Pi();  // take care about edge effect 
-      if (dfi<-1.5*TMath::Pi()) dfi+=TMath::Pi();  // 
-      if (TMath::Abs(dfi)>kMaxdPhi&&helixes[i0].GetHelix(4)*helixes[i1].GetHelix(4)<0){
-	//
-	// if short tracks with undefined sign 
-	fi1 =  -TMath::ATan2(yc1,-xc1);
-	dfi = fi0-fi1;
+      for (Int_t i=firstpoint;i<lastpoint;i++){
+	if (s1->GetClusterIndex2(i)>0) nall0++;
+	if (s2->GetClusterIndex2(i)>0) nall1++;
+	if  (s1->GetClusterIndex2(i)>0 && s2->GetClusterIndex2(i)>0) {
+	  if (i<firstRow) firstRow=i;
+	  if (i>lastRow)  lastRow=i;
+	}
+	if ( (s1->GetClusterIndex2(i))==(s2->GetClusterIndex2(i)) && s1->GetClusterIndex2(i)>0) {
+	  if (i<firstShared) firstShared=i;
+	  if (i>lastShared)  lastShared=i;
+	  sumShared++;
+	}
+      }
+      Double_t ratio0 = Float_t(sumShared)/Float_t(TMath::Min(nall0+1,nall1+1));
+      Double_t ratio1 = Float_t(sumShared)/Float_t(TMath::Max(nall0+1,nall1+1));
+      
+      if( AliTPCReconstructor::StreamLevel()>1){
+	TTreeSRedirector &cstream = *fDebugStreamer;
+	Int_t n0=s1->GetNumberOfClusters();
+	Int_t n1=s2->GetNumberOfClusters();
+	Int_t n0F=s1->GetNFoundable();
+	Int_t n1F=s2->GetNFoundable();
+	Int_t lab0=s1->GetLabel();
+	Int_t lab1=s2->GetLabel();
+
+	cstream<<"Splitted2"<<
+	  "iter="<<fIteration<<
+	  "lab0="<<lab0<<        // MC label if exist
+	  "lab1="<<lab1<<        // MC label if exist
+	  "index0="<<index0<<
+	  "index1="<<index1<<
+ 	  "ratio0="<<ratio0<<      // shared ratio
+ 	  "ratio1="<<ratio1<<      // shared ratio
+	  "p0.="<<&par0<<        // track parameters
+	  "p1.="<<&par1<<
+	  "s0.="<<s1<<           // full seed
+	  "s1.="<<s2<<
+	  "n0="<<n0<<     // number of clusters track 0
+	  "n1="<<n1<<     // number of clusters track 1
+	  "nall0="<<nall0<<     // number of clusters track 0
+	  "nall1="<<nall1<<     // number of clusters track 1
+	  "n0F="<<n0F<<   // number of findable
+	  "n1F="<<n1F<<   // number of findable
+	  "shared="<<sumShared<<    // number of shared clusters
+	  "firstS="<<firstShared<<  // first and the last shared row
+	  "lastS="<<lastShared<<
+	  "firstRow="<<firstRow<<   // first and the last row with cluster
+	  "lastRow="<<lastRow<<     //
+	  "\n";
       }
-      if (TMath::Abs(dfi)>kMaxdPhi) continue;
-      //
-      //      
-      Float_t sum =0;
-      Float_t sums=0;
-      Float_t sum0=0;
-      Float_t sum1=0;
-      for (Int_t icl=0; icl<160; icl++){
-	Int_t index0=track0->GetClusterIndex2(icl);
-	Int_t index1=track1->GetClusterIndex2(icl);       
-	Bool_t used0 = (index0>0 && !(index0&0x8000));
-	Bool_t used1 = (index1>0 && !(index1&0x8000));
-	//
-	if (used0) sum0++;  // used cluster0
-	if (used1) sum1++;  // used clusters1
-	if (used0&&used1) sum++;
-	if (index0==index1 && used0 && used1) sums++;
-      } 
-     
-      //
-      if (sums<10) continue;
-      if (sum<40) continue;
-      if (sums/Float_t(TMath::Min(sum0,sum1))<0.5) continue;
-      //
-      Double_t dist[5][4];   // distance at X 
-      Double_t mdist[4]={0,0,0,0};  // mean distance on range +-delta
-     
-      //
-      //            
-      track0->GetDistance(track1,xm[i0],dist[0],AliTracker::GetBz());
-      for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[0][i]);
-      track0->GetDistance(track1,xm[i1],dist[1],AliTracker::GetBz());
-      for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[1][i]);
-      //
-      track0->GetDistance(track1,TMath::Min(xm[i1],xm[i0])-kdelta,dist[2],AliTracker::GetBz());
-      for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[2][i]);
-      track0->GetDistance(track1,TMath::Max(xm[i1],xm[i0])+kdelta,dist[3],AliTracker::GetBz());
-      for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[3][i]);     
-      //
-      track0->GetDistance(track1,(xm[i1]+xm[i0])*0.5,dist[4],AliTracker::GetBz());
-      for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[4][i]);     
-      for (Int_t i=0;i<3;i++) mdist[i]*=0.2;
       //
+      // remove track with lower quality
       //
-      Int_t lab0=track0->GetLabel();
-      Int_t lab1=track1->GetLabel();
-      if( AliTPCReconstructor::StreamLevel()>5){
-      TTreeSRedirector &cstream = *fDebugStreamer;
-	cstream<<"Splitted"<<
-	  "iter="<<iter<<
-	  "lab0="<<lab0<<
-	  "lab1="<<lab1<<   
-	  "Tr0.="<<track0<<       // seed0
-	  "Tr1.="<<track1<<       // seed1
-	  "h0.="<<&helixes[i0]<<
-	  "h1.="<<&helixes[i1]<<
-	  //
-	  "sum="<<sum<<           //the sum of rows with cl in both
-	  "sum0="<<sum0<<           //the sum of rows with cl in 0 track
-	  "sum1="<<sum1<<           //the sum of rows with cl in 1 track
-	  "sums="<<sums<<         //the sum of shared clusters
-	  "xm0="<<xm[i0]<<        // the center of track
-	  "xm1="<<xm[i1]<<        // the x center of track
-	  // General cut variables                   
-	  "dfi="<<dfi<<           // distance in fi angle
-	  "dtheta="<<dtheta<<     // distance int theta angle
-	  //
-	  //
-	  "dist0="<<dist[4][0]<<     //distance x
-	  "dist1="<<dist[4][1]<<     //distance y
-	  "dist2="<<dist[4][2]<<     //distance z
-	  "mdist0="<<mdist[0]<<   //distance x
-	  "mdist1="<<mdist[1]<<   //distance y
-	  "mdist2="<<mdist[2]<<   //distance z	  
-	  "\n";
+      if (ratio0>AliTPCReconstructor::GetRecoParam()->GetCutSharedClusters(0) ||
+	  ratio1>AliTPCReconstructor::GetRecoParam()->GetCutSharedClusters(1)){
+	//
+	//
+	//
+	delete array->RemoveAt(index1);
       }
-      delete array->RemoveAt(i1);
     }
-  }    
-  delete [] helixes;
-  delete [] xm;
-  delete [] quality;
-  delete [] indexes;
-  AliInfo("Time for splitted tracks removal");
-  timer.Print();
+  }
+  //
+  // 4. Delete temporary array
+  //
+  delete [] params; 
 }
 
 
 
-void  AliTPCtrackerMI::FindCurling(TObjArray * array, AliESDEvent */*esd*/, Int_t iter)
+void  AliTPCtrackerMI::FindCurling(const TObjArray * array, AliESDEvent */*esd*/, Int_t iter)
 {
   //
   //  find Curling tracks
@@ -4684,7 +4571,7 @@ void  AliTPCtrackerMI::FindCurling(TObjArray * array, AliESDEvent */*esd*/, Int_
 	    track0->SetCircular(track0->GetCircular()+2);
 	  }
 	}		
-	if (AliTPCReconstructor::StreamLevel()>1){	  
+	if (AliTPCReconstructor::StreamLevel()>2){	  
 	  //
 	  //debug stream to tune "fine" cuts	  
 	  Int_t lab0=track0->GetLabel();
@@ -5041,8 +4928,8 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
 
       Float_t x[3] = { kink->GetPosition()[0],kink->GetPosition()[1],kink->GetPosition()[2]};
       Int_t index[4];
-      fParam->Transform0to1(x,index);
-      fParam->Transform1to2(x,index);
+      fkParam->Transform0to1(x,index);
+      fkParam->Transform1to2(x,index);
       row0 = GetRowNumber(x[0]); 
 
       if (kink->GetR()<100) continue;
@@ -5121,6 +5008,30 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
 	kink->SetShapeFactor(shapesum/sum);
       }      
       //      esd->AddKink(kink);
+      //
+      //      kink->SetMother(paramm);
+      //kink->SetDaughter(paramd);
+ 
+      Double_t chi2P2 = paramm.GetParameter()[2]-paramd.GetParameter()[2];
+      chi2P2*=chi2P2;
+      chi2P2/=paramm.GetCovariance()[5]+paramd.GetCovariance()[5];
+      Double_t chi2P3 = paramm.GetParameter()[3]-paramd.GetParameter()[3];
+      chi2P3*=chi2P3;
+      chi2P3/=paramm.GetCovariance()[9]+paramd.GetCovariance()[9];
+      //
+      if (AliTPCReconstructor::StreamLevel()>1) {
+	(*fDebugStreamer)<<"kinkLpt"<<
+	  "chi2P2="<<chi2P2<<
+	  "chi2P3="<<chi2P3<<
+	  "p0.="<<&paramm<<
+	  "p1.="<<&paramd<<
+	  "k.="<<kink<<
+	  "\n";
+      }
+      if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(0)){
+	continue;
+      }
+      //
       kinks->AddLast(kink);
       kink = new AliKink;
       ncandidates++;
@@ -5420,7 +5331,7 @@ void  AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
   timer.Print();
 }
 
-void  AliTPCtrackerMI::FindV0s(TObjArray * array, AliESDEvent *esd)
+void  AliTPCtrackerMI::FindV0s(const TObjArray * array, AliESDEvent *const esd)
 {
   //
   //  find V0s
@@ -5778,7 +5689,7 @@ void  AliTPCtrackerMI::FindV0s(TObjArray * array, AliESDEvent *esd)
   timer.Print();
 }
 
-Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &knk)
+Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, const AliESDkink &knk)
 {
   //
   // refit kink towards to the vertex
@@ -5920,7 +5831,7 @@ void AliTPCtrackerMI::UpdateKinkQualityD(AliTPCseed * seed){
 }
 
 
-Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &knk)
+Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTPCseed &daughter, const AliESDkink &knk)
 {
   //
   // check kink point for given track
@@ -6047,11 +5958,36 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
     delete seed1;
     return 0;
   }
+
   //  Float_t anglesigma = TMath::Sqrt(param0[index].fC22+param0[index].fC33+param1[index].fC22+param1[index].fC33);
   
   kink.SetMother(param0[index]);
   kink.SetDaughter(param1[index]);
   kink.Update();
+
+  Double_t chi2P2 = param0[index].GetParameter()[2]-param1[index].GetParameter()[2];
+  chi2P2*=chi2P2;
+  chi2P2/=param0[index].GetCovariance()[5]+param1[index].GetCovariance()[5];
+  Double_t chi2P3 = param0[index].GetParameter()[3]-param1[index].GetParameter()[3];
+  chi2P3*=chi2P3;
+  chi2P3/=param0[index].GetCovariance()[9]+param1[index].GetCovariance()[9];
+  //
+  if (AliTPCReconstructor::StreamLevel()>1) {
+    (*fDebugStreamer)<<"kinkHpt"<<
+      "chi2P2="<<chi2P2<<
+      "chi2P3="<<chi2P3<<
+      "p0.="<<&param0[index]<<
+      "p1.="<<&param1[index]<<
+      "k.="<<&kink<<
+      "\n";
+  }
+  if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(0)){
+    delete seed0;
+    delete seed1;
+    return 0; 
+  }
+
+
   row0    = GetRowNumber(kink.GetR());   
   kink.SetTPCRow0(row0);
   kink.SetLabel(CookLabel(seed0,0.5,0,row0),0);
@@ -6066,9 +6002,12 @@ Int_t  AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP
   daughter = param1[index];
   daughter.SetLabel(kink.GetLabel(1));  
   param0[index].Reset(kTRUE);
-  FollowProlongation(param0[index],0);  
+  FollowProlongation(param0[index],0);    
   mother = param0[index];
   mother.SetLabel(kink.GetLabel(0));
+  if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(1)){
+    mother=*seed;
+  }
   delete seed0;
   delete seed1;
   //
@@ -6143,7 +6082,7 @@ Int_t AliTPCtrackerMI::ReadSeeds(const TFile *inp) {
   return 0;
 }
 
-Int_t AliTPCtrackerMI::Clusters2Tracks (AliESDEvent *esd)
+Int_t AliTPCtrackerMI::Clusters2Tracks (AliESDEvent *const esd)
 {
   //
   if (fSeeds) DeleteSeeds();
@@ -6193,9 +6132,10 @@ Int_t AliTPCtrackerMI::Clusters2Tracks() {
   RemoveUsed2(fSeeds,0.85,0.85,0);
   if (AliTPCReconstructor::GetRecoParam()->GetDoKinks()) FindKinks(fSeeds,fEvent);
   //FindCurling(fSeeds, fEvent,0);  
-  if (AliTPCReconstructor::StreamLevel()>2)  FindMultiMC(fSeeds, fEvent,0); // find multi found tracks
+  if (AliTPCReconstructor::StreamLevel()>5)  FindMultiMC(fSeeds, fEvent,-1); // find multi found tracks
   RemoveUsed2(fSeeds,0.5,0.4,20);
   FindSplitted(fSeeds, fEvent,0); // find multi found tracks
+  if (AliTPCReconstructor::StreamLevel()>5)  FindMultiMC(fSeeds, fEvent,0); // find multi found tracks
 
  //  //
 //   // refit short tracks
@@ -6599,7 +6539,7 @@ void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *&arr2) const
 
 
 
-void  AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rlast)
+void  AliTPCtrackerMI::ParallelTracking(TObjArray *const arr, Int_t rfirst, Int_t rlast)
 {
   //
   // try to track in parralel
@@ -6611,7 +6551,7 @@ void  AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rla
     if (!pt) continue;
     if (!t.IsActive()) continue;
     // follow prolongation to the first layer
-    if ( (fSectors ==fInnerSec) || (t.GetFirstPoint()-fParam->GetNRowLow()>rfirst+1) )  
+    if ( (fSectors ==fInnerSec) || (t.GetFirstPoint()-fkParam->GetNRowLow()>rfirst+1) )  
       FollowProlongation(t, rfirst+1);
   }
 
@@ -6630,7 +6570,7 @@ void  AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rla
       if (!pt) continue;
       if (nr==80) pt->UpdateReference();
       if (!pt->IsActive()) continue;
-      //      if ( (fSectors ==fOuterSec) && (pt->fFirstPoint-fParam->GetNRowLow())<nr) continue;
+      //      if ( (fSectors ==fOuterSec) && (pt->fFirstPoint-fkParam->GetNRowLow())<nr) continue;
       if (pt->GetRelativeSector()>17) {
 	continue;
       }
@@ -6641,7 +6581,7 @@ void  AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rla
       AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i); 
       if (!pt) continue;
       if (!pt->IsActive()) continue; 
-      // if ((fSectors ==fOuterSec) && (pt->fFirstPoint-fParam->GetNRowLow())<nr) continue;
+      // if ((fSectors ==fOuterSec) && (pt->fFirstPoint-fkParam->GetNRowLow())<nr) continue;
       if (pt->GetRelativeSector()>17) {
 	continue;
       }
@@ -6650,7 +6590,7 @@ void  AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rla
   }    
 }
 
-void AliTPCtrackerMI::PrepareForBackProlongation(TObjArray * arr,Float_t fac) const
+void AliTPCtrackerMI::PrepareForBackProlongation(TObjArray *const arr,Float_t fac) const
 {
   //
   //
@@ -6686,7 +6626,7 @@ void AliTPCtrackerMI::PrepareForBackProlongation(TObjArray * arr,Float_t fac) co
 
 
 }
-void AliTPCtrackerMI::PrepareForProlongation(TObjArray * arr, Float_t fac) const
+void AliTPCtrackerMI::PrepareForProlongation(TObjArray *const arr, Float_t fac) const
 {
   //
   //
@@ -6705,7 +6645,7 @@ void AliTPCtrackerMI::PrepareForProlongation(TObjArray * arr, Float_t fac) const
 
 }
 
-Int_t AliTPCtrackerMI::PropagateBack(TObjArray * arr)
+Int_t AliTPCtrackerMI::PropagateBack(TObjArray *const arr)
 {
   //
   // make back propagation
@@ -6736,7 +6676,7 @@ Int_t AliTPCtrackerMI::PropagateBack(TObjArray * arr)
 }
 
 
-Int_t AliTPCtrackerMI::PropagateForward2(TObjArray * arr)
+Int_t AliTPCtrackerMI::PropagateForward2(TObjArray *const arr)
 {
   //
   // make forward propagation
@@ -6784,7 +6724,7 @@ Int_t AliTPCtrackerMI::PropagateForward()
 
 
 
-Int_t AliTPCtrackerMI::PropagateBack(AliTPCseed * pt, Int_t row0, Int_t row1)
+Int_t AliTPCtrackerMI::PropagateBack(AliTPCseed *const pt, Int_t row0, Int_t row1)
 {
   //
   // make back propagation, in between row0 and row1
@@ -6821,24 +6761,24 @@ void  AliTPCtrackerMI::GetShape(AliTPCseed * seed, Int_t row)
   //
   // 
   AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
-  Float_t zdrift = TMath::Abs((fParam->GetZLength(0)-TMath::Abs(seed->GetZ())));
-  Int_t type = (seed->GetSector() < fParam->GetNSector()/2) ? 0: (row>126) ? 1:2;
+  Float_t zdrift = TMath::Abs((fkParam->GetZLength(0)-TMath::Abs(seed->GetZ())));
+  Int_t type = (seed->GetSector() < fkParam->GetNSector()/2) ? 0: (row>126) ? 1:2;
   Double_t angulary  = seed->GetSnp();
-  angulary = angulary*angulary/(1.-angulary*angulary);
+  angulary = angulary*angulary/((1.-angulary)*(1.+angulary));
   Double_t angularz  = seed->GetTgl()*seed->GetTgl()*(1.+angulary);
   
   Double_t sigmay =  clparam->GetRMS0(0,type,zdrift,TMath::Sqrt(TMath::Abs(angulary)));
   Double_t sigmaz =  clparam->GetRMS0(1,type,zdrift,TMath::Sqrt(TMath::Abs(angularz)));
   seed->SetCurrentSigmaY2(sigmay*sigmay);
   seed->SetCurrentSigmaZ2(sigmaz*sigmaz);
-  // Float_t sd2 = TMath::Abs((fParam->GetZLength(0)-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL();
-//   //  Float_t padlength =  fParam->GetPadPitchLength(seed->fSector);
+  // Float_t sd2 = TMath::Abs((fkParam->GetZLength(0)-TMath::Abs(seed->GetZ())))*fkParam->GetDiffL()*fkParam->GetDiffL();
+//   //  Float_t padlength =  fkParam->GetPadPitchLength(seed->fSector);
 //   Float_t padlength =  GetPadPitchLength(row);
 //   //
-//   Float_t sresy = (seed->GetSector() < fParam->GetNSector()/2) ? 0.2 :0.3;
+//   Float_t sresy = (seed->GetSector() < fkParam->GetNSector()/2) ? 0.2 :0.3;
 //   seed->SetCurrentSigmaY2(sd2+padlength*padlength*angulary/12.+sresy*sresy);  
 //   //
-//   Float_t sresz = fParam->GetZSigma();
+//   Float_t sresz = fkParam->GetZSigma();
 //   seed->SetCurrentSigmaZ2(sd2+padlength*padlength*angularz*angularz*(1+angulary)/12.+sresz*sresz);
   /*
   Float_t wy = GetSigmaY(seed);
@@ -6943,7 +6883,7 @@ void AliTPCtrackerMI::CookLabel(AliKalmanTrack *tk, Float_t wrong) const {
 
 
 //__________________________________________________________________________
-Int_t AliTPCtrackerMI::CookLabel(AliTPCseed *t, Float_t wrong,Int_t first, Int_t last) const {
+Int_t AliTPCtrackerMI::CookLabel(AliTPCseed *const t, Float_t wrong,Int_t first, Int_t last) const {
   //--------------------------------------------------------------------
   //This function "cooks" a track label. If label<0, this track is fake.
   //--------------------------------------------------------------------
@@ -7049,11 +6989,14 @@ void AliTPCtrackerMI::MakeBitmaps(AliTPCseed *t)
   Int_t firstpoint = 0;
   Int_t lastpoint = 159;
   AliTPCTrackerPoint *point;
+  AliTPCclusterMI    *cluster;
   
   for (int iter=firstpoint; iter<lastpoint; iter++) {
-    point = t->GetTrackPoint(iter);
-    if (point) {
+    // Change to cluster pointers to see if we have a cluster at given padrow
+    cluster = t->GetClusterPointer(iter);
+    if (cluster) {
       t->SetClusterMapBit(iter, kTRUE);
+      point = t->GetTrackPoint(iter);
       if (point->IsShared())
 	t->SetSharedMapBit(iter,kTRUE);
       else
@@ -7066,6 +7009,19 @@ void AliTPCtrackerMI::MakeBitmaps(AliTPCseed *t)
   }
 }
 
+Bool_t AliTPCtrackerMI::IsFindable(AliTPCseed & track){
+  //
+  // return flag if there is findable cluster at given position
+  //
+  Float_t kDeltaZ=10;
+  Float_t z = track.GetZ();
+  
+  if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*track.GetX()+kDeltaZ) && 
+      TMath::Abs(z)<fkParam->GetZLength(0) && 
+      (TMath::Abs(track.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker()))
+    return kTRUE;
+  return kFALSE;      
+}
 
 
 void AliTPCtrackerMI::AddCovariance(AliTPCseed * seed){