X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TRD%2FAliTRDtrackerV1.cxx;h=ba28453b5720ef7acbb4b2138d8a66d24902f367;hb=2420973e4193d5a6e8cff21970353fd7f9387f32;hp=d541aa05d7456e56bbbed5a41ce91be407e91d42;hpb=7e6b06acd7b5899773043da454b99339c71707f9;p=u%2Fmrichter%2FAliRoot.git

diff --git a/TRD/AliTRDtrackerV1.cxx b/TRD/AliTRDtrackerV1.cxx
index d541aa05d74..ba28453b572 100644
--- a/TRD/AliTRDtrackerV1.cxx
+++ b/TRD/AliTRDtrackerV1.cxx
@@ -49,6 +49,7 @@
 #include "AliTRDrecoParam.h"
 
 #include "AliTRDcluster.h" 
+#include "AliTRDdigitsParam.h"
 #include "AliTRDseedV1.h"
 #include "AliTRDtrackV1.h"
 #include "AliTRDtrackerV1.h"
@@ -57,6 +58,8 @@
 #include "AliTRDchamberTimeBin.h"
 
 ClassImp(AliTRDtrackerV1)
+ClassImp(AliTRDtrackerV1::AliTRDLeastSquare)
+ClassImp(AliTRDtrackerV1::AliTRDtrackFitterRieman)
 
 const  Float_t  AliTRDtrackerV1::fgkMinClustersInTrack =  0.5;  //
 const  Float_t  AliTRDtrackerV1::fgkLabelFraction      =  0.8;  //
@@ -83,6 +86,7 @@ AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec)
   ,fClusters(NULL)
   ,fTracklets(NULL)
   ,fTracks(NULL)
+  ,fTracksESD(NULL)
   ,fSieveSeeding(0)
 {
   //
@@ -112,13 +116,6 @@ AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec)
     fR[ily] = glb[0]+ AliTRDgeometry::AnodePos()-.5*AliTRDgeometry::AmThick() - AliTRDgeometry::DrThick();
   }
 
-  // initialize calibration values
-  AliTRDcalibDB *trd = NULL;
-  if (!(trd = AliTRDcalibDB::Instance())) {
-    AliFatal("Could not get calibration.");
-  }
-  if(!fgNTimeBins) fgNTimeBins = trd->GetNumberOfTimeBins();
-
   // initialize cluster containers
   for (Int_t isector = 0; isector < AliTRDgeometry::kNsector; isector++) new(&fTrSec[isector]) AliTRDtrackingSector(fGeom, isector);
   
@@ -126,6 +123,8 @@ AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec)
   memset(fTrackQuality, 0, kMaxTracksStack*sizeof(Double_t));
   memset(fSeedLayer, 0, kMaxTracksStack*sizeof(Int_t));
   memset(fSeedTB, 0, kNSeedPlanes*sizeof(AliTRDchamberTimeBin*));
+  fTracksESD = new TClonesArray("AliESDtrack", 2*kMaxTracksStack);
+  fTracksESD->SetOwner();
 }
 
 //____________________________________________________________________
@@ -139,6 +138,7 @@ AliTRDtrackerV1::~AliTRDtrackerV1()
   if(fgTiltedRieman) delete fgTiltedRieman; fgTiltedRieman = NULL;
   if(fgTiltedRiemanConstrained) delete fgTiltedRiemanConstrained; fgTiltedRiemanConstrained = NULL;
   for(Int_t isl =0; isl<kNSeedPlanes; isl++) if(fSeedTB[isl]) delete fSeedTB[isl];
+  if(fTracksESD){ fTracksESD->Delete(); delete fTracksESD; }
   if(fTracks) {fTracks->Delete(); delete fTracks;}
   if(fTracklets) {fTracklets->Delete(); delete fTracklets;}
   if(fClusters) {
@@ -177,7 +177,7 @@ Int_t AliTRDtrackerV1::Clusters2Tracks(AliESDEvent *esd)
     //AliInfo(Form("Processing supermodule %i ...", ism));
     ntracks += Clusters2TracksSM(ism, esd);
   }
-  AliInfo(Form("Number of found tracks : %d", ntracks));
+  AliInfo(Form("Number of tracks: !TRDin[%d]", ntracks));
   return ntracks;
 }
 
@@ -269,9 +269,14 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event)
 // 5. Propagation to TOF. If track propagation fails the AliESDtrack::kTRDStop is set.
 //  
 
+  if(!fClusters || !fClusters->GetEntriesFast()){ 
+    AliInfo("No TRD clusters");
+    return 0;
+  }
   AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance(); // Calibration monitor
-  if (!calibra) AliInfo("Could not get Calibra instance\n");
-  
+  if (!calibra) AliInfo("Could not get Calibra instance");
+  if(!fgNTimeBins) CookNTimeBins();
+
   // Define scalers
   Int_t nFound   = 0, // number of tracks found
         nSeeds   = 0, // total number of ESD seeds
@@ -352,16 +357,14 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event)
       // update calibration references using this track
       if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(&track);
       // save calibration object
-      if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){ 
+      if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){ 
         AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(track);
         calibTrack->SetOwner();
         seed->AddCalibObject(calibTrack);
       }
       //update ESD track
-      if ((track.GetNumberOfClusters() > 15) && (track.GetNumberOfClusters() > 0.5*expectedClr)) {
-        seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
-        track.UpdateESDtrack(seed);
-      }
+      seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
+      track.UpdateESDtrack(seed);
     }
 
     if ((TMath::Abs(track.GetC(track.GetBz()) - p4) / TMath::Abs(p4) < 0.2) ||(track.Pt() > 0.8)) {
@@ -435,7 +438,7 @@ Int_t AliTRDtrackerV1::PropagateBack(AliESDEvent *event)
         seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
         continue;
       }
-      seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
+      //seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
       // TODO obsolete - delete
       seed->SetTRDQuality(track.StatusForTOF()); 
     }
@@ -469,11 +472,16 @@ Int_t AliTRDtrackerV1::RefitInward(AliESDEvent *event)
   Int_t   found    = 0; // contor for updated TRD tracks
   
   
+  if(!fClusters || !fClusters->GetEntriesFast()){ 
+    AliInfo("No TRD clusters");
+    return 0;
+  }
   AliTRDtrackV1 track;
   for (Int_t itrack = 0; itrack < event->GetNumberOfTracks(); itrack++) {
     AliESDtrack *seed = event->GetTrack(itrack);
-    new(&track) AliTRDtrackV1(*seed);
+    ULong_t status = seed->GetStatus();
 
+    new(&track) AliTRDtrackV1(*seed);
     if (track.GetX() < 270.0) {
       seed->UpdateTrackParams(&track, AliESDtrack::kTRDbackup);
       continue;
@@ -481,7 +489,6 @@ Int_t AliTRDtrackerV1::RefitInward(AliESDEvent *event)
 
     // reject tracks which failed propagation in the TRD or
     // are produced by the TRD stand alone tracker
-    ULong_t status = seed->GetStatus();
     if(!(status & AliESDtrack::kTRDout)) continue;
     if(!(status & AliESDtrack::kTRDin)) continue;
     nseed++; 
@@ -500,7 +507,7 @@ Int_t AliTRDtrackerV1::RefitInward(AliESDEvent *event)
       }
 
       // Update the friend track
-      if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){ 
+      if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){ 
         TObject *o = NULL; Int_t ic = 0;
         AliTRDtrackV1 *calibTrack = NULL; 
         while((o = seed->GetCalibObject(ic++))){
@@ -516,8 +523,8 @@ Int_t AliTRDtrackerV1::RefitInward(AliESDEvent *event)
       if (PropagateToX(tt, xTPC, fgkMaxStep)) seed->UpdateTrackParams(&tt, AliESDtrack::kTRDbackup);
     }
   }
-  AliInfo(Form("Number of loaded seeds: %d",nseed));
-  AliInfo(Form("Number of found tracks from loaded seeds: %d",found));
+  AliInfo(Form("Number of seeds: TRDout[%d]", nseed));
+  AliInfo(Form("Number of tracks: TRDrefit[%d]", found));
   
   return 0;
 }
@@ -552,11 +559,14 @@ Int_t AliTRDtrackerV1::FollowProlongation(AliTRDtrackV1 &t)
   Bool_t kStoreIn = kTRUE;
   Int_t    nClustersExpected = 0;
   for (Int_t iplane = kNPlanes; iplane--;) {
-    Int_t   index   = 0;
+    Int_t   index(-1);
     AliTRDseedV1 *tracklet = GetTracklet(&t, iplane, index);
+    AliDebug(2, Form("Tracklet[%p] ly[%d] idx[%d]", (void*)tracklet, iplane, index));
     if(!tracklet) continue;
-    if(!tracklet->IsOK()) AliWarning("tracklet not OK");
-    
+    if(!tracklet->IsOK()){ 
+      AliDebug(1, Form("Tracklet Det[%d] !OK", tracklet->GetDetector()));
+      continue;
+    }
     Double_t x  = tracklet->GetX();//GetX0();
     // reject tracklets which are not considered for inward refit
     if(x > t.GetX()+fgkMaxStep) continue;
@@ -608,7 +618,7 @@ Int_t AliTRDtrackerV1::FollowProlongation(AliTRDtrackV1 &t)
     }
   }
 
-  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+  if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 1){
     Int_t index;
     for(int iplane=0; iplane<AliTRDgeometry::kNlayer; iplane++){
       AliTRDseedV1 *tracklet = GetTracklet(&t, iplane, index);
@@ -616,17 +626,18 @@ Int_t AliTRDtrackerV1::FollowProlongation(AliTRDtrackV1 &t)
       t.SetTracklet(tracklet, index);
     }
 
-    Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
-    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
-    AliTRDtrackV1 track(t);
-    track.SetOwner();
-    cstreamer << "FollowProlongation"
-        << "EventNumber="	<< eventNumber
-        << "ncl="					<< nClustersExpected
-        << "track.="			<< &track
-        << "\n";
+    if(fkReconstructor->IsDebugStreaming()){
+      Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
+      TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
+      AliTRDtrackV1 track(t);
+      track.SetOwner();
+      cstreamer << "FollowProlongation"
+          << "EventNumber="	<< eventNumber
+          << "ncl="					<< nClustersExpected
+          << "track.="			<< &track
+          << "\n";
+    }
   }
-
   return nClustersExpected;
 
 }
@@ -677,6 +688,9 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
   Double_t driftLength = .5*AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick();
   AliTRDtrackingChamber *chamber = NULL;
   
+  Int_t debugLevel = fkReconstructor->IsDebugStreaming() ? fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) : 0;
+  TTreeSRedirector *cstreamer = fkReconstructor->IsDebugStreaming() ? fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker) : 0x0;
+
   AliTRDseedV1 tracklet, *ptrTracklet = NULL;
   // in case of stand alone tracking we store all the pointers to the tracklets in a temporary array
   AliTRDseedV1 *tracklets[kNPlanes];
@@ -691,10 +705,13 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
   TGeoHMatrix *matrix = NULL;
   Double_t x, y, z;
   for (Int_t ily=0, sm=-1, stk=-1, det=-1; ily < AliTRDgeometry::kNlayer; ily++) {
+    AliDebug(2, Form("Propagate to x[%d] = %7.2f", ily, fR[ily]));
+
     // rough estimate of the entry point
     if (!t.GetProlongation(fR[ily], y, z)){
       n=-1; 
       t.SetStatus(AliTRDtrackV1::kProlongation);
+      AliDebug(4, Form("Failed Rough Prolongation to ly[%d] x[%7.2f] y[%7.2f] z[%7.2f]", ily, fR[ily], y, z));
       break;
     }
 
@@ -704,26 +721,31 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
     stk = fGeom->GetStack(z, ily);
     det = stk>=0 ? AliTRDgeometry::GetDetector(ily, stk, sm) : -1;
     matrix = det>=0 ? fGeom->GetClusterMatrix(det) : NULL;
+    AliDebug(3, Form("Propagate to det[%3d]", det));
 
     // check if supermodule/chamber is installed
     if( !fGeom->GetSMstatus(sm) ||
         stk<0. ||
         fGeom->IsHole(ily, stk, sm) ||
         !matrix ){ 
+      AliDebug(4, Form("Missing Geometry ly[%d]. Guess radial position", ily));
       // propagate to the default radial position
       if(fR[ily] > (fgkMaxStep + t.GetX()) && !PropagateToX(t, fR[ily], fgkMaxStep)){
         n=-1; 
         t.SetStatus(AliTRDtrackV1::kPropagation);
+        AliDebug(4, "Failed Propagation [Missing Geometry]");
         break;
       }
       if(!AdjustSector(&t)){
         n=-1; 
         t.SetStatus(AliTRDtrackV1::kAdjustSector);
+        AliDebug(4, "Failed Adjust Sector [Missing Geometry]");
         break;
       }
       if(TMath::Abs(t.GetSnp()) > fgkMaxSnp){
         n=-1; 
         t.SetStatus(AliTRDtrackV1::kSnp);
+        AliDebug(4, "Failed Max Snp [Missing Geometry]");
         break;
       }
       t.SetStatus(AliTRDtrackV1::kGeometry, ily);
@@ -740,16 +762,19 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
     if(x > (fgkMaxStep + t.GetX()) && !PropagateToX(t, x, fgkMaxStep)){
       n=-1; 
       t.SetStatus(AliTRDtrackV1::kPropagation);
+      AliDebug(4, Form("Failed Initial Propagation to x[%7.2f]", x));
       break;
     }
     if(!AdjustSector(&t)){
       n=-1; 
       t.SetStatus(AliTRDtrackV1::kAdjustSector);
+      AliDebug(4, "Failed Adjust Sector Start");
       break;
     }
     if(TMath::Abs(t.GetSnp()) > fgkMaxSnp) {
       n=-1; 
       t.SetStatus(AliTRDtrackV1::kSnp);
+      AliDebug(4, Form("Failed Max Snp[%f] MaxSnp[%f]", t.GetSnp(), fgkMaxSnp));
       break;
     }
     Bool_t doRecalculate = kFALSE;
@@ -765,6 +790,7 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
       det = AliTRDgeometry::GetDetector(ily, stk, sm);
       if(!(matrix = fGeom->GetClusterMatrix(det))){ 
         t.SetStatus(AliTRDtrackV1::kGeometry, ily);
+        AliDebug(4, Form("Failed Geometry Matrix ly[%d]", ily));
         continue;
       }
       matrix->LocalToMaster(loc, glb);
@@ -775,10 +801,12 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
     if (!t.GetProlongation(x+fgkMaxStep, y, z)) {
       n=-1; 
       t.SetStatus(AliTRDtrackV1::kProlongation);
+      AliDebug(4, Form("Failed Prolongation to x[%7.2f] y[%7.2f] z[%7.2f]", x+fgkMaxStep, y, z));
       break;
     }
     if(fGeom->IsOnBoundary(det, y, z, .5)){ 
       t.SetStatus(AliTRDtrackV1::kBoundary, ily);
+      AliDebug(4, "Failed Track on Boundary");
       continue;
     }
     // mark track as entering the FIDUCIAL volume of TRD
@@ -789,23 +817,28 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
 
     ptrTracklet  = tracklets[ily];
     if(!ptrTracklet){ // BUILD TRACKLET
+      AliDebug(3, Form("Building tracklet det[%d]", det));
       // check data in supermodule
       if(!fTrSec[sm].GetNChambers()){ 
         t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+        AliDebug(4, "Failed NoClusters");
         continue;
       }
       if(fTrSec[sm].GetX(ily) < 1.){ 
         t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+        AliDebug(4, "Failed NoX");
         continue;
       }
       
       // check data in chamber
       if(!(chamber = fTrSec[sm].GetChamber(stk, ily))){ 
         t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+        AliDebug(4, "Failed No Detector");
         continue;
       }
       if(chamber->GetNClusters() < fgNTimeBins*fkReconstructor->GetRecoParam() ->GetFindableClusters()){ 
         t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+        AliDebug(4, "Failed Not Enough Clusters in Detector");
         continue;
       }      
       // build tracklet
@@ -817,39 +850,63 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
       if(!tracklet.Init(&t)){
         n=-1; 
         t.SetStatus(AliTRDtrackV1::kTrackletInit);
+        AliDebug(4, "Failed Tracklet Init");
         break;
       }
       if(!tracklet.AttachClusters(chamber, kTRUE)){   
         t.SetStatus(AliTRDtrackV1::kNoAttach, ily);
+        if(debugLevel>3){
+          AliTRDseedV1 trackletCp(*ptrTracklet);
+          UChar_t status(t.GetStatusTRD(ily));
+          (*cstreamer)   << "FollowBackProlongation2"
+          <<"status="    << status
+          <<"tracklet.=" << &trackletCp
+          << "\n";
+        }
+        AliDebug(4, "Failed Attach Clusters");
         continue;
       }
+      AliDebug(3, Form("Number of Clusters in Tracklet: %d", tracklet.GetN()));
       if(tracklet.GetN() < fgNTimeBins*fkReconstructor->GetRecoParam() ->GetFindableClusters()){
         t.SetStatus(AliTRDtrackV1::kNoClustersTracklet, ily);
+        if(debugLevel>3){
+          AliTRDseedV1 trackletCp(*ptrTracklet);
+          UChar_t status(t.GetStatusTRD(ily));
+          (*cstreamer)   << "FollowBackProlongation2"
+          <<"status="    << status
+          <<"tracklet.=" << &trackletCp
+          << "\n";
+        }
+        AliDebug(4, "Failed N Clusters Attached");
         continue;
       }
       ptrTracklet->UpdateUsed();
-    }
+    } else AliDebug(2, Form("Use external tracklet ly[%d]", ily));
     // propagate track to the radial position of the tracklet
     ptrTracklet->UseClusters(); // TODO ? do we need this here ?
     // fit tracklet no tilt correction
     if(!ptrTracklet->Fit(kFALSE)){
       t.SetStatus(AliTRDtrackV1::kNoFit, ily);
+      AliDebug(4, "Failed Tracklet Fit");
       continue;
     } 
     x = ptrTracklet->GetX(); //GetX0();
     if(x > (fgkMaxStep + t.GetX()) && !PropagateToX(t, x, fgkMaxStep)) {
       n=-1; 
       t.SetStatus(AliTRDtrackV1::kPropagation);
+      AliDebug(4, Form("Failed Propagation to Tracklet x[%7.2f]", x));
       break;
     }
     if(!AdjustSector(&t)) {
       n=-1; 
       t.SetStatus(AliTRDtrackV1::kAdjustSector);
+      AliDebug(4, "Failed Adjust Sector");
       break;
     }
     if(TMath::Abs(t.GetSnp()) > fgkMaxSnp) {
       n=-1; 
       t.SetStatus(AliTRDtrackV1::kSnp);
+      AliDebug(4, Form("Failed Max Snp[%f] MaxSnp[%f]", t.GetSnp(), fgkMaxSnp));
       break;
     }
     if(kPropagateIn){
@@ -859,39 +916,38 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
     Double_t cov[3]; ptrTracklet->GetCovAt(x, cov);
     Double_t p[2] = { ptrTracklet->GetY(), ptrTracklet->GetZ()};
     Double_t chi2 = ((AliExternalTrackParam)t).GetPredictedChi2(p, cov);
-    if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
-      Double_t ytrack = ptrTracklet->GetYref(0);
-      Double_t ztrack = ptrTracklet->GetZref(0);
-      Double_t ytracklet = ptrTracklet->GetYfit(0);
-      Double_t ztracklet = ptrTracklet->GetZfit(0);
-      Double_t phitrack = ptrTracklet->GetYref(1);
-      Double_t phitracklet = ptrTracklet->GetYfit(1);
-      Double_t thetatrack = ptrTracklet->GetZref(1);
-      Double_t thetatracklet = ptrTracklet->GetZfit(1);
-   
-      TTreeSRedirector &mystreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
-      mystreamer << "FollowBackProlongation1"
-        << "il="              << ily
-        << "x="               << x
-        << "ytrack="          << ytrack
-        << "ztrack="          << ztrack
-        << "ytracklet="       << ytracklet
-        << "ztracklet="       << ztracklet
-        << "phitrack="        << phitrack
-        << "thetatrack="      << thetatrack
-        << "phitracklet="     << phitracklet
-        << "thetatracklet="   << thetatracklet
-        << "chi2="            << chi2
-        << "\n";
-    }
     // update Kalman with the TRD measurement
     if(chi2>1e+10){ // TODO
       t.SetStatus(AliTRDtrackV1::kChi2, ily);
+      if(debugLevel > 2){
+        UChar_t status(t.GetStatusTRD());
+        AliTRDseedV1  trackletCp(*ptrTracklet);
+        AliTRDtrackV1 trackCp(t);
+        trackCp.SetOwner();
+        (*cstreamer) << "FollowBackProlongation1"
+            << "status="      << status
+            << "tracklet.="   << &trackletCp
+            << "track.="      << &trackCp
+            << "\n";
+      }
+      AliDebug(4, Form("Failed Chi2[%f]", chi2));
       continue; 
     }
     if(!t.Update(p, cov, chi2)) {
       n=-1; 
       t.SetStatus(AliTRDtrackV1::kUpdate);
+      if(debugLevel > 2){
+        UChar_t status(t.GetStatusTRD());
+        AliTRDseedV1  trackletCp(*ptrTracklet);
+        AliTRDtrackV1 trackCp(t);
+        trackCp.SetOwner();
+        (*cstreamer) << "FollowBackProlongation1"
+            << "status="      << status
+            << "tracklet.="   << &trackletCp
+            << "track.="      << &trackCp
+            << "\n";
+      }
+      AliDebug(4, Form("Failed Track Update @ y[%7.2f] z[%7.2f] s2y[%f] s2z[%f] covyz[%f]", p[0], p[1], cov[0], cov[2], cov[1]));
       break;
     }
     // fill residuals ?!
@@ -901,8 +957,10 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
     // load tracklet to the tracker
     ptrTracklet->Update(&t);
     ptrTracklet = SetTracklet(ptrTracklet);
-    t.SetTracklet(ptrTracklet, fTracklets->GetEntriesFast()-1);
+    Int_t index(fTracklets->GetEntriesFast()-1);
+    t.SetTracklet(ptrTracklet, index);
     n += ptrTracklet->GetN();
+    AliDebug(2, Form("Setting Tracklet[%d] @ Idx[%d]", ily, index));
 
     // Reset material budget if 2 consecutive gold
 //     if(ilayer>0 && t.GetTracklet(ilayer-1) && ptrTracklet->GetN() + t.GetTracklet(ilayer-1)->GetN() > 20) t.SetBudget(2, 0.);
@@ -926,12 +984,11 @@ Int_t AliTRDtrackerV1::FollowBackProlongation(AliTRDtrackV1 &t)
   //printf("clusters[%d] chi2[%f] x[%f] status[%d ", n, t.GetChi2(), t.GetX(), t.GetStatusTRD());
   //for(int i=0; i<6; i++) printf("%d ", t.GetStatusTRD(i)); printf("]\n");
 
-  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
-    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+  if(debugLevel > 1){
     Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
     AliTRDtrackV1 track(t);
     track.SetOwner();
-    cstreamer << "FollowBackProlongation"
+    (*cstreamer) << "FollowBackProlongation0"
         << "EventNumber=" << eventNumber
         << "ncl="         << n
         << "track.="      << &track
@@ -1071,7 +1128,7 @@ Float_t AliTRDtrackerV1::FitTiltedRiemanConstraint(AliTRDseedV1 *tracklets, Doub
       nPoints++;
     }
   }
-  if(fitter->Eval()) return 1.E10;
+  fitter->Eval();
 
   // Calculate curvature
   Double_t a = fitter->GetParameter(0);
@@ -1082,7 +1139,7 @@ Float_t AliTRDtrackerV1::FitTiltedRiemanConstraint(AliTRDseedV1 *tracklets, Doub
   for(Int_t ip = 0; ip < AliTRDtrackerV1::kNPlanes; ip++)
     tracklets[ip].SetC(curvature);
 
-/*  if(fkReconstructor->GetStreamLevel() >= 5){
+/*  if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker()) >= 5){
     //Linear Model on z-direction
     Double_t xref = CalculateReferenceX(tracklets);		// Relative to the middle of the stack
     Double_t slope = fitter->GetParameter(2);
@@ -1186,7 +1243,7 @@ Float_t AliTRDtrackerV1::FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigErro
       nPoints++;
     }
   }
-  if(fitter->Eval()) return 1.E10;
+  fitter->Eval();
   zfitter.Eval();
 
   Double_t offset = fitter->GetParameter(3);
@@ -1207,7 +1264,7 @@ Float_t AliTRDtrackerV1::FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigErro
     Double_t zmf	= zfitter.GetFunctionValue(&xref);
     fgTiltedRieman->FixParameter(3, zmf);
     fgTiltedRieman->FixParameter(4, dzmf);
-    if (fitter->Eval()) return 1.E10;
+    fitter->Eval();
     fitter->ReleaseParameter(3);
     fitter->ReleaseParameter(4);
     offset = fitter->GetParameter(3);
@@ -1302,8 +1359,8 @@ Float_t AliTRDtrackerV1::FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigErro
     tracklets[iLayer].SetChi2(chi2track);
   }
   
-/*  if(fkReconstructor->GetStreamLevel() >=5){
-    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+/*  if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >=5){
+    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
     Int_t eventNumber			= AliTRDtrackerDebug::GetEventNumber();
     Int_t candidateNumber	= AliTRDtrackerDebug::GetCandidateNumber();
     Double_t chi2z = CalculateChi2Z(tracklets, offset, slope, xref);
@@ -1461,6 +1518,8 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
   }
 
   Double_t xref = CalculateReferenceX(tracklets);
+  AliDebugGeneral("AliTRDtrackerV1::FitRiemanTilt()", 4, 
+  Form("\nx0[(0)%6.2f (1)%6.2f (2)%6.2f (3)%6.2f (4)%6.2f (5)%6.2f] xref[%6.2f]", tracklets[0].GetX0(), tracklets[1].GetX0(), tracklets[2].GetX0(), tracklets[3].GetX0(), tracklets[4].GetX0(), tracklets[5].GetX0(), xref));
   Double_t x, y, z, t, tilt, dx, w, we;
   Double_t uvt[4];
   Int_t nPoints = 0;
@@ -1469,7 +1528,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
     if(!tracklets[ipl].IsOK()) continue;
     for(Int_t itb = 0; itb < AliTRDseedV1::kNclusters; itb++){
       if(!(cl = tracklets[ipl].GetClusters(itb))) continue;
-      if (!tracklets[ipl].IsUsable(itb)) continue;
+      //if (!tracklets[ipl].IsUsable(itb)) continue;
       x = cl->GetX();
       y = cl->GetY();
       z = cl->GetZ();
@@ -1512,7 +1571,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
     Double_t zmf	= zfitter.GetFunctionValue(&xref);
     fitter->FixParameter(3, zmf);
     fitter->FixParameter(4, dzmf);
-    if(fitter->Eval()) return 1.E10;
+    fitter->Eval();
     fitter->ReleaseParameter(3);
     fitter->ReleaseParameter(4);
     z0   = fitter->GetParameter(3); // = zmf ?
@@ -1533,6 +1592,8 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
 
   // Calculate chi2 of the fit 
   Double_t chi2 = fitter->GetChisquare()/Double_t(nPoints);
+  AliDebugGeneral("AliTRDtrackerV1::FitRiemanTilt()", 4, 
+  Form("x0[%6.2f] y0[%6.2f] R[%6.2f] chi2[%f]\n", x0, y0, radius, chi2));
 
   // Update the tracklets
   if(!track){
@@ -1569,7 +1630,7 @@ Double_t AliTRDtrackerV1::FitRiemanTilt(const AliTRDtrackV1 *track, AliTRDseedV1
 
 
 //____________________________________________________________________
-Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, const AliTRDseedV1 * const tracklets, Bool_t up, Int_t np, AliTrackPoint *points)
+Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, AliTRDseedV1 * const tracklets, Bool_t up, Int_t np, AliTrackPoint *points)
 {
 //   Kalman filter implementation for the TRD.
 //   It returns the positions of the fit in the array "points"
@@ -1595,11 +1656,11 @@ Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, const AliTRDseedV1 * c
     // GET TRACKLET OR BUILT IT		
     Int_t iplane = up ? jplane : kNPlanes - 1 - jplane;
     if(tracklets){ 
-      if(!(ptrTracklet = const_cast<AliTRDseedV1 *>(&tracklets[iplane]))) continue;
+      if(!(ptrTracklet = &tracklets[iplane])) continue;
     }else{
       if(!(ptrTracklet  = track->GetTracklet(iplane))){ 
       /*AliTRDtrackerV1 *tracker = NULL;
-        if(!(tracker = dynamic_cast<AliTRDtrackerV1*>( AliTRDReconstructor::Tracker()))) continue;
+        if(!(tracker = dynamic_cast<AliTRDtrackerV1*>( AliTRDrecoParam:Tracker()))) continue;
         ptrTracklet = new(&tracklet) AliTRDseedV1(iplane);
         if(!tracker->MakeTracklet(ptrTracklet, track)) */
         continue;
@@ -1652,7 +1713,7 @@ Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, const AliTRDseedV1 * c
     xyz1[0] =  x * TMath::Cos(alpha) - y * TMath::Sin(alpha); 
     xyz1[1] = +x * TMath::Sin(alpha) + y * TMath::Cos(alpha);
     xyz1[2] =  z;
-    if((xyz0[0] - xyz1[9] < 1e-3) && (xyz0[0] - xyz1[9] < 1e-3)) continue; // check wheter we are at the same global x position
+    if(TMath::Abs(xyz0[0] - xyz1[0]) < 1e-3 && TMath::Abs(xyz0[1] - xyz1[1]) < 1e-3) continue; // check wheter we are at the same global x position
     Double_t param[7];
     if(AliTracker::MeanMaterialBudget(xyz0, xyz1, param) <=0.) break;	
     Double_t xrho = param[0]*param[4]; // density*length
@@ -1888,6 +1949,7 @@ Int_t AliTRDtrackerV1::BuildTrackingContainers()
   while (icl--) {
     AliTRDcluster *c = (AliTRDcluster *) fClusters->UncheckedAt(icl);
     if(c->IsInChamber()) nin++;
+    if(fkReconstructor->IsHLT()) c->SetRPhiMethod(AliTRDcluster::kCOG);
     Int_t detector       = c->GetDetector();
     Int_t sector         = fGeom->GetSector(detector);
     Int_t stack          = fGeom->GetStack(detector);
@@ -1999,7 +2061,7 @@ AliTRDseedV1* AliTRDtrackerV1::GetTracklet(AliTRDtrackV1 *const track, Int_t p,
   // Detailed description
   //
   idx = track->GetTrackletIndex(p);
-  AliTRDseedV1 *tracklet = (idx==0xffff) ? NULL : (AliTRDseedV1*)fTracklets->UncheckedAt(idx);
+  AliTRDseedV1 *tracklet = (idx<0) ? NULL : (AliTRDseedV1*)fTracklets->UncheckedAt(idx);
 
   return tracklet;
 }
@@ -2027,6 +2089,38 @@ AliTRDseedV1* AliTRDtrackerV1::SetTracklet(const AliTRDseedV1 * const tracklet)
   return new ((*fTracklets)[nentries]) AliTRDseedV1(*tracklet);
 }
 
+//____________________________________________________________________
+void AliTRDtrackerV1::CookNTimeBins()
+{ 
+  // Initialize number of time bins
+
+  if(fgNTimeBins){
+    // first look if set by hand
+    AliDebug(2, Form("NTimeBins [%d] (set by user)", fgNTimeBins));
+  } else if(fkReconstructor && fkReconstructor->HasDigitsParam()) {
+    // second look into digits param to avoid DB query
+    fgNTimeBins = fkReconstructor->GetDigitsParam()->GetNTimeBins();
+    if(fgNTimeBins>0) AliDebug(2, Form("NTimeBins [%d] (set from digits param)", fgNTimeBins));
+    else AliWarning(Form("NTimeBins [%d] failed from digits param.", fgNTimeBins));
+  }
+
+  if(!fgNTimeBins){ // third query DB
+    AliTRDcalibDB *trd(NULL);
+    if((trd = AliTRDcalibDB::Instance())) {
+      if((fgNTimeBins = trd->GetNumberOfTimeBinsDCS()) <= 0){
+        AliError("Corrupted DCS Object in OCDB");
+        fgNTimeBins = 24;
+        AliDebug(2, Form("NTimeBins [%d] (set to default 24)", fgNTimeBins));
+      } else AliDebug(2, Form("NTimeBins [%d] (set from DB)", fgNTimeBins));
+    } else AliFatal("Could not get DB.");
+  }
+
+  if(fgNTimeBins<=0){
+    AliError("NTimeBins failed all settings. Use default 24 !");
+    fgNTimeBins = 24;
+  }
+}
+
 //____________________________________________________________________
 AliTRDtrackV1* AliTRDtrackerV1::SetTrack(const AliTRDtrackV1 * const track)
 {
@@ -2074,10 +2168,6 @@ Int_t AliTRDtrackerV1::Clusters2TracksSM(Int_t sector, AliESDEvent *esd)
   // 3. Pack results in the ESD event.
   //
   
-  // allocate space for esd tracks in this SM
-  TClonesArray esdTrackList("AliESDtrack", 2*kMaxTracksStack);
-  esdTrackList.SetOwner();
-  
   Int_t nTracks   = 0;
   Int_t nChambers = 0;
   AliTRDtrackingChamber **stack = NULL, *chamber = NULL;
@@ -2092,16 +2182,33 @@ Int_t AliTRDtrackerV1::Clusters2TracksSM(Int_t sector, AliESDEvent *esd)
     }
     if(nChambers < 4) continue;
     //AliInfo(Form("Doing stack %d", istack));
-    nTracks += Clusters2TracksStack(stack, &esdTrackList);
+    nTracks += Clusters2TracksStack(stack, fTracksESD);
+  }
+  if(nTracks) AliDebug(2, Form("Number of tracks: SM_%02d[%d]", sector, nTracks));
+
+  for(int itrack=0; itrack<nTracks; itrack++){
+    AliESDtrack *esdTrack((AliESDtrack*)(fTracksESD->operator[](itrack)));
+    Int_t id = esd->AddTrack(esdTrack);
+
+    // set ESD id to stand alone TRD tracks
+    if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){ 
+      esdTrack=esd->GetTrack(id);
+      TObject *o(NULL); Int_t ic(0);
+      AliTRDtrackV1 *calibTrack(NULL); 
+      while((o = esdTrack->GetCalibObject(ic++))){
+        if(!(calibTrack = dynamic_cast<AliTRDtrackV1*>(o))) continue;
+        calibTrack->SetESDid(esdTrack->GetID());
+        break;
+      }
+    }
   }
-  //AliInfo(Form("Found %d tracks in SM %d [%d]\n", nTracks, sector, esd->GetNumberOfTracks()));
-  
-  for(int itrack=0; itrack<nTracks; itrack++)
-    esd->AddTrack((AliESDtrack*)esdTrackList[itrack]);
 
   // Reset Track and Candidate Number
   AliTRDtrackerDebug::SetCandidateNumber(0);
   AliTRDtrackerDebug::SetTrackNumber(0);
+
+  // delete ESD tracks in the array
+  fTracksESD->Delete();
   return nTracks;
 }
 
@@ -2153,7 +2260,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
 
   // Build initial seeding configurations
   Double_t quality = BuildSeedingConfigs(stack, configs);
-  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){
+  if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 10){
     AliInfo(Form("Plane config %d %d %d Quality %f"
     , configs[0], configs[1], configs[2], quality));
   }
@@ -2182,7 +2289,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
       //AliInfo(Form("Number of Tracks after iteration step %d: %d\n", iconf, ntracks));
       if(ntracks == kMaxTracksStack) break;
     }
-    if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1) AliInfo(Form("Candidate TRD tracks %d in iteration %d.", ntracks, fSieveSeeding));
+    AliDebug(2, Form("Candidate TRD tracks %d in iteration %d.", ntracks, fSieveSeeding));
     
     if(!ntracks) break;
     
@@ -2236,7 +2343,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
           fakeTrack[trackIndex] = kTRUE;
           continue;
         }
-        if (Float_t(nused)/ncl >= .25){
+        if (ncl>0 && Float_t(nused)/ncl >= .25){
           //printf("Skip %d nused/ncl >= .25\n", trackIndex);
           fakeTrack[trackIndex] = kTRUE;
           continue;
@@ -2271,9 +2378,10 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
         }
         if(skip){
           candidates++;
-          //printf("REJECTED : %d [%d] nlayers %d trackQuality = %e nused %d\n", itrack, trackIndex, nlayers, fTrackQuality[trackIndex], nused);
+          AliDebug(4, Form("REJECTED : %d idx[%d] quality[%e] tracklets[%d] usedClusters[%d]", itrack, trackIndex, fTrackQuality[trackIndex], nlayers, nused));
           continue;
-        }
+        } else AliDebug(4, Form("ACCEPTED : %d idx[%d] quality[%e] tracklets[%d] usedClusters[%d]", itrack, trackIndex, fTrackQuality[trackIndex], nlayers, nused));
+
         signedTrack[trackIndex] = kTRUE;
 
         // Build track parameters
@@ -2293,7 +2401,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
         Int_t ich = 0; while(!(chamber = stack[ich])) ich++;
         trackParams[6] = fGeom->GetSector(chamber->GetDetector());/* *alpha+shift;	// Supermodule*/
 
-        if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+        if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 1 && fkReconstructor->IsDebugStreaming()){
           //AliInfo(Form("Track %d [%d] nlayers %d trackQuality = %e nused %d, yref = %3.3f", itrack, trackIndex, nlayers, fTrackQuality[trackIndex], nused, trackParams[1]));
 
           AliTRDseedV1 *dseed[6];
@@ -2303,7 +2411,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
           Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
           Int_t trackNumber = AliTRDtrackerDebug::GetTrackNumber();
           Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
-          TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+          TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
           cstreamer << "Clusters2TracksStack"
               << "EventNumber="		<< eventNumber
               << "TrackNumber="		<< trackNumber
@@ -2332,7 +2440,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
 
         AliTRDtrackV1 *track = MakeTrack(&sseed[trackIndex*kNPlanes], trackParams);
         if(!track){
-          AliWarning("Fail to build a TRD Track.");
+          AliDebug(1, "Track building failed.");
           continue;
         }
       
@@ -2342,7 +2450,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
         esdTrack->SetLabel(track->GetLabel());
         track->UpdateESDtrack(esdTrack);
         // write ESD-friends if neccessary
-        if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
+        if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
           AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(*track);
           calibTrack->SetOwner();
           esdTrack->AddCalibObject(calibTrack);
@@ -2370,7 +2478,7 @@ Int_t AliTRDtrackerV1::Clusters2TracksStack(AliTRDtrackingChamber **stack, TClon
       chamber->Build(fGeom, cal);//Indices(fSieveSeeding);
     }
 
-    if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){ 
+    if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 10){ 
       AliInfo(Form("Sieve level %d Plane config %d %d %d Quality %f", fSieveSeeding, configs[0], configs[1], configs[2], quality));
     }
   } while(fSieveSeeding<10); // end stack clusters sieve
@@ -2433,7 +2541,7 @@ Double_t AliTRDtrackerV1::BuildSeedingConfigs(AliTRDtrackingChamber **stack, Int
 }
 
 //____________________________________________________________________
-Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseedV1 * const sseed, const Int_t * const ipar)
+Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 * const sseed, const Int_t * const ipar)
 {
 //
 // Seed tracklets and build candidate TRD tracks. The procedure is used during barrel tracking to account for tracks which are 
@@ -2497,7 +2605,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
 
   AliTRDtrackingChamber *chamber = NULL;
   AliTRDcluster *c[kNSeedPlanes] = {NULL, NULL, NULL, NULL}; // initilize seeding clusters
-  AliTRDseedV1 *cseed = const_cast<AliTRDseedV1 *>(&sseed[0]); // initialize tracklets for first track
+  AliTRDseedV1 *cseed = &sseed[0]; // initialize tracklets for first track
   Int_t ncl, mcl; // working variable for looping over clusters
   Int_t index[AliTRDchamberTimeBin::kMaxClustersLayer], jndex[AliTRDchamberTimeBin::kMaxClustersLayer];
   // chi2 storage
@@ -2545,9 +2653,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
     x0[iLayer] = glb[0];
   }
 
-  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
-    AliInfo(Form("Making seeds Stack[%d] Config[%d] Tracks[%d]...", istack, config, ntracks));
-  }
+  AliDebug(2, Form("Making seeds Stack[%d] Config[%d] Tracks[%d]...", istack, config, ntracks));
 
   // Build seeding layers
   ResetSeedTB();
@@ -2587,9 +2693,12 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
         c[2] = fSeedTB[2]->GetNearestCluster(cond2);
         //printf("Found c[1] candidate 2 %p\n", c[2]);
         if(!c[2]) continue;
-              
-       	//AliInfo("Seeding clusters found. Building seeds ...");
-       	//for(Int_t i = 0; i < kNSeedPlanes; i++) printf("%i. coordinates: x = %6.3f, y = %6.3f, z = %6.3f\n", i, c[i]->GetX(), c[i]->GetY(), c[i]->GetZ());
+
+       	AliDebug(3, Form("Seeding clusters\n 0[%6.3f %6.3f %6.3f]\n 1[%6.3f %6.3f %6.3f]\n 2[%6.3f %6.3f %6.3f]\n 3[%6.3f %6.3f %6.3f].",
+          c[0]->GetX(), c[0]->GetY(), c[0]->GetZ(),
+          c[1]->GetX(), c[1]->GetY(), c[1]->GetZ(),
+          c[2]->GetX(), c[2]->GetY(), c[2]->GetZ(),
+          c[3]->GetX(), c[3]->GetY(), c[3]->GetZ()));
               
         for (Int_t il = 0; il < kNPlanes; il++) cseed[il].Reset();
       
@@ -2610,7 +2719,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
         }
       
         Bool_t isFake = kFALSE;
-        if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+        if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
           if (c[0]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
           if (c[1]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
           if (c[2]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
@@ -2623,7 +2732,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
           Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
           Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
           AliRieman *rim = GetRiemanFitter();
-          TTreeSRedirector &cs0 = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+          TTreeSRedirector &cs0 = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
           cs0 << "MakeSeeds0"
               <<"EventNumber="		<< eventNumber
               <<"CandidateNumber="	<< candidateNumber
@@ -2654,12 +2763,12 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
               <<"\n";
         }
         if(chi2[0] > fkReconstructor->GetRecoParam() ->GetChi2Z()/*7./(3. - sLayer)*//*iter*/){
-          //AliInfo(Form("Failed chi2 filter on chi2Z [%f].", chi2[0]));
+          AliDebug(3, Form("Filter on chi2Z [%f].", chi2[0]));
           AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
           continue;
         }
         if(chi2[1] > fkReconstructor->GetRecoParam() ->GetChi2Y()/*1./(3. - sLayer)*//*iter*/){
-          //AliInfo(Form("Failed chi2 filter on chi2Y [%f].", chi2[1]));
+          AliDebug(3, Form("Filter on chi2Y [%f].", chi2[1]));
           AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
           continue;
         }
@@ -2667,29 +2776,29 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
       
         // try attaching clusters to tracklets
         Int_t mlayers = 0; 
-	AliTRDcluster *cl = NULL;
+        AliTRDcluster *cl = NULL;
         for(int iLayer=0; iLayer<kNSeedPlanes; iLayer++){
           Int_t jLayer = planes[iLayer];
-	  Int_t nNotInChamber = 0;
+          Int_t nNotInChamber = 0;
           if(!cseed[jLayer].AttachClusters(stack[jLayer], kTRUE)) continue;
-	  if(fkReconstructor->IsHLT()){ 
-	    cseed[jLayer].UpdateUsed();
-	    if(!cseed[jLayer].IsOK()) continue;
-	  }else{
-	    cseed[jLayer].Fit();
-	    cseed[jLayer].UpdateUsed();
-	    cseed[jLayer].ResetClusterIter();
-	    while((cl = cseed[jLayer].NextCluster())){
-	      if(!cl->IsInChamber()) nNotInChamber++;
-	    }
-	    //printf("clusters[%d], used[%d], not in chamber[%d]\n", cseed[jLayer].GetN(), cseed[jLayer].GetNUsed(), nNotInChamber);
-	    if(cseed[jLayer].GetN() - (cseed[jLayer].GetNUsed() + nNotInChamber) < 5) continue; // checking for Cluster which are not in chamber is a much stronger restriction on real data
-	  }
+          if(/*fkReconstructor->IsHLT()*/kFALSE){ 
+            cseed[jLayer].UpdateUsed();
+            if(!cseed[jLayer].IsOK()) continue;
+          }else{
+            cseed[jLayer].Fit();
+            cseed[jLayer].UpdateUsed();
+            cseed[jLayer].ResetClusterIter();
+            while((cl = cseed[jLayer].NextCluster())){
+              if(!cl->IsInChamber()) nNotInChamber++;
+            }
+            //printf("clusters[%d], used[%d], not in chamber[%d]\n", cseed[jLayer].GetN(), cseed[jLayer].GetNUsed(), nNotInChamber);
+            if(cseed[jLayer].GetN() - (cseed[jLayer].GetNUsed() + nNotInChamber) < 5) continue; // checking for Cluster which are not in chamber is a much stronger restriction on real data
+          }
           mlayers++;
         }
 
         if(mlayers < kNSeedPlanes){ 
-          //AliInfo(Form("Failed updating all seeds %d [%d].", mlayers, kNSeedPlanes));
+          AliDebug(2, Form("Found only %d tracklets out of %d. Skip.", mlayers, kNSeedPlanes));
           AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
           continue;
         }
@@ -2700,8 +2809,8 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
           for(int iLayer=0; iLayer<kNPlanes-kNSeedPlanes; iLayer++){
             Int_t jLayer = planesExt[iLayer];
             if(!(chamber = stack[jLayer])) continue;
-            cseed[jLayer].AttachClusters(chamber, kTRUE);
-            //cseed[jLayer].Fit();
+            if(!cseed[jLayer].AttachClusters(chamber, kTRUE)) continue;
+            cseed[jLayer].Fit();
           }
           fTrackQuality[ntracks] = 1.; // dummy value
           ntracks++;
@@ -2721,7 +2830,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
         Double_t like = CookLikelihood(&cseed[0], planes); // to be checked
       
         if (TMath::Log(1.E-9 + like) < fkReconstructor->GetRecoParam() ->GetTrackLikelihood()){
-          //AliInfo(Form("Failed likelihood %f[%e].", TMath::Log(1.E-9 + like), like));
+          AliDebug(3, Form("Filter on likelihood %f[%e].", TMath::Log(1.E-9 + like), like));
           AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
           continue;
         }
@@ -2732,6 +2841,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
         fSeedLayer[ntracks]  = config;/*sLayer;*/
       
         // attach clusters to the extrapolation seeds
+        Int_t elayers(0);
         for(int iLayer=0; iLayer<kNPlanes-kNSeedPlanes; iLayer++){
           Int_t jLayer = planesExt[iLayer];
           if(!(chamber = stack[jLayer])) continue;
@@ -2745,12 +2855,13 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
           cseed[jLayer] = pseed;
           FitTiltedRieman(cseed,  kTRUE);
           cseed[jLayer].Fit(kTRUE);
+          elayers++;
         }
       
         // AliInfo("Extrapolation done.");
         // Debug Stream containing all the 6 tracklets
-        if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
-          TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+        if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
+          TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
           TLinearFitter *tiltedRieman = GetTiltedRiemanFitter();
           Int_t eventNumber 		= AliTRDtrackerDebug::GetEventNumber();
           Int_t candidateNumber	= AliTRDtrackerDebug::GetCandidateNumber();
@@ -2767,9 +2878,17 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
               << "\n";
         }
               
-        if(fkReconstructor->HasImproveTracklets() && ImproveSeedQuality(stack, cseed) < 4){
-          AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
-          continue;
+        if(fkReconstructor->GetRecoParam()->HasImproveTracklets()){ 
+          AliTRDseedV1 bseed[AliTRDgeometry::kNlayer];
+          for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) bseed[jLayer] = cseed[jLayer];
+
+          if(ImproveSeedQuality(stack, cseed) < mlayers+elayers){
+            AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
+            AliDebug(3, "Filter on improve seeds.");
+          } else {
+            // store results
+            for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) cseed[jLayer] = bseed[jLayer];
+          }
         }
         //AliInfo("Improve seed quality done.");
       
@@ -2781,7 +2900,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
         // do the final track fitting (Once with vertex constraint and once without vertex constraint)
         Double_t chi2Vals[3];
         chi2Vals[0] = FitTiltedRieman(&cseed[0], kTRUE);
-        if(fkReconstructor->HasVertexConstrained())
+        if(fkReconstructor->GetRecoParam()->IsVertexConstrained())
           chi2Vals[1] = FitTiltedRiemanConstraint(&cseed[0], GetZ()); // Do Vertex Constrained fit if desired
         else
           chi2Vals[1] = 1.;
@@ -2791,8 +2910,8 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
         fTrackQuality[ntracks] = CalculateTrackLikelihood(&cseed[0], &chi2Vals[0]);
         //AliInfo("Hyperplane fit done\n");
                   
-        if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
-          TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+        if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
+          TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
           Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
           Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
           TLinearFitter *fitterTC = GetTiltedRiemanFitterConstraint();
@@ -2835,7 +2954,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseed
 }
 
 //_____________________________________________________________________________
-AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(const AliTRDseedV1 * const seeds, Double_t *params)
+AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 * const seeds, Double_t *params)
 {
 //
 // Build a TRD track out of tracklet candidates
@@ -2877,30 +2996,35 @@ AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(const AliTRDseedV1 * const seeds, Doub
   AliTRDseedV1 *ptrTracklet = NULL;
 
   // skip Kalman filter for HLT
-  if(fkReconstructor->IsHLT()){ 
+  if(/*fkReconstructor->IsHLT()*/kFALSE){ 
     for (Int_t jLayer = 0; jLayer < AliTRDgeometry::kNlayer; jLayer++) {
       track.UnsetTracklet(jLayer);
-      ptrTracklet = const_cast<AliTRDseedV1 *>(&seeds[jLayer]);
+      ptrTracklet = &seeds[jLayer];
       if(!ptrTracklet->IsOK()) continue;
-      //if(TMath::Abs(ptrTracklet->GetYref(1) - ptrTracklet->GetYfit(1)) >= .2) continue; // check this condition with Marian
+      if(TMath::Abs(ptrTracklet->GetYref(1) - ptrTracklet->GetYfit(1)) >= .2) continue; // check this condition with Marian
       ptrTracklet = SetTracklet(ptrTracklet);
       ptrTracklet->UseClusters();
       track.SetTracklet(ptrTracklet, fTracklets->GetEntriesFast()-1);
     }
     AliTRDtrackV1 *ptrTrack = SetTrack(&track);
     ptrTrack->CookPID();
+    ptrTrack->CookLabel(.9);
     ptrTrack->SetReconstructor(fkReconstructor);
     return ptrTrack;
   }
 
+  // prevent the error message in AliTracker::MeanMaterialBudget: "start point out of geometry"
+  if(TMath::Abs(track.GetX()) + TMath::Abs(track.GetY()) + TMath::Abs(track.GetZ()) > 10000) 
+    return NULL;
+
   track.ResetCovariance(1);
   Int_t nc = TMath::Abs(FollowBackProlongation(track));
-  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 5){
+  if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 5 && fkReconstructor->IsDebugStreaming()){
     Int_t eventNumber 		= AliTRDtrackerDebug::GetEventNumber();
     Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
     Double_t p[5]; // Track Params for the Debug Stream
     track.GetExternalParameters(params[0], p);
-    TTreeSRedirector &cs = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+    TTreeSRedirector &cs = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
     cs << "MakeTrack"
     << "EventNumber="     << eventNumber
     << "CandidateNumber=" << candidateNumber
@@ -2961,61 +3085,82 @@ Int_t AliTRDtrackerV1::ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDs
   
   // make a local working copy
   AliTRDtrackingChamber *chamber = NULL;
-  AliTRDseedV1 bseed[6];
-  Int_t nLayers = 0;
-  for (Int_t jLayer = 0; jLayer < 6; jLayer++) bseed[jLayer] = cseed[jLayer];
-  
-  Float_t lastquality = 10000.0;
-  Float_t lastchi2    = 10000.0;
-  Float_t chi2        =  1000.0;
+  AliTRDseedV1 bseed[AliTRDgeometry::kNlayer];
+
+  Float_t quality(0.), 
+          lQuality[] = {1.e3, 1.e3, 1.e3, 1.e3, 1.e3, 1.e3};
+  Int_t rLayers(0);
+  for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;){ 
+    bseed[jLayer] = cseed[jLayer];
+    if(!bseed[jLayer].IsOK()) continue;
+    rLayers++;
+    lQuality[jLayer] = bseed[jLayer].GetQuality(kTRUE);
+    quality    += lQuality[jLayer];
+  }
+  Float_t chi2 = FitTiltedRieman(bseed, kTRUE);
 
   for (Int_t iter = 0; iter < 4; iter++) {
-    Float_t sumquality = 0.0;
-    Float_t squality[6];
-    Int_t   sortindexes[6];
-
-    for (Int_t jLayer = 0; jLayer < 6; jLayer++) {
-      squality[jLayer]  = bseed[jLayer].IsOK() ? bseed[jLayer].GetQuality(kTRUE) : 1000.;
-      sumquality += squality[jLayer];
-    }
-    if ((sumquality >= lastquality) || (chi2       >     lastchi2)) break;
-
-    nLayers = 0;
-    lastquality = sumquality;
-    lastchi2    = chi2;
-    if (iter > 0) for (Int_t jLayer = 0; jLayer < 6; jLayer++) cseed[jLayer] = bseed[jLayer];
-
-    TMath::Sort(6, squality, sortindexes, kFALSE);
-    for (Int_t jLayer = 5; jLayer > 1; jLayer--) {
-      Int_t bLayer = sortindexes[jLayer];
+    AliDebug(2, Form("Iter[%d] Q[%f] chi2[%f]", iter, quality, chi2));
+
+    // Try better cluster set
+    Int_t nLayers(0); Float_t qualitynew(0.);
+    Int_t  indexes[6];
+    TMath::Sort(Int_t(AliTRDgeometry::kNlayer), lQuality, indexes, kFALSE);
+    for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) {
+      Int_t bLayer = indexes[jLayer];
+      bseed[bLayer].Reset("c");
       if(!(chamber = stack[bLayer])) continue;
-      bseed[bLayer].AttachClusters(chamber, kTRUE);
+      if(!bseed[bLayer].AttachClusters(chamber, kTRUE)) continue;
       bseed[bLayer].Fit(kTRUE);
-      if(bseed[bLayer].IsOK()) nLayers++;
+      if(!bseed[bLayer].IsOK()) continue;
+      nLayers++;
+      lQuality[jLayer] = bseed[jLayer].GetQuality(kTRUE);
+      qualitynew    += lQuality[jLayer];
     }
+    if(rLayers > nLayers){
+      AliDebug(1, Form("Lost %d tracklets while improving.", rLayers-nLayers));
+      break;
+    } else rLayers=nLayers;
 
-    chi2 = FitTiltedRieman(bseed, kTRUE);
-    if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 7){
+    if(qualitynew >= quality){ 
+      AliDebug(4, Form("Quality worsen in iter[%d].", iter));
+      break;
+    } else quality = qualitynew;
+
+    // try improve track parameters
+    AliTRDseedV1 tseed[AliTRDgeometry::kNlayer];
+    for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) tseed[jLayer]=bseed[jLayer];
+    Float_t chi2new = FitTiltedRieman(tseed, kTRUE);
+    if(chi2new > chi2){ 
+      AliDebug(4, Form("Chi2 worsen in iter[%d].", iter));
+      break;
+    } else chi2 = chi2new;
+
+    // store better tracklets
+    for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) bseed[jLayer]=tseed[jLayer];
+
+
+    if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 7 && fkReconstructor->IsDebugStreaming()){
       Int_t eventNumber 		= AliTRDtrackerDebug::GetEventNumber();
       Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
       TLinearFitter *tiltedRieman = GetTiltedRiemanFitter();
-      TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+      TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
       cstreamer << "ImproveSeedQuality"
-    << "EventNumber=" 		<< eventNumber
-    << "CandidateNumber="	<< candidateNumber
-    << "Iteration="				<< iter
-    << "S0.="							<< &bseed[0]
-    << "S1.="							<< &bseed[1]
-    << "S2.="							<< &bseed[2]
-    << "S3.="							<< &bseed[3]
-    << "S4.="							<< &bseed[4]
-    << "S5.="							<< &bseed[5]
-    << "FitterT.="				<< tiltedRieman
-    << "\n";
+        << "EventNumber=" 		<< eventNumber
+        << "CandidateNumber="	<< candidateNumber
+        << "Iteration="				<< iter
+        << "S0.="							<< &bseed[0]
+        << "S1.="							<< &bseed[1]
+        << "S2.="							<< &bseed[2]
+        << "S3.="							<< &bseed[3]
+        << "S4.="							<< &bseed[4]
+        << "S5.="							<< &bseed[5]
+        << "FitterT.="				<< tiltedRieman
+        << "\n";
     }
   } // Loop: iter
   // we are sure that at least 2 tracklets are OK !
-  return nLayers+2;
+  return rLayers;
 }
 
 //_________________________________________________________________________
@@ -3047,16 +3192,16 @@ Double_t AliTRDtrackerV1::CalculateTrackLikelihood(const AliTRDseedV1 *const tra
   chi2phi /= Float_t (nLayers - 2.0);
   
   Double_t likeChi2Z  = TMath::Exp(-chi2[2] * 0.14);			// Chi2Z 
-  Double_t likeChi2TC = (fkReconstructor->HasVertexConstrained()) ? 
+  Double_t likeChi2TC = (fkReconstructor->GetRecoParam()->IsVertexConstrained()) ? 
   											TMath::Exp(-chi2[1] * 0.677) : 1;			// Constrained Tilted Riemann
   Double_t likeChi2TR = TMath::Exp(-chi2[0] * 0.0078);			// Non-constrained Tilted Riemann
   Double_t likeChi2Phi= TMath::Exp(-chi2phi * 3.23);//3.23
   Double_t trackLikelihood     = likeChi2Z * likeChi2TR * likeChi2Phi;
 
-  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+  if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
     Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
     Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
-    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
     cstreamer << "CalculateTrackLikelihood0"
         << "EventNumber="			<< eventNumber
         << "CandidateNumber="	<< candidateNumber
@@ -3120,7 +3265,7 @@ Double_t AliTRDtrackerV1::CookLikelihood(AliTRDseedV1 *cseed, Int_t planes[4])
   Double_t likeN     = TMath::Exp(-(fRecoPars->GetNMeanClusters() - nclusters) / fRecoPars->GetNSigmaClusters());
   Double_t like      = likea * likechi2y * likechi2z * likeN;
 
-  if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+  if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
     Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
     Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
     Int_t nTracklets = 0; Float_t meanNcls = 0;
@@ -3131,7 +3276,7 @@ Double_t AliTRDtrackerV1::CookLikelihood(AliTRDseedV1 *cseed, Int_t planes[4])
     }
     if(nTracklets) meanNcls /= nTracklets;
     // The Debug Stream contains the seed 
-    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+    TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
     cstreamer << "CookLikelihood"
         << "EventNumber="			<< eventNumber
         << "CandidateNumber=" << candidateNumber
@@ -3381,6 +3526,7 @@ void AliTRDtrackerV1::GetExtrapolationConfig(Int_t iconfig, Int_t planes[2])
 //____________________________________________________________________
 AliCluster* AliTRDtrackerV1::GetCluster(Int_t idx) const
 {
+  if(!fClusters) return NULL;
   Int_t ncls = fClusters->GetEntriesFast();
   return idx >= 0 && idx < ncls ? (AliCluster*)fClusters->UncheckedAt(idx) : NULL;
 }
@@ -3388,6 +3534,7 @@ AliCluster* AliTRDtrackerV1::GetCluster(Int_t idx) const
 //____________________________________________________________________
 AliTRDseedV1* AliTRDtrackerV1::GetTracklet(Int_t idx) const
 {
+  if(!fTracklets) return NULL;
   Int_t ntrklt = fTracklets->GetEntriesFast();
   return idx >= 0 && idx < ntrklt ? (AliTRDseedV1*)fTracklets->UncheckedAt(idx) : NULL;
 }
@@ -3395,6 +3542,7 @@ AliTRDseedV1* AliTRDtrackerV1::GetTracklet(Int_t idx) const
 //____________________________________________________________________
 AliKalmanTrack* AliTRDtrackerV1::GetTrack(Int_t idx) const
 {
+  if(!fTracks) return NULL;
   Int_t ntrk = fTracks->GetEntriesFast();
   return idx >= 0 && idx < ntrk ? (AliKalmanTrack*)fTracks->UncheckedAt(idx) : NULL;
 }
@@ -3594,9 +3742,26 @@ Double_t AliTRDtrackerV1::FitTiltedRiemanV1(AliTRDseedV1 *const tracklets){
 
 //_____________________________________________________________________________
 AliTRDtrackerV1::AliTRDLeastSquare::AliTRDLeastSquare(){
-  //
-  // Constructor of the nested class AliTRDtrackFitterLeastSquare
-  //
+//
+// Constructor of the nested class AliTRDtrackFitterLeastSquare
+//
+// Fast solving linear regresion in 2D
+//         y=a + bx
+// The data members have the following meaning
+// fParams[0] : a
+// fParams[1] : b
+// 
+// fSums[0] : S
+// fSums[1] : Sx
+// fSums[2] : Sy
+// fSums[3] : Sxy
+// fSums[4] : Sxx
+// fSums[5] : Syy
+// 
+// fCovarianceMatrix[0] : s2a
+// fCovarianceMatrix[1] : s2b
+// fCovarianceMatrix[2] : cov(ab)
+
   memset(fParams, 0, sizeof(Double_t) * 2);
   memset(fSums, 0, sizeof(Double_t) * 6);
   memset(fCovarianceMatrix, 0, sizeof(Double_t) * 3);
@@ -3608,6 +3773,7 @@ void AliTRDtrackerV1::AliTRDLeastSquare::AddPoint(const Double_t *const x, Doubl
   //
   // Adding Point to the fitter
   //
+  
   Double_t weight = 1/(sigmaY > 1e-9 ? sigmaY : 1e-9);
   weight *= weight;
   const Double_t &xpt = *x;
@@ -3625,7 +3791,7 @@ void AliTRDtrackerV1::AliTRDLeastSquare::RemovePoint(const Double_t *const x, Do
   //
   // Remove Point from the sample
   //
-  
+
   Double_t weight = 1/(sigmaY > 1e-9 ? sigmaY : 1e-9);
   weight *= weight;
   const Double_t &xpt = *x; 
@@ -3638,27 +3804,35 @@ void AliTRDtrackerV1::AliTRDLeastSquare::RemovePoint(const Double_t *const x, Do
 }
 
 //_____________________________________________________________________________
-void AliTRDtrackerV1::AliTRDLeastSquare::Eval(){
+Bool_t AliTRDtrackerV1::AliTRDLeastSquare::Eval(){
   //
   // Evaluation of the fit:
   // Calculation of the parameters
   // Calculation of the covariance matrix
   //
   
-  Double_t denominator = fSums[0] * fSums[4] - fSums[1] *fSums[1];
-  if(denominator==0) return;
+  Double_t det = fSums[0] * fSums[4] - fSums[1] *fSums[1];
+  if(det==0) return kFALSE;
 
   //	for(Int_t isum = 0; isum < 5; isum++)
   //		printf("fSums[%d] = %f\n", isum, fSums[isum]);
   //	printf("denominator = %f\n", denominator);
-  fParams[0] = (fSums[2] * fSums[4] - fSums[1] * fSums[3])/ denominator;
-  fParams[1] = (fSums[0] * fSums[3] - fSums[1] * fSums[2]) / denominator;
+  fParams[0] = (fSums[2] * fSums[4] - fSums[1] * fSums[3])/det;
+  fParams[1] = (fSums[0] * fSums[3] - fSums[1] * fSums[2])/det;
   //	printf("fParams[0] = %f, fParams[1] = %f\n", fParams[0], fParams[1]);
   
   // Covariance matrix
-  fCovarianceMatrix[0] = fSums[4] / fSums[0] - fSums[1] * fSums[1] / (fSums[0] * fSums[0]);
+  Double_t den = fSums[0]*fSums[4] - fSums[1]*fSums[1];
+  fCovarianceMatrix[0] = fSums[4] / den;
+  fCovarianceMatrix[1] = fSums[0] / den;
+  fCovarianceMatrix[2] = -fSums[1] / den;
+/*  fCovarianceMatrix[0] = fSums[4] / fSums[0] - fSums[1] * fSums[1] / (fSums[0] * fSums[0]);
   fCovarianceMatrix[1] = fSums[5] / fSums[0] - fSums[2] * fSums[2] / (fSums[0] * fSums[0]);
-  fCovarianceMatrix[2] = fSums[3] / fSums[0] - fSums[1] * fSums[2] / (fSums[0] * fSums[0]);
+  fCovarianceMatrix[2] = fSums[3] / fSums[0] - fSums[1] * fSums[2] / (fSums[0] * fSums[0]);*/
+
+
+
+  return kTRUE;
 }
 
 //_____________________________________________________________________________