- Adding check and flagging for HG present
[u/mrichter/AliRoot.git] / MUON / AliMUONTrackReconstructorK.cxx
index 8e0dccb..8c265ba 100644 (file)
@@ -15,8 +15,8 @@
 
 /* $Id$ */
 
+//-----------------------------------------------------------------------------
 /// \class AliMUONTrackReconstructorK
-/////////////////////////////////////
 ///
 /// MUON track reconstructor using the kalman method
 ///
 /// It contains as methods, among others:
 /// - MakeTracks to build the tracks
 ///
-////////////////////////////////////
+//-----------------------------------------------------------------------------
 
 #include "AliMUONTrackReconstructorK.h"
+
 #include "AliMUONConstants.h"
-#include "AliMUONHitForRec.h"
+#include "AliMUONVCluster.h"
+#include "AliMUONVClusterServer.h"
+#include "AliMUONVClusterStore.h"
 #include "AliMUONTrack.h"
 #include "AliMUONTrackParam.h"
 #include "AliMUONTrackExtrap.h"
+#include "AliMUONRecoParam.h"
+
+#include "AliMpArea.h"
 
 #include "AliLog.h"
 
 ClassImp(AliMUONTrackReconstructorK) // Class implementation in ROOT context
 /// \endcond
 
-//************* Defaults parameters for reconstruction
-const Bool_t AliMUONTrackReconstructorK::fgkRunSmoother = kTRUE;
-
-
   //__________________________________________________________________________
-AliMUONTrackReconstructorK::AliMUONTrackReconstructorK()
-  : AliMUONVTrackReconstructor()
+AliMUONTrackReconstructorK::AliMUONTrackReconstructorK(const AliMUONRecoParam* recoParam, AliMUONVClusterServer* clusterServer)
+  : AliMUONVTrackReconstructor(recoParam, clusterServer)
 {
-  /// Constructor for class AliMUONTrackReconstructorK
-  AliInfo("*** Tracking with Kalman Filter ***");
+  /// Constructor
 }
 
   //__________________________________________________________________________
@@ -64,212 +65,371 @@ AliMUONTrackReconstructorK::~AliMUONTrackReconstructorK()
 } 
 
   //__________________________________________________________________________
-void AliMUONTrackReconstructorK::MakeTrackCandidates()
+Bool_t AliMUONTrackReconstructorK::MakeTrackCandidates(AliMUONVClusterStore& clusterStore)
 {
-  /// To make track candidates (assuming linear propagation if the flag fgkMakeTrackCandidatesFast is set to kTRUE):
+  /// To make track candidates (assuming linear propagation if AliMUONRecoParam::MakeTrackCandidatesFast() return kTRUE):
   /// Start with segments station(1..) 4 or 5 then follow track in station 5 or 4.
-  /// Good candidates are made of at least three hitForRec's.
-  /// Keep only best candidates or all of them according to the flag fgkTrackAllTracks.
+  /// Good candidates are made of at least three clusters if both stations are requested (two otherwise).
+  /// Keep only best candidates or all of them according to the flag AliMUONRecoParam::TrackAllTracks().
+  
   TClonesArray *segments;
+  AliMUONObjectPair *segment;
   AliMUONTrack *track;
   Int_t iCandidate = 0;
-  Bool_t hitFound;
+  Bool_t clusterFound;
 
   AliDebug(1,"Enter MakeTrackCandidates");
 
+  // Unless we're doing combined tracking, we'll clusterize all stations at once
+  Int_t firstChamber(0);
+  Int_t lastChamber(9);
+  
+  if (GetRecoParam()->CombineClusterTrackReco()) {
+    // ... Here's the exception : ask the clustering to reconstruct
+    // clusters *only* in station 4 and 5 for combined tracking
+    firstChamber = 6;
+  }
+  
+  for (Int_t i = firstChamber; i <= lastChamber; ++i ) 
+  {
+    if (fClusterServer && GetRecoParam()->UseChamber(i)) fClusterServer->Clusterize(i, clusterStore, AliMpArea(), GetRecoParam());
+  }
+  
   // Loop over stations(1..) 5 and 4 and make track candidates
   for (Int_t istat=4; istat>=3; istat--) {
     
     // Make segments in the station
-    segments = MakeSegmentsInStation(istat);
+    segments = MakeSegmentsBetweenChambers(clusterStore, 2*istat, 2*istat+1);
     
     // Loop over segments
-    for (Int_t iseg=0; iseg<segments->GetEntriesFast(); iseg++) {
+    for (Int_t iSegment=0; iSegment<segments->GetEntriesFast(); iSegment++) {
       AliDebug(1,Form("Making primary candidate(1..) %d",++iCandidate));
+      segment = (AliMUONObjectPair*) segments->UncheckedAt(iSegment);
       
       // Transform segments to tracks and put them at the end of fRecTracksPtr
-      track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack((AliMUONObjectPair*)((*segments)[iseg]));
+      track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(segment,GetRecoParam()->GetBendingVertexDispersion());
       fNRecTracks++;
       
-      // Printout for debuging
-      if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
-        cout<<endl<<"Track parameter covariances at first hit:"<<endl;
-        ((AliMUONTrackParam*) (track->GetTrackParamAtHit()->First()))->GetCovariances().Print();
-      }
+      // Look for compatible cluster(s) in the other station
+      if (GetRecoParam()->MakeTrackCandidatesFast()) clusterFound = FollowLinearTrackInStation(*track, clusterStore, 7-istat);
+      else clusterFound = FollowTrackInStation(*track, clusterStore, 7-istat);
       
-      // Look for compatible hitForRec(s) in the other station
-      if (fgkMakeTrackCandidatesFast) hitFound = FollowLinearTrackInStation(*track,7-istat);
-      else {
-        // First recompute track parameters and covariances on station(1..) 5 using Kalman filter
-        // (to make sure all tracks are treated in the same way)
-        if (istat == 4) RetraceTrack(*track,kFALSE);
-       hitFound = FollowTrackInStation(*track,7-istat);
-      }
-      
-      // Remove track if no hit found
-      if (!hitFound) {
-        fRecTracksPtr->Remove(track);
-       fNRecTracks--;
+      // Remove track if no cluster found on a requested station
+      // or abort tracking if there are too many candidates
+      if (GetRecoParam()->RequestStation(7-istat)) {
+       if (!clusterFound) {
+         fRecTracksPtr->Remove(track);
+         fNRecTracks--;
+       } else if (fNRecTracks > GetRecoParam()->GetMaxTrackCandidates()) {
+         AliError(Form("Too many track candidates (%d tracks). Stop tracking.", fNRecTracks));
+         delete segments;
+         return kFALSE;
+       }
+      } else {
+       if ((fNRecTracks + segments->GetEntriesFast() - iSegment - 1) > GetRecoParam()->GetMaxTrackCandidates()) {
+         AliError(Form("Too many track candidates (%d tracks). Stop tracking.", fNRecTracks + segments->GetEntriesFast() - iSegment - 1));
+         delete segments;
+         return kFALSE;
+       }
       }
       
     }
+    
     // delete the array of segments
     delete segments;
   }
   
+  // Keep all different tracks if required
+  if (GetRecoParam()->TrackAllTracks()) RemoveIdenticalTracks();
   
-  // Retrace tracks using Kalman filter and remove bad ones
-  if (fgkMakeTrackCandidatesFast) {
-    fRecTracksPtr->Compress(); // this is essential before checking tracks
+  // Retrace tracks using Kalman filter and select them if needed
+  Int_t nCurrentTracks = fRecTracksPtr->GetLast()+1;
+  for (Int_t iRecTrack = 0; iRecTrack < nCurrentTracks; iRecTrack++) {
+    track = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iRecTrack);
     
-    Int_t currentNRecTracks = fNRecTracks;
-    for (Int_t iRecTrack = 0; iRecTrack < currentNRecTracks; iRecTrack++) {
-      track = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iRecTrack);
+    // skip empty slots
+    if(!track) continue;
+    
+    // retrace tracks using Kalman filter and remove the ones for which extrap failed or that are out of limits
+    if (!RetraceTrack(*track,kTRUE) || !IsAcceptable(*((AliMUONTrackParam*)track->GetTrackParamAtCluster()->First()))) {
+      fRecTracksPtr->Remove(track);
+      fNRecTracks--;
+    }
+    
+  }
+  
+  // Keep only the best tracks if required
+  if (!GetRecoParam()->TrackAllTracks()) RemoveDoubleTracks();
+  else fRecTracksPtr->Compress();
+  
+  AliDebug(1,Form("Number of good candidates = %d",fNRecTracks));
+  
+  return kTRUE;
+  
+}
+
+  //__________________________________________________________________________
+Bool_t AliMUONTrackReconstructorK::MakeMoreTrackCandidates(AliMUONVClusterStore& clusterStore)
+{
+  /// To make extra track candidates assuming linear propagation:
+  /// clustering is supposed to be already done
+  /// Start with segments made of 1 cluster in each of the stations 4 and 5 then follow track in remaining chambers.
+  /// Good candidates are made of at least three clusters if both stations are requested (two otherwise).
+  /// Keep only best candidates or all of them according to the flag fgkTrackAllTracks.
+  
+  TClonesArray *segments;
+  AliMUONObjectPair *segment;
+  AliMUONTrack *track;
+  Int_t iCandidate = 0, iCurrentTrack, nCurrentTracks;
+  Int_t initialNRecTracks = fNRecTracks;
+  Bool_t clusterFound;
+  
+  AliDebug(1,"Enter MakeMoreTrackCandidates");
+  
+  // Double loop over chambers in stations(1..) 4 and 5 to make track candidates
+  for (Int_t ich1 = 6; ich1 <= 7; ich1++) {
+    for (Int_t ich2 = 8; ich2 <= 9; ich2++) {
+      
+      // Make segments between ch1 and ch2
+      segments = MakeSegmentsBetweenChambers(clusterStore, ich1, ich2);
       
-      // Recompute track parameters and covariances using Kalman filter
-      RetraceTrack(*track,kTRUE);
+      /// Remove segments already attached to a track
+      RemoveUsedSegments(*segments);
       
-      // Remove the track if the normalized chi2 is too high
-      if (track->GetNormalizedChi2() > fgkSigmaToCutForTracking * fgkSigmaToCutForTracking) {
-        fRecTracksPtr->Remove(track);
-        fNRecTracks--;
+      // Loop over segments
+      for (Int_t iSegment=0; iSegment<segments->GetEntriesFast(); iSegment++) {
+       AliDebug(1,Form("Making primary candidate(1..) %d",++iCandidate));
+       segment = (AliMUONObjectPair*) segments->UncheckedAt(iSegment);
+       
+       // Transform segments to tracks and put them at the end of fRecTracksPtr
+       iCurrentTrack = fRecTracksPtr->GetLast()+1;
+       track = new ((*fRecTracksPtr)[iCurrentTrack]) AliMUONTrack(segment,GetRecoParam()->GetBendingVertexDispersion());
+       fNRecTracks++;
+       
+       // Look for compatible cluster(s) in the second chamber of station 5
+       clusterFound = FollowLinearTrackInChamber(*track, clusterStore, 17-ich2);
+       
+       // skip the original track in case it has been removed
+       if (GetRecoParam()->TrackAllTracks() && clusterFound) iCurrentTrack++;
+       
+       // loop over every new tracks
+       nCurrentTracks = fRecTracksPtr->GetLast()+1;
+       while (iCurrentTrack < nCurrentTracks) {
+         track = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iCurrentTrack);
+         
+         // Look for compatible cluster(s) in the second chamber of station 4
+         FollowLinearTrackInChamber(*track, clusterStore, 13-ich1);
+         
+         iCurrentTrack++;
+       }
+       
+       // abort tracking if there are too many candidates
+       if ((fNRecTracks + segments->GetEntriesFast() - iSegment - 1) > GetRecoParam()->GetMaxTrackCandidates()) {
+         AliError(Form("Too many track candidates (%d tracks). Stop tracking.", fNRecTracks + segments->GetEntriesFast() - iSegment - 1));
+         delete segments;
+         return kFALSE;
+       }
+       
       }
       
+      // delete the array of segments
+      delete segments;
     }
-    
   }
   
-  fRecTracksPtr->Compress(); // this is essential before checking tracks
+  // Retrace tracks using Kalman filter (also compute track chi2) and select them
+  nCurrentTracks = fRecTracksPtr->GetLast()+1;
+  for (Int_t iRecTrack = initialNRecTracks; iRecTrack < nCurrentTracks; iRecTrack++) {
+    track = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iRecTrack);
+    
+    // skip empty slots
+    if(!track) continue;
+    
+    // retrace tracks using Kalman filter and remove the ones for which extrap failed or that are out of limits
+    if (!RetraceTrack(*track,kTRUE) || !IsAcceptable(*((AliMUONTrackParam*)track->GetTrackParamAtCluster()->First()))) {
+      fRecTracksPtr->Remove(track);
+      fNRecTracks--;
+    }
+    
+  }
   
-  // Keep all different tracks or only the best ones as required
-  if (fgkTrackAllTracks) RemoveIdenticalTracks();
-  else RemoveDoubleTracks();
+  // Keep only the best tracks if required
+  if (!GetRecoParam()->TrackAllTracks()) RemoveDoubleTracks();
+  else fRecTracksPtr->Compress();
   
   AliDebug(1,Form("Number of good candidates = %d",fNRecTracks));
   
+  return kTRUE;
+  
 }
 
   //__________________________________________________________________________
-void AliMUONTrackReconstructorK::RetraceTrack(AliMUONTrack &trackCandidate, Bool_t resetSeed)
+Bool_t AliMUONTrackReconstructorK::RetraceTrack(AliMUONTrack &trackCandidate, Bool_t resetSeed)
 {
-  /// Re-run the kalman filter from the most downstream hit to the most uptream one
+  /// Re-run the kalman filter from the most downstream cluster to the most uptream one
+  /// Return kFALSE in case of failure (i.e. extrapolation problem)
   AliDebug(1,"Enter RetraceTrack");
   
-  AliMUONTrackParam* startingTrackParam = (AliMUONTrackParam*) trackCandidate.GetTrackParamAtHit()->Last();
+  AliMUONTrackParam* lastTrackParam = (AliMUONTrackParam*) trackCandidate.GetTrackParamAtCluster()->Last();
   
-  // Reset the "seed" (= track parameters and their covariances at last hit) if required
+  // Reset the "seed" (= track parameters and their covariances at last cluster) if required
   if (resetSeed) {
-    // => Shift track parameters at the position of the last hit
-    AliMUONHitForRec* hitForRecAtHit = startingTrackParam->GetHitForRecPtr();
-    startingTrackParam->SetNonBendingCoor(hitForRecAtHit->GetNonBendingCoor());
-    startingTrackParam->SetBendingCoor(hitForRecAtHit->GetBendingCoor());
-    
-    // => Re-compute and reset track parameters covariances at last hit (as if the other hits did not exist)
-    const TMatrixD& kParamCov = startingTrackParam->GetCovariances();
-    TMatrixD newParamCov(5,5);
-    newParamCov.Zero();
+    
+    // parameters at last cluster
+    AliMUONVCluster* cluster2 = lastTrackParam->GetClusterPtr();
+    Double_t x2 = cluster2->GetX();
+    Double_t y2 = cluster2->GetY();
+    Double_t z2 = cluster2->GetZ();
+    
+    // parameters at last but one cluster
+    AliMUONTrackParam* previousTrackParam = (AliMUONTrackParam*) trackCandidate.GetTrackParamAtCluster()->Before(lastTrackParam);
+    AliMUONVCluster* cluster1 = previousTrackParam->GetClusterPtr();
+    // make sure it is on the previous chamber (can have 2 clusters in the same chamber after "ComplementTrack")
+    if (cluster2->GetChamberId() == cluster1->GetChamberId()) {
+      previousTrackParam = (AliMUONTrackParam*) trackCandidate.GetTrackParamAtCluster()->Before(previousTrackParam);
+      cluster1 = previousTrackParam->GetClusterPtr();
+    }
+    Double_t x1 = cluster1->GetX();
+    Double_t y1 = cluster1->GetY();
+    Double_t z1 = cluster1->GetZ();
+    
+    // reset track parameters
+    Double_t dZ = z1 - z2;
+    lastTrackParam->SetNonBendingCoor(x2);
+    lastTrackParam->SetBendingCoor(y2);
+    lastTrackParam->SetZ(z2);
+    lastTrackParam->SetNonBendingSlope((x1 - x2) / dZ);
+    lastTrackParam->SetBendingSlope((y1 - y2) / dZ);
+    Double_t bendingImpact = y2 - z2 * lastTrackParam->GetBendingSlope();
+    Double_t inverseBendingMomentum = 1. / AliMUONTrackExtrap::GetBendingMomentumFromImpactParam(bendingImpact);
+    lastTrackParam->SetInverseBendingMomentum(inverseBendingMomentum);
+    
+    // => Reset track parameter covariances at last cluster (as if the other clusters did not exist)
+    TMatrixD lastParamCov(5,5);
+    lastParamCov.Zero();
     // Non bending plane
-    newParamCov(0,0) = hitForRecAtHit->GetNonBendingReso2();
-    newParamCov(1,1) = 100.*kParamCov(1,1);
+    lastParamCov(0,0) = cluster2->GetErrX2();
+    lastParamCov(0,1) = - cluster2->GetErrX2() / dZ;
+    lastParamCov(1,0) = lastParamCov(0,1);
+    lastParamCov(1,1) = ( 1000. * cluster1->GetErrX2() + cluster2->GetErrX2() ) / dZ / dZ;
     // Bending plane
-    newParamCov(2,2) = hitForRecAtHit->GetBendingReso2();
-    newParamCov(3,3) = 100.*kParamCov(3,3);
-    // Inverse bending momentum
-    newParamCov(4,4) = 0.5*startingTrackParam->GetInverseBendingMomentum() * 0.5*startingTrackParam->GetInverseBendingMomentum();
-    startingTrackParam->SetCovariances(newParamCov);
+    lastParamCov(2,2) = cluster2->GetErrY2();
+    lastParamCov(2,3) = - cluster2->GetErrY2() / dZ;
+    lastParamCov(3,2) = lastParamCov(2,3);
+    lastParamCov(3,3) = ( 1000. * cluster1->GetErrY2() + cluster2->GetErrY2() ) / dZ / dZ;
+    // Inverse bending momentum (vertex resolution + bending slope resolution + 10% error on dipole parameters+field)
+    if (AliMUONTrackExtrap::IsFieldON()) {
+      lastParamCov(4,4) = ((GetRecoParam()->GetBendingVertexDispersion() *
+                           GetRecoParam()->GetBendingVertexDispersion() +
+                           (z1 * z1 * cluster2->GetErrY2() + z2 * z2 * 1000. * cluster1->GetErrY2()) / dZ / dZ) /
+                          bendingImpact / bendingImpact + 0.1 * 0.1) * inverseBendingMomentum * inverseBendingMomentum;
+      lastParamCov(2,4) = z1 * cluster2->GetErrY2() * inverseBendingMomentum / bendingImpact / dZ;
+      lastParamCov(4,2) = lastParamCov(2,4);
+      lastParamCov(3,4) = - (z1 * cluster2->GetErrY2() + z2 * 1000. * cluster1->GetErrY2()) *
+      inverseBendingMomentum / bendingImpact / dZ / dZ;
+      lastParamCov(4,3) = lastParamCov(3,4);
+    } else lastParamCov(4,4) = inverseBendingMomentum*inverseBendingMomentum;
+    lastTrackParam->SetCovariances(lastParamCov);
     
     // Reset the track chi2
-    startingTrackParam->SetTrackChi2(0.);
+    lastTrackParam->SetTrackChi2(0.);
   
   }
   
   // Redo the tracking
-  RetracePartialTrack(trackCandidate, startingTrackParam);
+  return RetracePartialTrack(trackCandidate, lastTrackParam);
   
 }
 
   //__________________________________________________________________________
-void AliMUONTrackReconstructorK::RetracePartialTrack(AliMUONTrack &trackCandidate, const AliMUONTrackParam* startingTrackParam)
+Bool_t AliMUONTrackReconstructorK::RetracePartialTrack(AliMUONTrack &trackCandidate, const AliMUONTrackParam* startingTrackParam)
 {
-  /// Re-run the kalman filter from the hit attached to startingTrackParam to the most uptream hit
+  /// Re-run the kalman filter from the cluster attached to startingTrackParam to the most uptream cluster
+  /// Return kFALSE in case of failure (i.e. extrapolation problem)
   AliDebug(1,"Enter RetracePartialTrack");
   
   // Printout for debuging
   if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-    cout << "RetracePartialTrack: track chi2 before re-tracking: " << trackCandidate.GetFitFMin() << endl;
+    cout << "RetracePartialTrack: track chi2 before re-tracking: " << trackCandidate.GetGlobalChi2() << endl;
   }
   
   // Reset the track chi2
-  trackCandidate.SetFitFMin(startingTrackParam->GetTrackChi2());
+  trackCandidate.SetGlobalChi2(startingTrackParam->GetTrackChi2());
   
-  // loop over attached hits until the first one and recompute track parameters and covariances using kalman filter
-  Int_t expectedChamber = startingTrackParam->GetHitForRecPtr()->GetChamberNumber() - 1;
+  // loop over attached clusters until the first one and recompute track parameters and covariances using kalman filter
+  Bool_t extrapStatus = kTRUE;
+  Int_t expectedChamber = startingTrackParam->GetClusterPtr()->GetChamberId() - 1;
   Int_t currentChamber;
-  Double_t addChi2TrackAtHit;
-  AliMUONTrackParam* trackParamAtHit = (AliMUONTrackParam*) trackCandidate.GetTrackParamAtHit()->Before(startingTrackParam); 
-  while (trackParamAtHit) {
+  Double_t addChi2TrackAtCluster;
+  AliMUONTrackParam* trackParamAtCluster = (AliMUONTrackParam*) trackCandidate.GetTrackParamAtCluster()->Before(startingTrackParam); 
+  while (trackParamAtCluster) {
     
     // reset track parameters and their covariances
-    trackParamAtHit->SetParameters(startingTrackParam->GetParameters());
-    trackParamAtHit->SetZ(startingTrackParam->GetZ());
-    trackParamAtHit->SetCovariances(startingTrackParam->GetCovariances());
+    trackParamAtCluster->SetParameters(startingTrackParam->GetParameters());
+    trackParamAtCluster->SetZ(startingTrackParam->GetZ());
+    trackParamAtCluster->SetCovariances(startingTrackParam->GetCovariances());
     
     // add MCS effect
-    AliMUONTrackExtrap::AddMCSEffect(trackParamAtHit,AliMUONConstants::ChamberThicknessInX0(),1.);
+    AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(expectedChamber+1),-1.);
     
     // reset propagator for smoother
-    if (fgkRunSmoother) trackParamAtHit->ResetPropagator();
+    if (GetRecoParam()->UseSmoother()) trackParamAtCluster->ResetPropagator();
     
-    // add MCS in missing chambers if any (at most 2 chambers can be missing according to tracking criteria)
-    currentChamber = trackParamAtHit->GetHitForRecPtr()->GetChamberNumber();
+    // add MCS in missing chambers if any
+    currentChamber = trackParamAtCluster->GetClusterPtr()->GetChamberId();
     while (currentChamber < expectedChamber) {
       // extrapolation to the missing chamber (update the propagator)
-      AliMUONTrackExtrap::ExtrapToZCov(trackParamAtHit, AliMUONConstants::DefaultChamberZ(expectedChamber), fgkRunSmoother);
+      if (!AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, AliMUONConstants::DefaultChamberZ(expectedChamber),
+                                           GetRecoParam()->UseSmoother())) extrapStatus = kFALSE;
       // add MCS effect
-      AliMUONTrackExtrap::AddMCSEffect(trackParamAtHit,AliMUONConstants::ChamberThicknessInX0(),1.);
+      AliMUONTrackExtrap::AddMCSEffect(trackParamAtCluster,AliMUONConstants::ChamberThicknessInX0(expectedChamber),-1.);
       expectedChamber--;
     }
     
-    // extrapolation to the plane of the hitForRec attached to the current trackParamAtHit (update the propagator)
-    AliMUONTrackExtrap::ExtrapToZCov(trackParamAtHit, trackParamAtHit->GetHitForRecPtr()->GetZ(), fgkRunSmoother);
+    // extrapolation to the plane of the cluster attached to the current trackParamAtCluster (update the propagator)
+    if (!AliMUONTrackExtrap::ExtrapToZCov(trackParamAtCluster, trackParamAtCluster->GetClusterPtr()->GetZ(),
+                                         GetRecoParam()->UseSmoother())) extrapStatus = kFALSE;
     
-    if (fgkRunSmoother) {
+    if (GetRecoParam()->UseSmoother()) {
       // save extrapolated parameters for smoother
-      trackParamAtHit->SetExtrapParameters(trackParamAtHit->GetParameters());
+      trackParamAtCluster->SetExtrapParameters(trackParamAtCluster->GetParameters());
       
       // save extrapolated covariance matrix for smoother
-      trackParamAtHit->SetExtrapCovariances(trackParamAtHit->GetCovariances());
+      trackParamAtCluster->SetExtrapCovariances(trackParamAtCluster->GetCovariances());
     }
     
-    // Compute new track parameters including "hitForRecCh2" using kalman filter
-    addChi2TrackAtHit = RunKalmanFilter(*trackParamAtHit);
+    // Compute new track parameters using kalman filter
+    addChi2TrackAtCluster = RunKalmanFilter(*trackParamAtCluster);
     
     // Update the track chi2
-    trackCandidate.SetFitFMin(trackCandidate.GetFitFMin() + addChi2TrackAtHit);
-    trackParamAtHit->SetTrackChi2(trackCandidate.GetFitFMin());
+    trackCandidate.SetGlobalChi2(trackCandidate.GetGlobalChi2() + addChi2TrackAtCluster);
+    trackParamAtCluster->SetTrackChi2(trackCandidate.GetGlobalChi2());
     
-    // prepare next step, add MCS effects in parameter covariances
-    expectedChamber--;
-    startingTrackParam = trackParamAtHit;
-    trackParamAtHit = (AliMUONTrackParam*) (trackCandidate.GetTrackParamAtHit()->Before(startingTrackParam)); 
+    // prepare next step
+    expectedChamber = currentChamber - 1;
+    startingTrackParam = trackParamAtCluster;
+    trackParamAtCluster = (AliMUONTrackParam*) (trackCandidate.GetTrackParamAtCluster()->Before(startingTrackParam)); 
   }
   
   // Printout for debuging
   if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-    cout << "RetracePartialTrack: track chi2 after re-tracking: " << trackCandidate.GetFitFMin() << endl;
+    cout << "RetracePartialTrack: track chi2 after re-tracking: " << trackCandidate.GetGlobalChi2() << endl;
   }
   
+  // set global chi2 to max value in case of problem during track extrapolation
+  if (!extrapStatus) trackCandidate.SetGlobalChi2(2.*AliMUONTrack::MaxChi2());
+  return extrapStatus;
+  
 }
 
   //__________________________________________________________________________
-void AliMUONTrackReconstructorK::FollowTracks()
+Bool_t AliMUONTrackReconstructorK::FollowTracks(AliMUONVClusterStore& clusterStore)
 {
   /// Follow tracks in stations(1..) 3, 2 and 1
   AliDebug(1,"Enter FollowTracks");
   
   AliMUONTrack *track;
   Int_t currentNRecTracks;
-  Bool_t hitFound;
   
   for (Int_t station = 2; station >= 0; station--) {
     
@@ -283,22 +443,45 @@ void AliMUONTrackReconstructorK::FollowTracks()
       
       track = (AliMUONTrack*) fRecTracksPtr->UncheckedAt(iRecTrack);
       
-      // Printout for debuging
-      if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
-        cout<<endl<<"Track parameter covariances at first hit:"<<endl;
-        ((AliMUONTrackParam*) (track->GetTrackParamAtHit()->First()))->GetCovariances().Print();
+      // Look for compatible cluster(s) in station(0..) "station"
+      if (!FollowTrackInStation(*track, clusterStore, station)) {
+       
+       // Try to recover track if required
+       if (GetRecoParam()->RecoverTracks()) {
+         
+         // work on a copy of the track if this station is not required
+         // to keep the case where no cluster is reconstructed as a possible candidate
+         if (!GetRecoParam()->RequestStation(station)) {
+           track = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(*track);
+           fNRecTracks++;
+         }
+         
+         // try to recover
+         if (!RecoverTrack(*track, clusterStore, station)) {
+           // remove track if no cluster found
+           fRecTracksPtr->Remove(track);
+           fNRecTracks--;
+         }
+         
+       } else if (GetRecoParam()->RequestStation(station)) {
+         // remove track if no cluster found
+         fRecTracksPtr->Remove(track);
+         fNRecTracks--;
+       } 
+       
       }
       
-      // Look for compatible hitForRec in station(0..) "station"
-      hitFound = FollowTrackInStation(*track,station);
-      
-      // Try to recover track if required
-      if (!hitFound && fgkRecoverTracks) hitFound = RecoverTrack(*track,station);
-      
-      // remove track if no hit found
-      if (!hitFound) {
-       fRecTracksPtr->Remove(track);
-       fNRecTracks--;
+      // abort tracking if there are too many candidates
+      if (GetRecoParam()->RequestStation(station)) {
+       if (fNRecTracks > GetRecoParam()->GetMaxTrackCandidates()) {
+         AliError(Form("Too many track candidates (%d tracks). Stop tracking.", fNRecTracks));
+         return kFALSE;
+       }
+      } else {
+       if ((fNRecTracks + currentNRecTracks - iRecTrack - 1) > GetRecoParam()->GetMaxTrackCandidates()) {
+         AliError(Form("Too many track candidates (%d tracks). Stop tracking.", fNRecTracks + currentNRecTracks - iRecTrack - 1));
+         return kFALSE;
+       }
       }
       
     }
@@ -306,22 +489,185 @@ void AliMUONTrackReconstructorK::FollowTracks()
     fRecTracksPtr->Compress(); // this is essential before checking tracks
     
     // Keep only the best tracks if required
-    if (!fgkTrackAllTracks) RemoveDoubleTracks();
+    if (!GetRecoParam()->TrackAllTracks()) RemoveDoubleTracks();
+    
+  }
+  
+  return kTRUE;
+  
+}
+
+  //__________________________________________________________________________
+Bool_t AliMUONTrackReconstructorK::FollowTrackInChamber(AliMUONTrack &trackCandidate, AliMUONVClusterStore& clusterStore, Int_t nextChamber)
+{
+  /// Follow trackCandidate in chamber(0..) nextChamber and search for compatible cluster(s)
+  /// Keep all possibilities or only the best one(s) according to the flag fgkTrackAllTracks:
+  /// kTRUE:  duplicate "trackCandidate" if there are several possibilities and add the new tracks at the end of
+  ///         fRecTracksPtr to avoid conficts with other track candidates at this current stage of the tracking procedure.
+  ///         Remove the obsolete "trackCandidate" at the end.
+  /// kFALSE: add only the best cluster(s) to the "trackCandidate". Try to add a couple of clusters in priority.
+  /// return kTRUE if new cluster(s) have been found (otherwise return kFALSE)
+  AliDebug(1,Form("Enter FollowTrackInChamber(1..) %d", nextChamber+1));
+  
+  Double_t chi2OfCluster;
+  Double_t maxChi2OfCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+                                  GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+  Double_t addChi2TrackAtCluster;
+  Double_t bestAddChi2TrackAtCluster = AliMUONTrack::MaxChi2();
+  Bool_t foundOneCluster = kFALSE;
+  AliMUONTrack *newTrack = 0x0;
+  AliMUONVCluster *cluster;
+  AliMUONTrackParam extrapTrackParamAtCh;
+  AliMUONTrackParam extrapTrackParamAtCluster;
+  AliMUONTrackParam bestTrackParamAtCluster;
+  
+  // Get track parameters according to the propagation direction
+  if (nextChamber > 7) extrapTrackParamAtCh = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->Last();
+  else extrapTrackParamAtCh = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->First();
+  
+  // Printout for debuging
+  if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+    cout<<endl<<"Track parameters and covariances at first cluster:"<<endl;
+    extrapTrackParamAtCh.GetParameters().Print();
+    extrapTrackParamAtCh.GetCovariances().Print();
+  }
+  
+  // Add MCS effect
+  Int_t currentChamber = extrapTrackParamAtCh.GetClusterPtr()->GetChamberId();
+  AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(currentChamber),-1.);
+  
+  // reset propagator for smoother
+  if (GetRecoParam()->UseSmoother()) extrapTrackParamAtCh.ResetPropagator();
+  
+  // Add MCS in the missing chamber(s) if any
+  while (currentChamber > nextChamber + 1) {
+    // extrapolation to the missing chamber
+    currentChamber--;
+    if (!AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(currentChamber),
+                                         GetRecoParam()->UseSmoother())) return kFALSE;
+    // add MCS effect
+    AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(currentChamber),-1.);
+  }
+  
+  //Extrapolate trackCandidate to chamber
+  if (!AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(nextChamber),
+                                       GetRecoParam()->UseSmoother())) return kFALSE;
+  
+  // Printout for debuging
+  if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+    cout<<endl<<"Track parameters and covariances at first cluster extrapolated to z = "<<AliMUONConstants::DefaultChamberZ(nextChamber)<<":"<<endl;
+    extrapTrackParamAtCh.GetParameters().Print();
+    extrapTrackParamAtCh.GetCovariances().Print();
+  }
+  
+  // Printout for debuging
+  if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+    cout << "FollowTrackInChamber: look for clusters in chamber(1..): " << nextChamber+1 << endl;
+  }
+  
+  // Ask the clustering to reconstruct new clusters around the track position in the current chamber
+  // except for station 4 and 5 that are already entirely clusterized
+  if (GetRecoParam()->CombineClusterTrackReco()) {
+    if (nextChamber < 6) AskForNewClustersInChamber(extrapTrackParamAtCh, clusterStore, nextChamber);
+  }
+  
+  // Create iterators to loop over clusters in both chambers
+  TIter next(clusterStore.CreateChamberIterator(nextChamber,nextChamber));
+  
+  // look for candidates in chamber
+  while ( ( cluster = static_cast<AliMUONVCluster*>(next()) ) ) {
+    
+    // try to add the current cluster fast
+    if (!TryOneClusterFast(extrapTrackParamAtCh, cluster)) continue;
+    
+    // try to add the current cluster accuratly
+    chi2OfCluster = TryOneCluster(extrapTrackParamAtCh, cluster, extrapTrackParamAtCluster,
+                                 GetRecoParam()->UseSmoother());
+    
+    // if good chi2 then consider to add cluster
+    if (chi2OfCluster < maxChi2OfCluster) {
+      
+      if (GetRecoParam()->UseSmoother()) {
+       // save extrapolated parameters for smoother
+       extrapTrackParamAtCluster.SetExtrapParameters(extrapTrackParamAtCluster.GetParameters());
+       
+       // save extrapolated covariance matrix for smoother
+       extrapTrackParamAtCluster.SetExtrapCovariances(extrapTrackParamAtCluster.GetCovariances());
+      }
+      
+      // Compute new track parameters including new cluster using kalman filter
+      addChi2TrackAtCluster = RunKalmanFilter(extrapTrackParamAtCluster);
+      
+      // skip track out of limits
+      if (!IsAcceptable(extrapTrackParamAtCluster)) continue;
+      
+      // remember a cluster was found
+      foundOneCluster = kTRUE;
+      
+      // Printout for debuging
+      if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+       cout << "FollowTrackInChamber: found one cluster in chamber(1..): " << nextChamber+1
+       << " (Chi2 = " << chi2OfCluster << ")" << endl;
+       cluster->Print();
+      }
+      
+      if (GetRecoParam()->TrackAllTracks()) {
+       // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
+       newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
+       UpdateTrack(*newTrack,extrapTrackParamAtCluster,addChi2TrackAtCluster);
+       fNRecTracks++;
+       
+       // Printout for debuging
+       if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+         cout << "FollowTrackInChamber: added one cluster in chamber(1..): " << nextChamber+1 << endl;
+         if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
+       }
+       
+      } else if (addChi2TrackAtCluster < bestAddChi2TrackAtCluster) {
+       // keep track of the best cluster
+       bestAddChi2TrackAtCluster = addChi2TrackAtCluster;
+       bestTrackParamAtCluster = extrapTrackParamAtCluster;
+      }
+      
+    }
     
   }
   
+  // fill out the best track if required else clean up the fRecTracksPtr array
+  if (!GetRecoParam()->TrackAllTracks()) {
+    if (foundOneCluster) {
+      UpdateTrack(trackCandidate,bestTrackParamAtCluster,bestAddChi2TrackAtCluster);
+      
+      // Printout for debuging
+      if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+        cout << "FollowTrackInChamber: added the best cluster in chamber(1..): " << bestTrackParamAtCluster.GetClusterPtr()->GetChamberId()+1 << endl;
+        if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
+      }
+      
+    } else return kFALSE;
+    
+  } else if (foundOneCluster) {
+    
+    // remove obsolete track
+    fRecTracksPtr->Remove(&trackCandidate);
+    fNRecTracks--;
+    
+  } else return kFALSE;
+  
+  return kTRUE;
+  
 }
 
   //__________________________________________________________________________
-Bool_t AliMUONTrackReconstructorK::FollowTrackInStation(AliMUONTrack &trackCandidate, Int_t nextStation)
+Bool_t AliMUONTrackReconstructorK::FollowTrackInStation(AliMUONTrack &trackCandidate, AliMUONVClusterStore& clusterStore, Int_t nextStation)
 {
-  /// Follow trackCandidate in station(0..) nextStation and search for compatible HitForRec(s)
+  /// Follow trackCandidate in station(0..) nextStation and search for compatible cluster(s)
   /// Keep all possibilities or only the best one(s) according to the flag fgkTrackAllTracks:
   /// kTRUE:  duplicate "trackCandidate" if there are several possibilities and add the new tracks at the end of
   ///         fRecTracksPtr to avoid conficts with other track candidates at this current stage of the tracking procedure.
   ///         Remove the obsolete "trackCandidate" at the end.
-  /// kFALSE: add only the best hit(s) to the "trackCandidate". Try to add a couple of hits in priority.
-  /// return kTRUE if new hits have been found (otherwise return kFALSE)
+  /// kFALSE: add only the best cluster(s) to the "trackCandidate". Try to add a couple of clusters in priority.
+  /// return kTRUE if new cluster(s) have been found (otherwise return kFALSE)
   AliDebug(1,Form("Enter FollowTrackInStation(1..) %d", nextStation+1));
   
   // Order the chamber according to the propagation direction (tracking starts with chamber 2):
@@ -336,187 +682,224 @@ Bool_t AliMUONTrackReconstructorK::FollowTrackInStation(AliMUONTrack &trackCandi
     ch2 = 2*nextStation+1;
   }
   
-  Double_t chi2OfHitForRec;
-  Double_t maxChi2OfHitForRec = 2. * fgkSigmaToCutForTracking * fgkSigmaToCutForTracking; // 2 because 2 quantities in chi2
-  Double_t addChi2TrackAtHit1;
-  Double_t addChi2TrackAtHit2;
-  Double_t bestAddChi2TrackAtHit1 = 1.e10;
-  Double_t bestAddChi2TrackAtHit2 = 1.e10;
-  Bool_t foundOneHit = kFALSE;
-  Bool_t foundTwoHits = kFALSE;
+  Double_t chi2OfCluster;
+  Double_t maxChi2OfCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+                                  GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+  Double_t addChi2TrackAtCluster1;
+  Double_t addChi2TrackAtCluster2;
+  Double_t bestAddChi2TrackAtCluster1 = AliMUONTrack::MaxChi2();
+  Double_t bestAddChi2TrackAtCluster2 = AliMUONTrack::MaxChi2();
+  Bool_t foundOneCluster = kFALSE;
+  Bool_t foundTwoClusters = kFALSE;
   AliMUONTrack *newTrack = 0x0;
-  AliMUONHitForRec *hitForRecCh1, *hitForRecCh2;
+  AliMUONVCluster *clusterCh1, *clusterCh2;
   AliMUONTrackParam extrapTrackParam;
-  AliMUONTrackParam extrapTrackParamAtHit1;
-  AliMUONTrackParam extrapTrackParamAtHit2;
-  AliMUONTrackParam bestTrackParamAtHit1;
-  AliMUONTrackParam bestTrackParamAtHit2;
-  Bool_t *hitForRecCh1Used = new Bool_t[fNHitsForRecPerChamber[ch1]];
-  for (Int_t hit1 = 0; hit1 < fNHitsForRecPerChamber[ch1]; hit1++) hitForRecCh1Used[hit1] = kFALSE;
+  AliMUONTrackParam extrapTrackParamAtCh;
+  AliMUONTrackParam extrapTrackParamAtCluster1;
+  AliMUONTrackParam extrapTrackParamAtCluster2;
+  AliMUONTrackParam bestTrackParamAtCluster1;
+  AliMUONTrackParam bestTrackParamAtCluster2;
+  
+  // Get track parameters according to the propagation direction
+  if (nextStation==4) extrapTrackParamAtCh = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->Last();
+  else extrapTrackParamAtCh = *(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->First();
   
-  // Get track parameters
-  AliMUONTrackParam extrapTrackParamAtCh(*(AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->First());
+  // Printout for debuging
+  if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+    cout<<endl<<"Track parameters and covariances at first cluster:"<<endl;
+    extrapTrackParamAtCh.GetParameters().Print();
+    extrapTrackParamAtCh.GetCovariances().Print();
+  }
   
   // Add MCS effect
-  AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
+  Int_t currentChamber = extrapTrackParamAtCh.GetClusterPtr()->GetChamberId();
+  AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(currentChamber),-1.);
   
   // reset propagator for smoother
-  if (fgkRunSmoother) extrapTrackParamAtCh.ResetPropagator();
+  if (GetRecoParam()->UseSmoother()) extrapTrackParamAtCh.ResetPropagator();
   
-  // Add MCS in the missing chamber if any (only 1 chamber can be missing according to tracking criteria)
-  if (ch1 < ch2 && extrapTrackParamAtCh.GetHitForRecPtr()->GetChamberNumber() > ch2 + 1) {
+  // Add MCS in the missing chamber(s) if any
+  while (ch1 < ch2 && currentChamber > ch2 + 1) {
     // extrapolation to the missing chamber
-    AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch2 + 1), fgkRunSmoother);
+    currentChamber--;
+    if (!AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(currentChamber),
+                                         GetRecoParam()->UseSmoother())) return kFALSE;
     // add MCS effect
-    AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
+    AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(currentChamber),-1.);
   }
   
   //Extrapolate trackCandidate to chamber "ch2"
-  AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch2), fgkRunSmoother);
+  if (!AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch2),
+                                       GetRecoParam()->UseSmoother())) return kFALSE;
   
   // Printout for debuging
   if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
-    cout<<endl<<"Track parameter covariances at first hit extrapolated to z = "<<AliMUONConstants::DefaultChamberZ(ch2)<<":"<<endl;
+    cout<<endl<<"Track parameters and covariances at first cluster extrapolated to z = "<<AliMUONConstants::DefaultChamberZ(ch2)<<":"<<endl;
+    extrapTrackParamAtCh.GetParameters().Print();
     extrapTrackParamAtCh.GetCovariances().Print();
   }
   
   // Printout for debuging
   if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-    cout << "FollowTrackInStation: look for hits in chamber(1..): " << ch2+1 << endl;
+    cout << "FollowTrackInStation: look for clusters in chamber(1..): " << ch2+1 << endl;
   }
   
-  // look for candidates in chamber 2 
-  for (Int_t hit2 = 0; hit2 < fNHitsForRecPerChamber[ch2]; hit2++) {
-    
-    hitForRecCh2 = (AliMUONHitForRec*) fHitsForRecPtr->UncheckedAt(fIndexOfFirstHitForRecPerChamber[ch2]+hit2);
+  // Ask the clustering to reconstruct new clusters around the track position in the current station
+  // except for station 4 and 5 that are already entirely clusterized
+  if (GetRecoParam()->CombineClusterTrackReco()) {
+    if (nextStation < 3) AskForNewClustersInStation(extrapTrackParamAtCh, clusterStore, nextStation);
+  }
+  
+  Int_t nClusters = clusterStore.GetSize();
+  Bool_t *clusterCh1Used = new Bool_t[nClusters];
+  for (Int_t i = 0; i < nClusters; i++) clusterCh1Used[i] = kFALSE;
+  Int_t iCluster1;
+  
+  // Create iterators to loop over clusters in both chambers
+  TIter nextInCh1(clusterStore.CreateChamberIterator(ch1,ch1));
+  TIter nextInCh2(clusterStore.CreateChamberIterator(ch2,ch2));
+  
+  // look for candidates in chamber 2
+  while ( ( clusterCh2 = static_cast<AliMUONVCluster*>(nextInCh2()) ) ) {
     
-    // try to add the current hit fast
-    if (!TryOneHitForRecFast(extrapTrackParamAtCh, hitForRecCh2)) continue;
+    // try to add the current cluster fast
+    if (!TryOneClusterFast(extrapTrackParamAtCh, clusterCh2)) continue;
     
-    // try to add the current hit accuratly
-    chi2OfHitForRec = TryOneHitForRec(extrapTrackParamAtCh, hitForRecCh2, extrapTrackParamAtHit2, fgkRunSmoother);
+    // try to add the current cluster accuratly
+    chi2OfCluster = TryOneCluster(extrapTrackParamAtCh, clusterCh2, extrapTrackParamAtCluster2,
+                                 GetRecoParam()->UseSmoother());
     
-    // if good chi2 then try to attach a hitForRec in the other chamber too
-    if (chi2OfHitForRec < maxChi2OfHitForRec) {
-      Bool_t foundSecondHit = kFALSE;
-      
-      // Printout for debuging
-      if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-        cout << "FollowTrackInStation: found one hit in chamber(1..): " << ch2+1
-            << " (Chi2 = " << chi2OfHitForRec << ")" << endl;
-        cout << "                      look for second hits in chamber(1..): " << ch1+1 << " ..." << endl;
-      }
+    // if good chi2 then try to attach a cluster in the other chamber too
+    if (chi2OfCluster < maxChi2OfCluster) {
       
-      if (fgkRunSmoother) {
+      if (GetRecoParam()->UseSmoother()) {
         // save extrapolated parameters for smoother
-        extrapTrackParamAtHit2.SetExtrapParameters(extrapTrackParamAtHit2.GetParameters());
+        extrapTrackParamAtCluster2.SetExtrapParameters(extrapTrackParamAtCluster2.GetParameters());
         
         // save extrapolated covariance matrix for smoother
-        extrapTrackParamAtHit2.SetExtrapCovariances(extrapTrackParamAtHit2.GetCovariances());
+        extrapTrackParamAtCluster2.SetExtrapCovariances(extrapTrackParamAtCluster2.GetCovariances());
       }
       
-      // Compute new track parameters including "hitForRecCh2" using kalman filter
-      addChi2TrackAtHit2 = RunKalmanFilter(extrapTrackParamAtHit2);
+      // Compute new track parameters including "clusterCh2" using kalman filter
+      addChi2TrackAtCluster2 = RunKalmanFilter(extrapTrackParamAtCluster2);
+      
+      // skip track out of limits
+      if (!IsAcceptable(extrapTrackParamAtCluster2)) continue;
+      
+      // Printout for debuging
+      if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+        cout << "FollowTrackInStation: found one cluster in chamber(1..): " << ch2+1
+       << " (Chi2 = " << chi2OfCluster << ")" << endl;
+       clusterCh2->Print();
+        cout << "                      look for second clusters in chamber(1..): " << ch1+1 << " ..." << endl;
+      }
       
       // copy new track parameters for next step
-      extrapTrackParam = extrapTrackParamAtHit2;
+      extrapTrackParam = extrapTrackParamAtCluster2;
       
       // add MCS effect
-      AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParam,AliMUONConstants::ChamberThicknessInX0(),1.);
+      AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParam,AliMUONConstants::ChamberThicknessInX0(ch2),-1.);
       
       // reset propagator for smoother
-      if (fgkRunSmoother) extrapTrackParam.ResetPropagator();
+      if (GetRecoParam()->UseSmoother()) extrapTrackParam.ResetPropagator();
       
       //Extrapolate track parameters to chamber "ch1"
-      AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParam, AliMUONConstants::DefaultChamberZ(ch1), fgkRunSmoother);
+      Bool_t normalExtrap = AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParam, AliMUONConstants::DefaultChamberZ(ch1),
+                                                            GetRecoParam()->UseSmoother());
       
-      for (Int_t hit1 = 0; hit1 < fNHitsForRecPerChamber[ch1]; hit1++) {
-        
-       hitForRecCh1 = (AliMUONHitForRec*) fHitsForRecPtr->UncheckedAt(fIndexOfFirstHitForRecPerChamber[ch1]+hit1);
+      // reset cluster iterator of chamber 1
+      nextInCh1.Reset();
+      iCluster1 = -1;
+      
+      // look for second candidates in chamber 1
+      Bool_t foundSecondCluster = kFALSE;
+      if (normalExtrap) while ( ( clusterCh1 = static_cast<AliMUONVCluster*>(nextInCh1()) ) ) {
+       iCluster1++;
        
-       // try to add the current hit fast
-       if (!TryOneHitForRecFast(extrapTrackParam, hitForRecCh1)) continue;
+       // try to add the current cluster fast
+       if (!TryOneClusterFast(extrapTrackParam, clusterCh1)) continue;
        
-       // try to add the current hit accuratly
-       chi2OfHitForRec = TryOneHitForRec(extrapTrackParam, hitForRecCh1, extrapTrackParamAtHit1, fgkRunSmoother);
+       // try to add the current cluster accuratly
+       chi2OfCluster = TryOneCluster(extrapTrackParam, clusterCh1, extrapTrackParamAtCluster1,
+                                     GetRecoParam()->UseSmoother());
        
-       // if good chi2 then consider to add the 2 hitForRec to the "trackCandidate"
-       if (chi2OfHitForRec < maxChi2OfHitForRec) {
-         foundSecondHit = kTRUE;
-         foundTwoHits = kTRUE;
+       // if good chi2 then consider to add the 2 clusters to the "trackCandidate"
+       if (chi2OfCluster < maxChi2OfCluster) {
           
-         // Printout for debuging
-         if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-           cout << "FollowTrackInStation: found one hit in chamber(1..): " << ch1+1
-                << " (Chi2 = " << chi2OfHitForRec << ")" << endl;
-         }
-          
-          if (fgkRunSmoother) {
+          if (GetRecoParam()->UseSmoother()) {
             // save extrapolated parameters for smoother
-            extrapTrackParamAtHit1.SetExtrapParameters(extrapTrackParamAtHit1.GetParameters());
+            extrapTrackParamAtCluster1.SetExtrapParameters(extrapTrackParamAtCluster1.GetParameters());
             
             // save extrapolated covariance matrix for smoother
-            extrapTrackParamAtHit1.SetExtrapCovariances(extrapTrackParamAtHit1.GetCovariances());
+            extrapTrackParamAtCluster1.SetExtrapCovariances(extrapTrackParamAtCluster1.GetCovariances());
           }
           
-          // Compute new track parameters including "hitForRecCh1" using kalman filter
-          addChi2TrackAtHit1 = RunKalmanFilter(extrapTrackParamAtHit1);
+          // Compute new track parameters including "clusterCh1" using kalman filter
+          addChi2TrackAtCluster1 = RunKalmanFilter(extrapTrackParamAtCluster1);
+          
+         // skip track out of limits
+         if (!IsAcceptable(extrapTrackParamAtCluster1)) continue;
+         
+         // remember a second cluster was found
+         foundSecondCluster = kTRUE;
+         foundTwoClusters = kTRUE;
           
-         if (fgkTrackAllTracks) {
-           // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new hitForRec's
+         // Printout for debuging
+         if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+           cout << "FollowTrackInStation: found one cluster in chamber(1..): " << ch1+1
+           << " (Chi2 = " << chi2OfCluster << ")" << endl;
+           clusterCh1->Print();
+         }
+         
+         if (GetRecoParam()->TrackAllTracks()) {
+           // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new clusters
             newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
-           UpdateTrack(*newTrack,extrapTrackParamAtHit1,extrapTrackParamAtHit2,addChi2TrackAtHit1,addChi2TrackAtHit2);
+           UpdateTrack(*newTrack,extrapTrackParamAtCluster1,extrapTrackParamAtCluster2,addChi2TrackAtCluster1,addChi2TrackAtCluster2);
            fNRecTracks++;
            
-           // if we are arrived on station(1..) 5, recompute track parameters and covariances starting from this station
-           // (going in the right direction)
-           if (nextStation == 4) RetraceTrack(*newTrack,kTRUE);
-           
-           // Tag hitForRecCh1 as used
-           hitForRecCh1Used[hit1] = kTRUE;
+           // Tag clusterCh1 as used
+           clusterCh1Used[iCluster1] = kTRUE;
            
            // Printout for debuging
            if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-             cout << "FollowTrackInStation: added two hits in station(1..): " << nextStation+1 << endl;
+             cout << "FollowTrackInStation: added two clusters in station(1..): " << nextStation+1 << endl;
              if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
            }
            
-          } else if (addChi2TrackAtHit1+addChi2TrackAtHit2 < bestAddChi2TrackAtHit1+bestAddChi2TrackAtHit2) {
-           // keep track of the best couple of hits
-           bestAddChi2TrackAtHit1 = addChi2TrackAtHit1;
-           bestAddChi2TrackAtHit2 = addChi2TrackAtHit2;
-           bestTrackParamAtHit1 = extrapTrackParamAtHit1;
-           bestTrackParamAtHit2 = extrapTrackParamAtHit2;
+          } else if (addChi2TrackAtCluster1+addChi2TrackAtCluster2 < bestAddChi2TrackAtCluster1+bestAddChi2TrackAtCluster2) {
+           // keep track of the best couple of clusters
+           bestAddChi2TrackAtCluster1 = addChi2TrackAtCluster1;
+           bestAddChi2TrackAtCluster2 = addChi2TrackAtCluster2;
+           bestTrackParamAtCluster1 = extrapTrackParamAtCluster1;
+           bestTrackParamAtCluster2 = extrapTrackParamAtCluster2;
           }
          
        }
        
       }
       
-      // if no hitForRecCh1 found then consider to add hitForRecCh2 only
-      if (!foundSecondHit) {
-       foundOneHit = kTRUE;
+      // if no clusterCh1 found then consider to add clusterCh2 only
+      if (!foundSecondCluster) {
+       
+       // remember a cluster was found
+       foundOneCluster = kTRUE;
         
-       if (fgkTrackAllTracks) {
-         // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new hitForRec's
+       if (GetRecoParam()->TrackAllTracks()) {
+         // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
           newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
-         UpdateTrack(*newTrack,extrapTrackParamAtHit2,addChi2TrackAtHit2);
+         UpdateTrack(*newTrack,extrapTrackParamAtCluster2,addChi2TrackAtCluster2);
          fNRecTracks++;
          
-         // if we are arrived on station(1..) 5, recompute track parameters and covariances starting from this station
-         // (going in the right direction)
-         if (nextStation == 4) RetraceTrack(*newTrack,kTRUE);
-         
          // Printout for debuging
          if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-           cout << "FollowTrackInStation: added one hit in chamber(1..): " << ch2+1 << endl;
+           cout << "FollowTrackInStation: added one cluster in chamber(1..): " << ch2+1 << endl;
            if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
          }
          
-       } else if (!foundTwoHits && addChi2TrackAtHit2 < bestAddChi2TrackAtHit1) {
-         // keep track of the best single hitForRec except if a couple of hits has already been found
-         bestAddChi2TrackAtHit1 = addChi2TrackAtHit2;
-         bestTrackParamAtHit1 = extrapTrackParamAtHit2;
+       } else if (!foundTwoClusters && addChi2TrackAtCluster2 < bestAddChi2TrackAtCluster1) {
+         // keep track of the best single cluster except if a couple of clusters has already been found
+         bestAddChi2TrackAtCluster1 = addChi2TrackAtCluster2;
+         bestTrackParamAtCluster1 = extrapTrackParamAtCluster2;
         }
        
       }
@@ -526,74 +909,89 @@ Bool_t AliMUONTrackReconstructorK::FollowTrackInStation(AliMUONTrack &trackCandi
   }
   
   // look for candidates in chamber 1 not already attached to a track
-  // if we want to keep all possible tracks or if no good couple of hitForRec has been found
-  if (fgkTrackAllTracks || !foundTwoHits) {
+  // if we want to keep all possible tracks or if no good couple of clusters has been found
+  if (GetRecoParam()->TrackAllTracks() || !foundTwoClusters) {
+    
+    // add MCS effect for next step
+    AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(ch2),-1.);
+    
+    //Extrapolate trackCandidate to chamber "ch1"
+    Bool_t normalExtrap = AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch1),
+                                                          GetRecoParam()->UseSmoother());
     
     // Printout for debuging
-    if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-      cout << "FollowTrackInStation: look for single hits in chamber(1..): " << ch1+1 << endl;
+    if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+      cout<<endl<<"Track parameters and covariances at first cluster extrapolated to z = "<<AliMUONConstants::DefaultChamberZ(ch1)<<":"<<endl;
+      extrapTrackParamAtCh.GetParameters().Print();
+      extrapTrackParamAtCh.GetCovariances().Print();
     }
     
-    // add MCS effect for next step
-    AliMUONTrackExtrap::AddMCSEffect(&extrapTrackParamAtCh,AliMUONConstants::ChamberThicknessInX0(),1.);
+    // Printout for debuging
+    if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+      cout << "FollowTrackInStation: look for single clusters in chamber(1..): " << ch1+1 << endl;
+    }
     
-    //Extrapolate trackCandidate to chamber "ch1"
-    AliMUONTrackExtrap::ExtrapToZCov(&extrapTrackParamAtCh, AliMUONConstants::DefaultChamberZ(ch1), fgkRunSmoother);
+    // reset cluster iterator of chamber 1
+    nextInCh1.Reset();
+    iCluster1 = -1;
     
-    for (Int_t hit1 = 0; hit1 < fNHitsForRecPerChamber[ch1]; hit1++) {
+    // look for second candidates in chamber 1
+    if (normalExtrap) while ( ( clusterCh1 = static_cast<AliMUONVCluster*>(nextInCh1()) ) ) {
+      iCluster1++;
       
-      hitForRecCh1 = (AliMUONHitForRec*) fHitsForRecPtr->UncheckedAt(fIndexOfFirstHitForRecPerChamber[ch1]+hit1);
+      if (clusterCh1Used[iCluster1]) continue; // Skip clusters already used
       
-      if (hitForRecCh1Used[hit1]) continue; // Skip hitForRec already used
+      // try to add the current cluster fast
+      if (!TryOneClusterFast(extrapTrackParamAtCh, clusterCh1)) continue;
       
-      // try to add the current hit fast
-      if (!TryOneHitForRecFast(extrapTrackParamAtCh, hitForRecCh1)) continue;
+      // try to add the current cluster accuratly
+      chi2OfCluster = TryOneCluster(extrapTrackParamAtCh, clusterCh1, extrapTrackParamAtCluster1,
+                                   GetRecoParam()->UseSmoother());
       
-      // try to add the current hit accuratly
-      chi2OfHitForRec = TryOneHitForRec(extrapTrackParamAtCh, hitForRecCh1, extrapTrackParamAtHit1, fgkRunSmoother);
-      
-      // if good chi2 then consider to add hitForRecCh1
-      // We do not try to attach a hitForRec in the other chamber too since it has already been done above
-      if (chi2OfHitForRec < maxChi2OfHitForRec) {
-       foundOneHit = kTRUE;
-       
-       // Printout for debuging
-       if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-         cout << "FollowTrackInStation: found one hit in chamber(1..): " << ch1+1
-              << " (Chi2 = " << chi2OfHitForRec << ")" << endl;
-       }
+      // if good chi2 then consider to add clusterCh1
+      // We do not try to attach a cluster in the other chamber too since it has already been done above
+      if (chi2OfCluster < maxChi2OfCluster) {
         
-       if (fgkRunSmoother) {
+       if (GetRecoParam()->UseSmoother()) {
           // save extrapolated parameters for smoother
-          extrapTrackParamAtHit1.SetExtrapParameters(extrapTrackParamAtHit1.GetParameters());
+          extrapTrackParamAtCluster1.SetExtrapParameters(extrapTrackParamAtCluster1.GetParameters());
           
           // save extrapolated covariance matrix for smoother
-          extrapTrackParamAtHit1.SetExtrapCovariances(extrapTrackParamAtHit1.GetCovariances());
+          extrapTrackParamAtCluster1.SetExtrapCovariances(extrapTrackParamAtCluster1.GetCovariances());
         }
         
-        // Compute new track parameters including "hitForRecCh1" using kalman filter
-        addChi2TrackAtHit1 = RunKalmanFilter(extrapTrackParamAtHit1);
+        // Compute new track parameters including "clusterCh1" using kalman filter
+        addChi2TrackAtCluster1 = RunKalmanFilter(extrapTrackParamAtCluster1);
         
-       if (fgkTrackAllTracks) {
-         // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new hitForRec's
+       // skip track out of limits
+       if (!IsAcceptable(extrapTrackParamAtCluster1)) continue;
+       
+       // remember a cluster was found
+       foundOneCluster = kTRUE;
+       
+       // Printout for debuging
+       if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+         cout << "FollowTrackInStation: found one cluster in chamber(1..): " << ch1+1
+         << " (Chi2 = " << chi2OfCluster << ")" << endl;
+         clusterCh1->Print();
+       }
+       
+       if (GetRecoParam()->TrackAllTracks()) {
+         // copy trackCandidate into a new track put at the end of fRecTracksPtr and add the new cluster
          newTrack = new ((*fRecTracksPtr)[fRecTracksPtr->GetLast()+1]) AliMUONTrack(trackCandidate);
-         UpdateTrack(*newTrack,extrapTrackParamAtHit1,addChi2TrackAtHit1);
+         UpdateTrack(*newTrack,extrapTrackParamAtCluster1,addChi2TrackAtCluster1);
          fNRecTracks++;
          
-         // if we are arrived on station(1..) 5, recompute track parameters and covariances starting from this station
-         // (going in the right direction)
-         if (nextStation == 4) RetraceTrack(*newTrack,kTRUE);
-         
          // Printout for debuging
          if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-           cout << "FollowTrackInStation: added one hit in chamber(1..): " << ch1+1 << endl;
+           cout << "FollowTrackInStation: added one cluster in chamber(1..): " << ch1+1 << endl;
            if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
          }
          
-       } else if (addChi2TrackAtHit1 < bestAddChi2TrackAtHit1) {
-         // keep track of the best single hitForRec except if a couple of hits has already been found
-         bestAddChi2TrackAtHit1 = addChi2TrackAtHit1;
-         bestTrackParamAtHit1 = extrapTrackParamAtHit1;
+       } else if (addChi2TrackAtCluster1 < bestAddChi2TrackAtCluster1) {
+         // keep track of the best single cluster except if a couple of clusters has already been found
+         bestAddChi2TrackAtCluster1 = addChi2TrackAtCluster1;
+         bestTrackParamAtCluster1 = extrapTrackParamAtCluster1;
        }
        
       }
@@ -603,99 +1001,98 @@ Bool_t AliMUONTrackReconstructorK::FollowTrackInStation(AliMUONTrack &trackCandi
   }
   
   // fill out the best track if required else clean up the fRecTracksPtr array
-  if (!fgkTrackAllTracks) {
-    if (foundTwoHits) {
-      UpdateTrack(trackCandidate,bestTrackParamAtHit1,bestTrackParamAtHit2,bestAddChi2TrackAtHit1,bestAddChi2TrackAtHit2);
+  if (!GetRecoParam()->TrackAllTracks()) {
+    if (foundTwoClusters) {
+      UpdateTrack(trackCandidate,bestTrackParamAtCluster1,bestTrackParamAtCluster2,bestAddChi2TrackAtCluster1,bestAddChi2TrackAtCluster2);
       
-      // if we are arrived on station(1..) 5, recompute track parameters and covariances starting from this station
-      // (going in the right direction)
-      if (nextStation == 4) RetraceTrack(trackCandidate,kTRUE);
-
       // Printout for debuging
       if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-        cout << "FollowTrackInStation: added the two best hits in station(1..): " << nextStation+1 << endl;
+        cout << "FollowTrackInStation: added the two best clusters in station(1..): " << nextStation+1 << endl;
         if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
       }
       
-    } else if (foundOneHit) {
-      UpdateTrack(trackCandidate,bestTrackParamAtHit1,bestAddChi2TrackAtHit1);
+    } else if (foundOneCluster) {
+      UpdateTrack(trackCandidate,bestTrackParamAtCluster1,bestAddChi2TrackAtCluster1);
       
-      // if we are arrived on station(1..) 5, recompute track parameters and covariances starting from this station
-      // (going in the right direction)
-      if (nextStation == 4) RetraceTrack(trackCandidate,kTRUE);
-
       // Printout for debuging
       if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-        cout << "FollowTrackInStation: added the best hit in chamber(1..): " << bestTrackParamAtHit1.GetHitForRecPtr()->GetChamberNumber()+1 << endl;
+        cout << "FollowTrackInStation: added the best cluster in chamber(1..): " << bestTrackParamAtCluster1.GetClusterPtr()->GetChamberId()+1 << endl;
         if (AliLog::GetGlobalDebugLevel() >= 3) newTrack->RecursiveDump();
       }
       
-    } else return kFALSE;
+    } else {
+      delete [] clusterCh1Used;
+      return kFALSE;
+    }
     
-  } else if (foundOneHit || foundTwoHits) {
+  } else if (foundOneCluster || foundTwoClusters) {
     
     // remove obsolete track
     fRecTracksPtr->Remove(&trackCandidate);
     fNRecTracks--;
     
-  } else return kFALSE;
+  } else {
+    delete [] clusterCh1Used;
+    return kFALSE;
+  }
   
+  delete [] clusterCh1Used;
   return kTRUE;
   
 }
 
   //__________________________________________________________________________
-Double_t AliMUONTrackReconstructorK::RunKalmanFilter(AliMUONTrackParam &trackParamAtHit)
+Double_t AliMUONTrackReconstructorK::RunKalmanFilter(AliMUONTrackParam &trackParamAtCluster)
 {
-  /// Compute new track parameters and their covariances including new hit using kalman filter
+  /// Compute new track parameters and their covariances including new cluster using kalman filter
   /// return the additional track chi2
   AliDebug(1,"Enter RunKalmanFilter");
   
   // Get actual track parameters (p)
-  TMatrixD param(trackParamAtHit.GetParameters());
+  TMatrixD param(trackParamAtCluster.GetParameters());
   
-  // Get new hit parameters (m)
-  AliMUONHitForRec *hitForRecAtHit = trackParamAtHit.GetHitForRecPtr();
-  TMatrixD hit(5,1);
-  hit.Zero();
-  hit(0,0) = hitForRecAtHit->GetNonBendingCoor();
-  hit(2,0) = hitForRecAtHit->GetBendingCoor();
+  // Get new cluster parameters (m)
+  AliMUONVCluster *cluster = trackParamAtCluster.GetClusterPtr();
+  TMatrixD clusterParam(5,1);
+  clusterParam.Zero();
+  clusterParam(0,0) = cluster->GetX();
+  clusterParam(2,0) = cluster->GetY();
   
   // Compute the actual parameter weight (W)
-  TMatrixD paramWeight(trackParamAtHit.GetCovariances());
+  TMatrixD paramWeight(trackParamAtCluster.GetCovariances());
   if (paramWeight.Determinant() != 0) {
     paramWeight.Invert();
   } else {
     AliWarning(" Determinant = 0");
-    return 1.e10;
+    return 2.*AliMUONTrack::MaxChi2();
   }
   
-  // Compute the new hit weight (U)
-  TMatrixD hitWeight(5,5);
-  hitWeight.Zero();
-  hitWeight(0,0) = 1. / hitForRecAtHit->GetNonBendingReso2();
-  hitWeight(2,2) = 1. / hitForRecAtHit->GetBendingReso2();
+  // Compute the new cluster weight (U)
+  TMatrixD clusterWeight(5,5);
+  clusterWeight.Zero();
+  clusterWeight(0,0) = 1. / cluster->GetErrX2();
+  clusterWeight(2,2) = 1. / cluster->GetErrY2();
 
   // Compute the new parameters covariance matrix ( (W+U)^-1 )
-  TMatrixD newParamCov(paramWeight,TMatrixD::kPlus,hitWeight);
+  TMatrixD newParamCov(paramWeight,TMatrixD::kPlus,clusterWeight);
   if (newParamCov.Determinant() != 0) {
     newParamCov.Invert();
   } else {
     AliWarning(" Determinant = 0");
-    return 1.e10;
+    return 2.*AliMUONTrack::MaxChi2();
   }
   
   // Save the new parameters covariance matrix
-  trackParamAtHit.SetCovariances(newParamCov);
+  trackParamAtCluster.SetCovariances(newParamCov);
   
   // Compute the new parameters (p' = ((W+U)^-1)U(m-p) + p)
-  TMatrixD tmp(hit,TMatrixD::kMinus,param);
-  TMatrixD tmp2(hitWeight,TMatrixD::kMult,tmp); // U(m-p)
+  TMatrixD tmp(clusterParam,TMatrixD::kMinus,param);
+  TMatrixD tmp2(clusterWeight,TMatrixD::kMult,tmp); // U(m-p)
   TMatrixD newParam(newParamCov,TMatrixD::kMult,tmp2); // ((W+U)^-1)U(m-p)
   newParam += param; // ((W+U)^-1)U(m-p) + p
   
   // Save the new parameters
-  trackParamAtHit.SetParameters(newParam);
+  trackParamAtCluster.SetParameters(newParam);
   
   // Compute the additional chi2 (= ((p'-p)^-1)W(p'-p) + ((p'-m)^-1)U(p'-m))
   tmp = newParam; // p'
@@ -703,8 +1100,8 @@ Double_t AliMUONTrackReconstructorK::RunKalmanFilter(AliMUONTrackParam &trackPar
   TMatrixD tmp3(paramWeight,TMatrixD::kMult,tmp); // W(p'-p)
   TMatrixD addChi2Track(tmp,TMatrixD::kTransposeMult,tmp3); // ((p'-p)^-1)W(p'-p)
   tmp = newParam; // p'
-  tmp -= hit; // (p'-m)
-  TMatrixD tmp4(hitWeight,TMatrixD::kMult,tmp); // U(p'-m)
+  tmp -= clusterParam; // (p'-m)
+  TMatrixD tmp4(clusterWeight,TMatrixD::kMult,tmp); // U(p'-m)
   addChi2Track += TMatrixD(tmp,TMatrixD::kTransposeMult,tmp4); // ((p'-p)^-1)W(p'-p) + ((p'-m)^-1)U(p'-m)
   
   return addChi2Track(0,0);
@@ -712,114 +1109,123 @@ Double_t AliMUONTrackReconstructorK::RunKalmanFilter(AliMUONTrackParam &trackPar
 }
 
   //__________________________________________________________________________
-void AliMUONTrackReconstructorK::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtHit, Double_t addChi2)
+void AliMUONTrackReconstructorK::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtCluster, Double_t addChi2)
 {
-  /// Add 1 hit to the track candidate
+  /// Add 1 cluster to the track candidate
   /// Update chi2 of the track 
   
-  // Flag hit as being not removable
-  trackParamAtHit.SetRemovable(kFALSE);
-  trackParamAtHit.SetLocalChi2(0.); // --> Local chi2 not used
+  // Flag cluster as being (not) removable
+  if (GetRecoParam()->RequestStation(trackParamAtCluster.GetClusterPtr()->GetChamberId()/2))
+    trackParamAtCluster.SetRemovable(kFALSE);
+  else trackParamAtCluster.SetRemovable(kTRUE);
+  trackParamAtCluster.SetLocalChi2(0.); // --> Local chi2 not used
   
-  // Update the track chi2 into TrackParamAtHit
-  trackParamAtHit.SetTrackChi2(track.GetFitFMin() + addChi2);
+  // Update the track chi2 into trackParamAtCluster
+  trackParamAtCluster.SetTrackChi2(track.GetGlobalChi2() + addChi2);
   
   // Update the chi2 of the new track
-  track.SetFitFMin(trackParamAtHit.GetTrackChi2());
+  track.SetGlobalChi2(trackParamAtCluster.GetTrackChi2());
   
-  // Update array of TrackParamAtHit
-  track.AddTrackParamAtHit(&trackParamAtHit,trackParamAtHit.GetHitForRecPtr());
-  track.GetTrackParamAtHit()->Sort();
+  // Update array of TrackParamAtCluster
+  track.AddTrackParamAtCluster(trackParamAtCluster,*(trackParamAtCluster.GetClusterPtr()));
   
 }
 
   //__________________________________________________________________________
-void AliMUONTrackReconstructorK::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtHit1, AliMUONTrackParam &trackParamAtHit2,
-                                            Double_t addChi2AtHit1, Double_t addChi2AtHit2)
+void AliMUONTrackReconstructorK::UpdateTrack(AliMUONTrack &track, AliMUONTrackParam &trackParamAtCluster1, AliMUONTrackParam &trackParamAtCluster2,
+                                            Double_t addChi2AtCluster1, Double_t addChi2AtCluster2)
 {
-  /// Add 2 hits to the track candidate
+  /// Add 2 clusters to the track candidate (order is important)
   /// Update track and local chi2
   
-  // Update local chi2 at first hit
-  AliMUONHitForRec* hit1 = trackParamAtHit1.GetHitForRecPtr();
-  Double_t deltaX = trackParamAtHit1.GetNonBendingCoor() - hit1->GetNonBendingCoor();
-  Double_t deltaY = trackParamAtHit1.GetBendingCoor() - hit1->GetBendingCoor();
-  Double_t localChi2AtHit1 = deltaX*deltaX / hit1->GetNonBendingReso2() +
-                            deltaY*deltaY / hit1->GetBendingReso2();
-  trackParamAtHit1.SetLocalChi2(localChi2AtHit1);
+  // Update local chi2 at first cluster
+  AliMUONVCluster* cluster1 = trackParamAtCluster1.GetClusterPtr();
+  Double_t deltaX = trackParamAtCluster1.GetNonBendingCoor() - cluster1->GetX();
+  Double_t deltaY = trackParamAtCluster1.GetBendingCoor() - cluster1->GetY();
+  Double_t localChi2AtCluster1 = deltaX*deltaX / cluster1->GetErrX2() +
+                                deltaY*deltaY / cluster1->GetErrY2();
+  trackParamAtCluster1.SetLocalChi2(localChi2AtCluster1);
   
-  // Flag first hit as being removable
-  trackParamAtHit1.SetRemovable(kTRUE);
+  // Flag first cluster as being removable
+  trackParamAtCluster1.SetRemovable(kTRUE);
   
-  // Update local chi2 at second hit
-  AliMUONHitForRec* hit2 = trackParamAtHit2.GetHitForRecPtr();
-  AliMUONTrackParam extrapTrackParamAtHit2(trackParamAtHit1);
-  AliMUONTrackExtrap::ExtrapToZ(&extrapTrackParamAtHit2, trackParamAtHit2.GetZ());
-  deltaX = extrapTrackParamAtHit2.GetNonBendingCoor() - hit2->GetNonBendingCoor();
-  deltaY = extrapTrackParamAtHit2.GetBendingCoor() - hit2->GetBendingCoor();
-  Double_t localChi2AtHit2 = deltaX*deltaX / hit2->GetNonBendingReso2() +
-                            deltaY*deltaY / hit2->GetBendingReso2();
-  trackParamAtHit2.SetLocalChi2(localChi2AtHit2);
+  // Update local chi2 at second cluster
+  AliMUONVCluster* cluster2 = trackParamAtCluster2.GetClusterPtr();
+  AliMUONTrackParam extrapTrackParamAtCluster2(trackParamAtCluster1);
+  AliMUONTrackExtrap::ExtrapToZ(&extrapTrackParamAtCluster2, trackParamAtCluster2.GetZ());
+  deltaX = extrapTrackParamAtCluster2.GetNonBendingCoor() - cluster2->GetX();
+  deltaY = extrapTrackParamAtCluster2.GetBendingCoor() - cluster2->GetY();
+  Double_t localChi2AtCluster2 = deltaX*deltaX / cluster2->GetErrX2() +
+                                deltaY*deltaY / cluster2->GetErrY2();
+  trackParamAtCluster2.SetLocalChi2(localChi2AtCluster2);
   
-  // Flag second hit as being removable
-  trackParamAtHit2.SetRemovable(kTRUE);
+  // Flag second cluster as being removable
+  trackParamAtCluster2.SetRemovable(kTRUE);
   
-  // Update the track chi2 into TrackParamAtHit1
-  trackParamAtHit1.SetTrackChi2(track.GetFitFMin() + addChi2AtHit1);
+  // Update the track chi2 into trackParamAtCluster2
+  trackParamAtCluster2.SetTrackChi2(track.GetGlobalChi2() + addChi2AtCluster2);
   
-  // Update the track chi2 into TrackParamAtHit2
-  trackParamAtHit2.SetTrackChi2(trackParamAtHit1.GetTrackChi2() + addChi2AtHit2);
+  // Update the track chi2 into trackParamAtCluster1
+  trackParamAtCluster1.SetTrackChi2(trackParamAtCluster2.GetTrackChi2() + addChi2AtCluster1);
   
   // Update the chi2 of the new track
-  track.SetFitFMin(trackParamAtHit2.GetTrackChi2());
+  track.SetGlobalChi2(trackParamAtCluster1.GetTrackChi2());
   
-  // Update array of TrackParamAtHit
-  track.AddTrackParamAtHit(&trackParamAtHit1,trackParamAtHit1.GetHitForRecPtr());
-  track.AddTrackParamAtHit(&trackParamAtHit2,trackParamAtHit2.GetHitForRecPtr());
-  track.GetTrackParamAtHit()->Sort();
+  // Update array of trackParamAtCluster
+  track.AddTrackParamAtCluster(trackParamAtCluster1,*cluster1);
+  track.AddTrackParamAtCluster(trackParamAtCluster2,*cluster2);
   
 }
 
   //__________________________________________________________________________
-Bool_t AliMUONTrackReconstructorK::RecoverTrack(AliMUONTrack &trackCandidate, Int_t nextStation)
+Bool_t AliMUONTrackReconstructorK::RecoverTrack(AliMUONTrack &trackCandidate, AliMUONVClusterStore& clusterStore, Int_t nextStation)
 {
   /// Try to recover the track candidate in the next station
-  /// by removing the worst of the two hits attached in the current station
+  /// by removing the worst of the two clusters attached in the current station
   /// Return kTRUE if recovering succeeds
   AliDebug(1,"Enter RecoverTrack");
   
-  // Do not try to recover track until we have attached hit(s) on station(1..) 3
+  // Do not try to recover track until we have attached cluster(s) on station(1..) 3
   if (nextStation > 1) return kFALSE;
   
-  Int_t worstHitNumber = -1;
-  Double_t localChi2, worstChi2 = 0.;
+  Int_t worstClusterNumber = -1;
+  Double_t localChi2, worstLocalChi2 = -1.;
   
-  // Look for the hit to remove
-  for (Int_t hitNumber = 0; hitNumber < 2; hitNumber++) {
-    AliMUONTrackParam *trackParamAtHit = (AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->UncheckedAt(hitNumber);
+  // Look for the cluster to remove
+  for (Int_t clusterNumber = 0; clusterNumber < 2; clusterNumber++) {
+    AliMUONTrackParam *trackParamAtCluster = (AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->UncheckedAt(clusterNumber);
+    
+    // check if current cluster is in the previous station
+    if (trackParamAtCluster->GetClusterPtr()->GetChamberId()/2 != nextStation+1) break;
+    
+    // check if current cluster is removable
+    if (!trackParamAtCluster->IsRemovable()) return kFALSE;
     
-    // check if current hit is removable
-    if (!trackParamAtHit->IsRemovable()) return kFALSE;
+    // reset the current cluster as being not removable if it is on a required station
+    if (GetRecoParam()->RequestStation(nextStation+1)) trackParamAtCluster->SetRemovable(kFALSE);
     
-    // Pick up hit with the worst chi2
-    localChi2 = trackParamAtHit->GetLocalChi2();
-    if (localChi2 > worstChi2) {
-      worstChi2 = localChi2;
-      worstHitNumber = hitNumber;
+    // Pick up cluster with the worst chi2
+    localChi2 = trackParamAtCluster->GetLocalChi2();
+    if (localChi2 > worstLocalChi2) {
+      worstLocalChi2 = localChi2;
+      worstClusterNumber = clusterNumber;
     }
   }
   
-  // Reset best hit as being NOT removable
-  ((AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->UncheckedAt((worstHitNumber+1)%2))->SetRemovable(kFALSE);
+  // check if worst cluster found
+  if (worstClusterNumber < 0) return kFALSE;
   
-  // Remove the worst hit
-  trackCandidate.RemoveTrackParamAtHit((AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->UncheckedAt(worstHitNumber));
+  // Remove the worst cluster
+  trackCandidate.RemoveTrackParamAtCluster((AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->UncheckedAt(worstClusterNumber));
   
-  // Re-calculate track parameters at the (new) first hit
-  RetracePartialTrack(trackCandidate,(AliMUONTrackParam*)trackCandidate.GetTrackParamAtHit()->UncheckedAt(1));
+  // Re-calculate track parameters at the (new) first cluster
+  if (!RetracePartialTrack(trackCandidate,(AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->UncheckedAt(1))) return kFALSE;
   
-  // Look for new hit(s) in next station
-  return FollowTrackInStation(trackCandidate,nextStation);
+  // skip track out of limits
+  if (!IsAcceptable(*((AliMUONTrackParam*)trackCandidate.GetTrackParamAtCluster()->First()))) return kFALSE;
+  
+  // Look for new cluster(s) in next station
+  return FollowTrackInStation(trackCandidate, clusterStore, nextStation);
   
 }
 
@@ -827,24 +1233,27 @@ Bool_t AliMUONTrackReconstructorK::RecoverTrack(AliMUONTrack &trackCandidate, In
 Bool_t AliMUONTrackReconstructorK::RunSmoother(AliMUONTrack &track)
 {
   /// Compute new track parameters and their covariances using smoother
-  AliDebug(1,"Enter RunSmoother");
+  AliDebug(1,"Enter UseSmoother");
   
-  AliMUONTrackParam *previousTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtHit()->First();
+  AliMUONTrackParam *previousTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->First();
   
-  // Smoothed parameters and covariances at first hit = filtered parameters and covariances
+  // Smoothed parameters and covariances at first cluster = filtered parameters and covariances
   previousTrackParam->SetSmoothParameters(previousTrackParam->GetParameters());
   previousTrackParam->SetSmoothCovariances(previousTrackParam->GetCovariances());
+
+  AliMUONTrackParam *currentTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->After(previousTrackParam);
   
-  // Compute local chi2 at first hit
-  AliMUONHitForRec *hitForRecAtHit = previousTrackParam->GetHitForRecPtr();
-  Double_t dX = hitForRecAtHit->GetNonBendingCoor() - previousTrackParam->GetNonBendingCoor();
-  Double_t dY = hitForRecAtHit->GetBendingCoor() - previousTrackParam->GetBendingCoor();
-  Double_t localChi2 = dX * dX / hitForRecAtHit->GetNonBendingReso2() + dY * dY / hitForRecAtHit->GetBendingReso2();
+  // Save local chi2 at first cluster = last additional chi2 provided by Kalman
+  previousTrackParam->SetLocalChi2(previousTrackParam->GetTrackChi2() - currentTrackParam->GetTrackChi2());
   
-  // Save local chi2 at first hit
-  previousTrackParam->SetLocalChi2(localChi2);
+  // if the track contains only 2 clusters simply copy the filtered parameters
+  if (track.GetNClusters() == 2) {
+    currentTrackParam->SetSmoothParameters(currentTrackParam->GetParameters());
+    currentTrackParam->SetSmoothCovariances(currentTrackParam->GetCovariances());
+    currentTrackParam->SetLocalChi2(currentTrackParam->GetTrackChi2());
+    return kTRUE;
+  }
   
-  AliMUONTrackParam *currentTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtHit()->After(previousTrackParam);
   while (currentTrackParam) {
     
     // Get variables
@@ -856,7 +1265,7 @@ Bool_t AliMUONTrackReconstructorK::RunSmoother(AliMUONTrack &track)
     const TMatrixD &filteredCovariances       = currentTrackParam->GetCovariances();        // C(k k)
     const TMatrixD &previousSmoothCovariances = previousTrackParam->GetSmoothCovariances(); // C(k+1 n)
     
-    // Compute smoother gain: A(k) = C(kk) * F(f)^t * (C(k+1 k))^-1
+    // Compute smoother gain: A(k) = C(kk) * F(k)^t * (C(k+1 k))^-1
     TMatrixD extrapWeight(extrapCovariances);
     if (extrapWeight.Determinant() != 0) {
       extrapWeight.Invert(); // (C(k+1 k))^-1
@@ -864,8 +1273,8 @@ Bool_t AliMUONTrackReconstructorK::RunSmoother(AliMUONTrack &track)
       AliWarning(" Determinant = 0");
       return kFALSE;
     }
-    TMatrixD smootherGain(filteredCovariances,TMatrixD::kMultTranspose,propagator); // C(kk) * F(f)^t
-    smootherGain *= extrapWeight; // C(kk) * F(f)^t * (C(k+1 k))^-1
+    TMatrixD smootherGain(filteredCovariances,TMatrixD::kMultTranspose,propagator); // C(kk) * F(k)^t
+    smootherGain *= extrapWeight; // C(kk) * F(k)^t * (C(k+1 k))^-1
     
     // Compute smoothed parameters: X(k n) = X(k k) + A(k) * (X(k+1 n) - X(k+1 k))
     TMatrixD tmpParam(previousSmoothParameters,TMatrixD::kMinus,extrapParameters); // X(k+1 n) - X(k+1 k)
@@ -884,19 +1293,19 @@ Bool_t AliMUONTrackReconstructorK::RunSmoother(AliMUONTrack &track)
     // Save smoothed covariances
     currentTrackParam->SetSmoothCovariances(smoothCovariances);
     
-    // Compute smoothed residual: r(k n) = hit - X(k n)
-    hitForRecAtHit = currentTrackParam->GetHitForRecPtr();
+    // Compute smoothed residual: r(k n) = cluster - X(k n)
+    AliMUONVCluster* cluster = currentTrackParam->GetClusterPtr();
     TMatrixD smoothResidual(2,1);
     smoothResidual.Zero();
-    smoothResidual(0,0) = hitForRecAtHit->GetNonBendingCoor() - smoothParameters(0,0);
-    smoothResidual(1,0) = hitForRecAtHit->GetBendingCoor() - smoothParameters(2,0);
+    smoothResidual(0,0) = cluster->GetX() - smoothParameters(0,0);
+    smoothResidual(1,0) = cluster->GetY() - smoothParameters(2,0);
     
-    // Compute weight of smoothed residual: W(k n) = (hitCov - C(k n))^-1
+    // Compute weight of smoothed residual: W(k n) = (clusterCov - C(k n))^-1
     TMatrixD smoothResidualWeight(2,2);
-    smoothResidualWeight(0,0) = hitForRecAtHit->GetNonBendingReso2() - smoothCovariances(0,0);
+    smoothResidualWeight(0,0) = cluster->GetErrX2() - smoothCovariances(0,0);
     smoothResidualWeight(0,1) = - smoothCovariances(0,2);
     smoothResidualWeight(1,0) = - smoothCovariances(2,0);
-    smoothResidualWeight(1,1) = hitForRecAtHit->GetBendingReso2() - smoothCovariances(2,2);
+    smoothResidualWeight(1,1) = cluster->GetErrY2() - smoothCovariances(2,2);
     if (smoothResidualWeight.Determinant() != 0) {
       smoothResidualWeight.Invert();
     } else {
@@ -912,7 +1321,7 @@ Bool_t AliMUONTrackReconstructorK::RunSmoother(AliMUONTrack &track)
     currentTrackParam->SetLocalChi2(localChi2(0,0));
     
     previousTrackParam = currentTrackParam;
-    currentTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtHit()->After(previousTrackParam);
+    currentTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->After(previousTrackParam);
   }
   
   return kTRUE;
@@ -920,139 +1329,301 @@ Bool_t AliMUONTrackReconstructorK::RunSmoother(AliMUONTrack &track)
 }
 
   //__________________________________________________________________________
-void AliMUONTrackReconstructorK::ImproveTracks()
+Bool_t AliMUONTrackReconstructorK::ComplementTracks(const AliMUONVClusterStore& clusterStore)
 {
-  /// Improve tracks by removing clusters with local chi2 highter than the defined cut
-  /// Recompute track parameters and covariances at the remaining clusters
-  AliDebug(1,"Enter ImproveTracks");
-  
-  Double_t localChi2, worstLocalChi2;
-  Int_t worstChamber;
-  AliMUONTrackParam *trackParamAtHit, *worstTrackParamAtHit;
-  Bool_t smoothed;
-  
-  // Remove double track to improve only "good" tracks
-  RemoveDoubleTracks();
+  /// Complete tracks by adding missing clusters (if there is an overlap between
+  /// two detection elements, the track may have two clusters in the same chamber).
+  /// Recompute track parameters and covariances at each clusters.
+  /// Remove tracks getting abnormal (i.e. extrapolation failed...) after being complemented.
+  /// Return kTRUE if one or more tracks have been complemented or removed.
+  AliDebug(1,"Enter ComplementTracks");
+  
+  Int_t chamberId, detElemId;
+  Double_t chi2OfCluster, addChi2TrackAtCluster, bestAddChi2TrackAtCluster;
+  Double_t maxChi2OfCluster = 2. * GetRecoParam()->GetSigmaCutForTracking() *
+                                  GetRecoParam()->GetSigmaCutForTracking(); // 2 because 2 quantities in chi2
+  Bool_t foundOneCluster, trackModified, hasChanged = kFALSE;
+  AliMUONVCluster *cluster;
+  AliMUONTrackParam *trackParam, *previousTrackParam, *nextTrackParam, trackParamAtCluster, bestTrackParamAtCluster;
+  AliMUONTrack *nextTrack;
   
   AliMUONTrack *track = (AliMUONTrack*) fRecTracksPtr->First();
   while (track) {
+    trackModified = kFALSE;
     
-    while (!track->IsImproved()) {
+    trackParam = (AliMUONTrackParam*)track->GetTrackParamAtCluster()->First();
+    previousTrackParam = trackParam;
+    while (trackParam) {
+      foundOneCluster = kFALSE;
+      bestAddChi2TrackAtCluster = AliMUONTrack::MaxChi2();
+      chamberId = trackParam->GetClusterPtr()->GetChamberId();
+      detElemId = trackParam->GetClusterPtr()->GetDetElemId();
       
-      // Run smoother if required
-      smoothed = kFALSE;
-      if (fgkRunSmoother) smoothed = RunSmoother(*track);
+      // prepare nextTrackParam before adding new cluster because of the sorting
+      nextTrackParam = (AliMUONTrackParam*)track->GetTrackParamAtCluster()->After(trackParam);
       
-      // Use standard procedure to compute local chi2 if smoother not required or not working
-      if (!smoothed) {
-        
-        // Update track parameters and covariances
-        track->UpdateCovTrackParamAtHit();
-        
-        // Compute local chi2 of each hits
-        track->ComputeLocalChi2(kTRUE);
-      }
+      // Create iterators to loop over clusters in current chamber
+      TIter nextInCh(clusterStore.CreateChamberIterator(chamberId,chamberId));
       
-      // Look for the hit to remove
-      worstTrackParamAtHit = NULL;
-      worstLocalChi2 = 0.;
-      trackParamAtHit = (AliMUONTrackParam*)track->GetTrackParamAtHit()->First();
-      while (trackParamAtHit) {
-        
-        // Pick up hit with the worst chi2
-        localChi2 = trackParamAtHit->GetLocalChi2();
-        if (localChi2 > worstLocalChi2) {
-          worstLocalChi2 = localChi2;
-          worstTrackParamAtHit = trackParamAtHit;
-        }
+      // look for one second candidate in the same chamber
+      while ( ( cluster = static_cast<AliMUONVCluster*>(nextInCh()) ) ) {
         
-      trackParamAtHit = (AliMUONTrackParam*)track->GetTrackParamAtHit()->After(trackParamAtHit);
+       // look for a cluster in another detection element
+       if (cluster->GetDetElemId() == detElemId) continue;
+       
+       // try to add the current cluster fast
+       if (!TryOneClusterFast(*trackParam, cluster)) continue;
+       
+       // try to add the current cluster accurately
+       // never use track parameters at last cluster because the covariance matrix is meaningless
+       if (nextTrackParam) chi2OfCluster = TryOneCluster(*trackParam, cluster, trackParamAtCluster);
+       else chi2OfCluster = TryOneCluster(*previousTrackParam, cluster, trackParamAtCluster);
+       
+       // if good chi2 then consider to add this cluster to the track
+       if (chi2OfCluster < maxChi2OfCluster) {
+          
+         // Compute local track parameters including current cluster using kalman filter
+          addChi2TrackAtCluster = RunKalmanFilter(trackParamAtCluster);
+          
+         // keep track of the best cluster
+         if (addChi2TrackAtCluster < bestAddChi2TrackAtCluster) {
+           bestAddChi2TrackAtCluster = addChi2TrackAtCluster;
+           bestTrackParamAtCluster = trackParamAtCluster;
+           foundOneCluster = kTRUE;
+         }
+         
+       }
+       
       }
       
-      // Check if bad removable hit found
-      if (!worstTrackParamAtHit) {
-        track->SetImproved(kTRUE);
-        break;
+      // add new cluster if any
+      if (foundOneCluster) {
+       
+       // Printout for debuging
+       if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+         cout << "ComplementTracks: found one cluster in chamber(1..): " << chamberId+1 << endl;
+         bestTrackParamAtCluster.GetClusterPtr()->Print();
+         if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+           cout<<endl<<"Track parameters and covariances at cluster:"<<endl;
+           bestTrackParamAtCluster.GetParameters().Print();
+           bestTrackParamAtCluster.GetCovariances().Print();
+         }
+       }
+       
+       trackParam->SetRemovable(kTRUE);
+       bestTrackParamAtCluster.SetRemovable(kTRUE);
+       track->AddTrackParamAtCluster(bestTrackParamAtCluster,*(bestTrackParamAtCluster.GetClusterPtr()));
+       trackModified = kTRUE;
+       hasChanged = kTRUE;
       }
       
-      // check whether the worst hit is removable or not
-      if (!worstTrackParamAtHit->IsRemovable()) {
-        track->SetImproved(kTRUE);
-        break;
-      }
+      previousTrackParam = trackParam;
+      trackParam = nextTrackParam;
+    }
+    
+    // prepare next track
+    nextTrack = (AliMUONTrack*) fRecTracksPtr->After(track);
+    
+    // re-compute track parameters using kalman filter if needed
+    if (trackModified && !RetraceTrack(*track,kTRUE)) {
+      AliWarning("track modified but problem occur during refitting --> remove track");
+      fRecTracksPtr->Remove(track);
+      fNRecTracks--;
+    }
+    
+    track = nextTrack;
+  }
+  
+  return hasChanged;
+  
+}
+
+//__________________________________________________________________________
+void AliMUONTrackReconstructorK::ImproveTrack(AliMUONTrack &track)
+{
+  /// Improve the given track by removing removable clusters with local chi2 highter than the defined cut
+  /// Removable clusters are identified by the method AliMUONTrack::TagRemovableClusters()
+  /// Recompute track parameters and covariances at the remaining clusters
+  /// and if something goes wrong (i.e. extrapolation failed...) set track chi2 to max value
+  AliDebug(1,"Enter ImproveTrack");
+  
+  Double_t localChi2, worstLocalChi2;
+  AliMUONTrackParam *trackParamAtCluster, *worstTrackParamAtCluster, *nextTrackParam, *next2nextTrackParam;
+  Int_t nextChamber, next2nextChamber;
+  Bool_t smoothed;
+  Double_t sigmaCut2 = GetRecoParam()->GetSigmaCutForImprovement() *
+                       GetRecoParam()->GetSigmaCutForImprovement();
+  
+  while (!track.IsImproved()) {
+    
+    // identify removable clusters
+    track.TagRemovableClusters(GetRecoParam()->RequestedStationMask());
+    
+    // Run smoother if required
+    smoothed = kFALSE;
+    if (GetRecoParam()->UseSmoother()) smoothed = RunSmoother(track);
+    
+    // Use standard procedure to compute local chi2 if smoother not required or not working
+    if (!smoothed) {
       
-      // Check whether the worst chi2 is under requirement or not
-      if (worstLocalChi2 < 2. * fgkSigmaToCutForImprovement * fgkSigmaToCutForImprovement) { // 2 because 2 quantities in chi2
-        track->SetImproved(kTRUE);
-        break;
+      // Update track parameters and covariances
+      if (!track.UpdateCovTrackParamAtCluster()) {
+       AliWarning("unable to update track parameters and covariances --> stop improvement");
+       // restore the kalman parameters
+       RetraceTrack(track,kTRUE);
+       break;
       }
       
-      // Reset the second hit in the same station as the bad one as being NOT removable
-      worstChamber = worstTrackParamAtHit->GetHitForRecPtr()->GetChamberNumber();
-      if (worstChamber%2 == 0) ((AliMUONTrackParam*)track->GetTrackParamAtHit()->After(worstTrackParamAtHit))->SetRemovable(kFALSE);
-      else ((AliMUONTrackParam*)track->GetTrackParamAtHit()->Before(worstTrackParamAtHit))->SetRemovable(kFALSE);
+      // Compute local chi2 of each clusters
+      track.ComputeLocalChi2(kTRUE);
+    }
+    
+    // Look for the cluster to remove
+    worstTrackParamAtCluster = 0x0;
+    worstLocalChi2 = -1.;
+    trackParamAtCluster = (AliMUONTrackParam*)track.GetTrackParamAtCluster()->First();
+    while (trackParamAtCluster) {
       
-      // Save pointer to the trackParamAtHit next to the one to be removed
-      trackParamAtHit = (AliMUONTrackParam*)track->GetTrackParamAtHit()->After(worstTrackParamAtHit);
+      // save parameters into smooth parameters in case of smoother did not work properly
+      if (GetRecoParam()->UseSmoother() && !smoothed) {
+       trackParamAtCluster->SetSmoothParameters(trackParamAtCluster->GetParameters());
+       trackParamAtCluster->SetSmoothCovariances(trackParamAtCluster->GetCovariances());
+      }
       
-      // Remove the worst hit
-      track->RemoveTrackParamAtHit(worstTrackParamAtHit);
+      // Pick up cluster with the worst chi2
+      localChi2 = trackParamAtCluster->GetLocalChi2();
+      if (localChi2 > worstLocalChi2) {
+       worstLocalChi2 = localChi2;
+       worstTrackParamAtCluster = trackParamAtCluster;
+      }
       
-      // Re-calculate track parameters
-      // - from the hit immediately downstream the one suppressed
-      // - or from the begining - if parameters have been re-computed using the standard method (kalman parameters have been lost)
-      //                       - or if the removed hit was the last one
-      if (smoothed && trackParamAtHit) RetracePartialTrack(*track,trackParamAtHit);
-      else RetraceTrack(*track,kTRUE);
+      trackParamAtCluster = (AliMUONTrackParam*)track.GetTrackParamAtCluster()->After(trackParamAtCluster);
+    }
+    
+    // Check whether the worst chi2 is under requirement or not
+    if (worstLocalChi2 < 2. * sigmaCut2) { // 2 because 2 quantities in chi2
+      track.SetImproved(kTRUE);
+      break;
+    }
+    
+    // if the worst cluster is not removable then stop improvement
+    if (!worstTrackParamAtCluster->IsRemovable()) {
+      // restore the kalman parameters in case they have been lost
+      if (!smoothed) RetraceTrack(track,kTRUE);
+      break;
+    }
+    
+    // get track parameters at cluster next to the one to be removed
+    nextTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->After(worstTrackParamAtCluster);
+    
+    // Remove the worst cluster
+    track.RemoveTrackParamAtCluster(worstTrackParamAtCluster);
+    
+    // Re-calculate track parameters
+    // - from the cluster immediately downstream the one suppressed
+    // - or from the begining - if parameters have been re-computed using the standard method (kalman parameters have been lost)
+    //                        - or if the removed cluster was used to compute the tracking seed
+    Bool_t normalExtrap;
+    if (smoothed && nextTrackParam) {
       
-      // Printout for debuging
-      if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
-        cout << "ImproveTracks: track " << fRecTracksPtr->IndexOf(track)+1 << " improved " << endl;
-      }
+      nextChamber = nextTrackParam->GetClusterPtr()->GetChamberId();
+      next2nextTrackParam = nextTrackParam;
+      do {
+       
+       next2nextChamber = next2nextTrackParam->GetClusterPtr()->GetChamberId();
+       next2nextTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->After(next2nextTrackParam);
+       
+      } while (next2nextTrackParam && (next2nextChamber == nextChamber));
+      
+      if (next2nextChamber == nextChamber) normalExtrap = RetraceTrack(track,kTRUE);
+      else normalExtrap = RetracePartialTrack(track,nextTrackParam);
       
+    } else normalExtrap = RetraceTrack(track,kTRUE);
+    
+    // stop in case of extrapolation problem
+    if (!normalExtrap) {
+      AliWarning("track partially improved but problem occur during refitting --> stop improvement");
+      break;
+    }
+    
+    // Printout for debuging
+    if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
+      cout << "ImproveTracks: track " << fRecTracksPtr->IndexOf(&track)+1 << " improved " << endl;
     }
     
-    track = (AliMUONTrack*) fRecTracksPtr->After(track);
   }
   
 }
 
-  //__________________________________________________________________________
-void AliMUONTrackReconstructorK::Finalize()
+//__________________________________________________________________________
+Bool_t AliMUONTrackReconstructorK::FinalizeTrack(AliMUONTrack &track)
 {
-  /// Fill AliMUONTrack's fHitForRecAtHit array
-  AliMUONTrack *track;
-  AliMUONTrackParam *trackParamAtHit;
+  /// Update track parameters and covariances at each attached cluster
+  /// using smoother if required, if not already done
+  /// return kFALSE if the track cannot be extrapolated uo to the last chamber
+  
+  AliMUONTrackParam *trackParamAtCluster;
   Bool_t smoothed = kFALSE;
   
-  track = (AliMUONTrack*) fRecTracksPtr->First();
-  while (track) {
-    
-    // update track parameters (using smoother if required) if not already done
-    if (!track->IsImproved()) {
-      smoothed = kFALSE;
-      if (fgkRunSmoother) smoothed = RunSmoother(*track);
-      if (!smoothed) track->UpdateCovTrackParamAtHit();
+  // update track parameters (using smoother if required) if not already done
+  if (track.IsImproved()) smoothed = GetRecoParam()->UseSmoother();
+  else {
+    if (GetRecoParam()->UseSmoother()) smoothed = RunSmoother(track);
+    if (!smoothed) {
+      if (track.UpdateCovTrackParamAtCluster()) track.ComputeLocalChi2(kTRUE);
+      else {
+       AliWarning("finalization failed due to extrapolation problem");
+       return kFALSE;
+      }
     }
+  }
+  
+  // copy smoothed parameters and covariances if any
+  if (smoothed) {
     
-    trackParamAtHit = (AliMUONTrackParam*) (track->GetTrackParamAtHit()->First());
-    while (trackParamAtHit) {
-      
-      // copy smoothed parameters and covariances if any
-      if (smoothed) {
-        trackParamAtHit->SetParameters(trackParamAtHit->GetSmoothParameters());
-        trackParamAtHit->SetCovariances(trackParamAtHit->GetSmoothCovariances());
-      }
+    trackParamAtCluster = (AliMUONTrackParam*) (track.GetTrackParamAtCluster()->First());
+    while (trackParamAtCluster) {
       
-      // update array of track hits
-      track->AddHitForRecAtHit(trackParamAtHit->GetHitForRecPtr());
+      trackParamAtCluster->SetParameters(trackParamAtCluster->GetSmoothParameters());
+      trackParamAtCluster->SetCovariances(trackParamAtCluster->GetSmoothCovariances());
       
-      trackParamAtHit = (AliMUONTrackParam*) (track->GetTrackParamAtHit()->After(trackParamAtHit));
+      trackParamAtCluster = (AliMUONTrackParam*) (track.GetTrackParamAtCluster()->After(trackParamAtCluster));
     }
     
-    track = (AliMUONTrack*) fRecTracksPtr->After(track);
-    
   }
-    
+  
+  return kTRUE;
+  
+}
+
+  //__________________________________________________________________________
+Bool_t AliMUONTrackReconstructorK::RefitTrack(AliMUONTrack &track, Bool_t enableImprovement)
+{
+  /// re-fit the given track
+  AliDebug(1,"Enter RefitTrack");
+  
+  // check validity of the track (i.e. at least 2 chambers hit on stations 4 and 5)
+  if (!track.IsValid(0)) {
+    AliWarning("the track is not valid --> unable to refit");
+    return kFALSE;
+  }
+  
+  // re-compute track parameters and covariances using Kalman filter
+  if (!RetraceTrack(track,kTRUE)) {
+    AliWarning("bad track refitting due to extrapolation failure");
+    return kFALSE;
+  }
+  
+  // Improve the reconstructed tracks if required
+  track.SetImproved(kFALSE);
+  if (enableImprovement && GetRecoParam()->ImproveTracks()) ImproveTrack(track);
+  
+  // Fill AliMUONTrack data members
+  if (track.GetGlobalChi2() < AliMUONTrack::MaxChi2()) return FinalizeTrack(track);
+  else {
+    AliWarning("track not finalized due to extrapolation failure");
+    return kFALSE;
+  }
+  
 }