New "EventReconstructor..." structure,
authorgosset <gosset@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 20 Jul 2000 12:45:27 +0000 (12:45 +0000)
committergosset <gosset@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 20 Jul 2000 12:45:27 +0000 (12:45 +0000)
hopefully more adapted to tree/streamer.
"AliMUONEventReconstructor::RemoveDoubleTracks"
to keep only one track among similar ones.

MUON/AliMUONEventReconstructor.cxx
MUON/AliMUONEventReconstructor.h
MUON/AliMUONTrack.cxx
MUON/AliMUONTrack.h
MUON/AliMUONTrackHit.cxx

index 2023f4b16a983cae735f7cd2a19aa79acdc89303..3a562462bacc8a5f80cea42f51c0f7fa802bdaac 100644 (file)
 
 /*
 $Log$
+Revision 1.8  2000/07/18 16:04:06  gosset
+AliMUONEventReconstructor package:
+* a few minor modifications and more comments
+* a few corrections
+  * right sign for Z of raw clusters
+  * right loop over chambers inside station
+  * symmetrized covariance matrix for measurements (TrackChi2MCS)
+  * right sign of charge in extrapolation (ExtrapToZ)
+  * right zEndAbsorber for Branson correction below 3 degrees
+* use of TVirtualFitter instead of TMinuit for AliMUONTrack::Fit
+* no parameter for AliMUONTrack::Fit() but more fit parameters in Track object
+
 Revision 1.7  2000/07/03 12:28:06  gosset
 Printout at the right place after extrapolation to vertex
 
@@ -138,6 +150,10 @@ AliMUONEventReconstructor::AliMUONEventReconstructor(void)
   // Is 10 the right size ????
   fRecTracksPtr = new TClonesArray("AliMUONTrack", 10);
   fNRecTracks = 0; // really needed or GetEntriesFast sufficient ????
+  // Memory allocation for the TClonesArray of hits on reconstructed tracks
+  // Is 100 the right size ????
+  fRecTrackHitsPtr = new TClonesArray("AliMUONTrack", 100);
+  fNRecTrackHits = 0; // really needed or GetEntriesFast sufficient ????
 
   // Initialize magnetic field
   // using Fortran subroutine INITFIELD in "reco_muon.F".
@@ -400,11 +416,22 @@ void AliMUONEventReconstructor::ResetSegments(void)
 void AliMUONEventReconstructor::ResetTracks(void)
 {
   // To reset the TClonesArray of reconstructed tracks
-  if (fRecTracksPtr) fRecTracksPtr->Clear();
+  if (fRecTracksPtr) fRecTracksPtr->Delete();
+  // Delete in order that the Track destructors are called,
+  // hence the space for the TClonesArray of pointers to TrackHit's is freed
   fNRecTracks = 0;
   return;
 }
 
+  //__________________________________________________________________________
+void AliMUONEventReconstructor::ResetTrackHits(void)
+{
+  // To reset the TClonesArray of hits on reconstructed tracks
+  if (fRecTrackHitsPtr) fRecTrackHitsPtr->Clear();
+  fNRecTrackHits = 0;
+  return;
+}
+
   //__________________________________________________________________________
 void AliMUONEventReconstructor::MakeEventToBeReconstructed(void)
 {
@@ -829,11 +856,15 @@ void AliMUONEventReconstructor::MakeTracks(void)
   // To make the tracks,
   // from the list of segments and points in all stations
   if (fPrintLevel >= 1) cout << "enter MakeTracks" << endl;
+  // The order may be important for the following Reset's
   ResetTracks();
+  ResetTrackHits();
   // Look for candidates from at least 3 aligned points in stations(1..) 4 and 5
   MakeTrackCandidates();
   // Follow tracks in stations(1..) 3, 2 and 1
   FollowTracks();
+  // Remove double tracks
+  RemoveDoubleTracks();
   return;
 }
 
@@ -1135,13 +1166,9 @@ void AliMUONEventReconstructor::FollowTracks(void)
          }
        }
        else {
-         // Remove current track candidate and update fNRecTracks
-         // To be checked: recursive delete of TrackHit's !!!!
-         // For cleaner implementation: call track->Remove()
-         // to be coded, with all cleanings,
-         // including links between HitForRec's and TrackHit's !!!!
-         fRecTracksPtr->Remove(track);
-         fNRecTracks--;
+         // Remove current track candidate
+         // and corresponding TrackHit's, ...
+         track->Remove();
          delete extrapSegment;
          break; // stop the search for this candidate:
          // exit from the loop over station
@@ -1187,6 +1214,50 @@ void AliMUONEventReconstructor::FollowTracks(void)
   return;
 }
 
+  //__________________________________________________________________________
+void AliMUONEventReconstructor::RemoveDoubleTracks(void)
+{
+  // To remove double tracks.
+  // Tracks are considered identical
+  // if they have at least half of their hits in common.
+  // Among two identical tracks, one keeps the track with the larger number of hits
+  // or, if these numbers are equal, the track with the minimum Chi2.
+  AliMUONTrack *track1, *track2, *trackToRemove;
+  Bool_t identicalTracks;
+  Int_t hitsInCommon, nHits1, nHits2;
+  identicalTracks = kTRUE;
+  while (identicalTracks) {
+    identicalTracks = kFALSE;
+    // Loop over first track of the pair
+    track1 = (AliMUONTrack*) fRecTracksPtr->First();
+    while (track1 && (!identicalTracks)) {
+      nHits1 = track1->GetNTrackHits();
+      // Loop over second track of the pair
+      track2 = (AliMUONTrack*) fRecTracksPtr->After(track1);
+      while (track2 && (!identicalTracks)) {
+       nHits2 = track2->GetNTrackHits();
+       // number of hits in common between two tracks
+       hitsInCommon = track1->HitsInCommon(track2);
+       // check for identical tracks
+       if ((4 * hitsInCommon) >= (nHits1 + nHits2)) {
+         identicalTracks = kTRUE;
+         // decide which track to remove
+         if (nHits1 > nHits2) trackToRemove = track2;
+         else if (nHits1 < nHits2) trackToRemove = track1;
+         else if ((track1->GetFitFMin()) < (track2->GetFitFMin()))
+           trackToRemove = track2;
+         else trackToRemove = track1;
+         // remove it
+         trackToRemove->Remove();
+       }
+       track2 = (AliMUONTrack*) fRecTracksPtr->After(track2);
+      } // track2
+      track1 = (AliMUONTrack*) fRecTracksPtr->After(track1);
+    } // track1
+  }
+  return;
+}
+
   //__________________________________________________________________________
 void AliMUONEventReconstructor::EventDump(void)
 {
index 84da84262cc57f046023c1f3f24b9b904605e514..56c61c4dba1d7892ebc2ab5b03f5b6607c00aa96 100644 (file)
@@ -58,7 +58,17 @@ class AliMUONEventReconstructor : public TObject {
   void NextBkgGeantEvent(void); // next event in background file for GEANT hits
 
   // Hits for reconstruction
-  Int_t GetNHitsForRec() {return fNHitsForRec;} // Number
+  Int_t GetNHitsForRec(void) {return fNHitsForRec;} // Number
+
+  // Reconstructed tracks
+  Int_t GetNRecTracks() {return fNRecTracks;} // Number
+  void SetNRecTracks(Int_t NRecTracks) {fNRecTracks = NRecTracks;}
+  TClonesArray* GetRecTracksPtr(void) {return fRecTracksPtr;} // Array
+
+  // Hits on reconstructed tracks
+  Int_t GetNRecTrackHits() {return fNRecTrackHits;} // Number
+  void SetNRecTrackHits(Int_t NRecTrackHits) {fNRecTrackHits = NRecTrackHits;}
+  TClonesArray* GetRecTrackHitsPtr(void) {return fRecTrackHitsPtr;} // Array
 
   // Functions
   Double_t GetImpactParamFromBendingMomentum(Double_t BendingMomentum);
@@ -108,10 +118,14 @@ class AliMUONEventReconstructor : public TObject {
   TClonesArray *fSegmentsPtr[kMaxMuonTrackingStations]; // array of pointers to the segments for each station
   Int_t fNSegments[kMaxMuonTrackingStations]; // number of segments for each station
 
-  // Tracks
+  // Reconstructed tracks
   TClonesArray *fRecTracksPtr; // pointer to array of reconstructed tracks
   Int_t fNRecTracks; // number of reconstructed tracks
 
+  // Track hits on reconstructed tracks
+  TClonesArray *fRecTrackHitsPtr; // pointer to array of hits on reconstructed tracks
+  Int_t fNRecTrackHits; // number of hits on reconstructed tracks
+
   // Functions
   void ResetHitsForRec(void);
   void MakeEventToBeReconstructed(void);
@@ -125,11 +139,13 @@ class AliMUONEventReconstructor : public TObject {
   void ResetSegments(void);
   void MakeSegmentsPerStation(Int_t Station);
   void MakeTracks(void);
+  void ResetTrackHits(void);
   void ResetTracks(void);
   Int_t MakeTrackCandidatesWithTwoSegments(AliMUONSegment *BegSegment);
   Int_t MakeTrackCandidatesWithOneSegmentAndOnePoint(AliMUONSegment *BegSegment);
   void MakeTrackCandidates(void);
   void FollowTracks(void);
+  void RemoveDoubleTracks(void);
 
   ClassDef(AliMUONEventReconstructor, 1) // MUON event reconstructor in ALICE
     };
index 8e4f6153ffe8228d2dd00e2bce6fb65248a4e278..2f0474cc3ce0b2f47c4e879f394db32f9ddfbe4c 100644 (file)
 
 /*
 $Log$
+Revision 1.5  2000/07/18 16:04:06  gosset
+AliMUONEventReconstructor package:
+* a few minor modifications and more comments
+* a few corrections
+  * right sign for Z of raw clusters
+  * right loop over chambers inside station
+  * symmetrized covariance matrix for measurements (TrackChi2MCS)
+  * right sign of charge in extrapolation (ExtrapToZ)
+  * right zEndAbsorber for Branson correction below 3 degrees
+* use of TVirtualFitter instead of TMinuit for AliMUONTrack::Fit
+* no parameter for AliMUONTrack::Fit() but more fit parameters in Track object
+
 Revision 1.4  2000/06/30 10:15:48  gosset
 Changes to EventReconstructor...:
 precision fit with multiple Coulomb scattering;
@@ -49,6 +61,7 @@ Addition of files for track reconstruction in C++
 #include <TClonesArray.h>
 #include <TMath.h>
 #include <TMatrix.h>
+#include <TObjArray.h>
 #include <TVirtualFitter.h>
 
 #include "AliMUONEventReconstructor.h" 
@@ -73,17 +86,18 @@ AliMUONTrack::AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegmen
 {
   // Constructor from two Segment's
   fEventReconstructor = EventReconstructor; // link back to EventReconstructor
-  // memory allocation for the TClonesArray of reconstructed TrackHit's
-  fTrackHitsPtr = new  TClonesArray("AliMUONTrackHit", 10);
+  // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
+  fTrackHitsPtr = new TObjArray(10);
   fNTrackHits = 0;
   AddSegment(BegSegment); // add hits from BegSegment
   AddSegment(EndSegment); // add hits from EndSegment
   fTrackHitsPtr->Sort(); // sort TrackHits according to increasing Z
   SetTrackParamAtVertex(); // set track parameters at vertex
-  // set fit conditions
+  // set fit conditions...
   fFitMCS = 0;
   fFitNParam = 3;
   fFitStart = 1;
+  fFitFMin = -1.0;
   return;
 }
 
@@ -92,20 +106,31 @@ AliMUONTrack::AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec,
 {
   // Constructor from one Segment and one HitForRec
   fEventReconstructor = EventReconstructor; // link back to EventReconstructor
-  // memory allocation for the TClonesArray of reconstructed TrackHit's
-  fTrackHitsPtr = new  TClonesArray("AliMUONTrackHit", 10);
+  // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
+  fTrackHitsPtr = new TObjArray(10);
   fNTrackHits = 0;
   AddSegment(Segment); // add hits from Segment
   AddHitForRec(HitForRec); // add HitForRec
   fTrackHitsPtr->Sort(); // sort TrackHits according to increasing Z
   SetTrackParamAtVertex(); // set track parameters at vertex
-  // set fit conditions
+  // set fit conditions...
   fFitMCS = 0;
   fFitNParam = 3;
   fFitStart = 1;
+  fFitFMin = -1.0;
   return;
 }
 
+  //__________________________________________________________________________
+AliMUONTrack::~AliMUONTrack()
+{
+  // Destructor
+  if (fTrackHitsPtr) {
+    delete fTrackHitsPtr; // delete the TObjArray of pointers to TrackHit's
+    fTrackHitsPtr = NULL;
+  }
+}
+
   //__________________________________________________________________________
 AliMUONTrack::AliMUONTrack (const AliMUONTrack& MUONTrack)
 {
@@ -119,6 +144,39 @@ AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& MUONTrack)
     return *this;
 }
 
+  //__________________________________________________________________________
+void AliMUONTrack::Remove()
+{
+  // Remove current track from array of tracks,
+  // and corresponding track hits from array of track hits.
+  // Compress the TClonesArray it belongs to.
+  AliMUONTrackHit *nextTrackHit;
+  AliMUONEventReconstructor *eventRec = this->fEventReconstructor;
+  TClonesArray *trackHitsPtr = eventRec->GetRecTrackHitsPtr();
+  // Loop over all track hits of track
+  AliMUONTrackHit *trackHit = (AliMUONTrackHit*) fTrackHitsPtr->First();
+  while (trackHit) {
+    nextTrackHit = (AliMUONTrackHit*) fTrackHitsPtr->After(trackHit);
+    // Remove TrackHit from event TClonesArray.
+    // Destructor is called,
+    // hence links between HitForRec's and TrackHit's are updated
+    trackHitsPtr->Remove(trackHit);
+    trackHit = nextTrackHit;
+  }
+  // Remove the track from event TClonesArray
+  // Destructor is called,
+  // hence space for TObjArray of pointers to TrackHit's is freed
+  eventRec->GetRecTracksPtr()->Remove(this);
+  // Number of tracks decreased by 1
+  eventRec->SetNRecTracks(eventRec->GetNRecTracks() - 1);
+  // Compress event TClonesArray of Track's:
+  // this is essential to retrieve the TClonesArray afterwards
+  eventRec->GetRecTracksPtr()->Compress();
+  // Compress event TClonesArray of TrackHit's:
+  // this is probably also essential to retrieve the TClonesArray afterwards
+  trackHitsPtr->Compress();
+}
+
   //__________________________________________________________________________
 void AliMUONTrack::SetFitMCS(Int_t FitMCS)
 {
@@ -190,6 +248,30 @@ void AliMUONTrack::RecursiveDump(void)
   return;
 }
 
+  //__________________________________________________________________________
+Int_t AliMUONTrack::HitsInCommon(AliMUONTrack* Track)
+{
+  // Returns the number of hits in common
+  // between the current track ("this")
+  // and the track pointed to by "Track".
+  Int_t hitsInCommon = 0;
+  AliMUONTrackHit *trackHit1, *trackHit2;
+  // Loop over hits of first track
+  trackHit1 = (AliMUONTrackHit*) this->GetTrackHitsPtr()->First();
+  while (trackHit1) {
+    // Loop over hits of second track
+    trackHit2 = (AliMUONTrackHit*) Track->GetTrackHitsPtr()->First();
+    while (trackHit2) {
+      // Increment "hitsInCommon" if both TrackHits point to the same HitForRec
+      if ( (trackHit1->GetHitForRecPtr()) ==
+          (trackHit2->GetHitForRecPtr())    ) hitsInCommon++;
+      trackHit2 = (AliMUONTrackHit*) Track->GetTrackHitsPtr()->After(trackHit2);
+    } // trackHit2
+    trackHit1 = (AliMUONTrackHit*) this->GetTrackHitsPtr()->After(trackHit1);
+  } // trackHit1
+  return hitsInCommon;
+}
+
   //__________________________________________________________________________
 void AliMUONTrack::Fit()
 {
@@ -261,12 +343,16 @@ void AliMUONTrack::Fit()
     trackParam->SetNonBendingCoor(x);
     trackParam->SetBendingCoor(y);
   }
+  // global result of the fit
+  Double_t fedm, errdef;
+  Int_t npari, nparx;
+  fgFitter->GetStats(fFitFMin, fedm, errdef, npari, nparx);
 }
 
   //__________________________________________________________________________
 void AliMUONTrack::AddSegment(AliMUONSegment* Segment)
 {
-  // Add Segment
+  // Add Segment to the track
   AddHitForRec(Segment->GetHitForRec1()); // 1st hit
   AddHitForRec(Segment->GetHitForRec2()); // 2nd hit
 }
@@ -274,8 +360,17 @@ void AliMUONTrack::AddSegment(AliMUONSegment* Segment)
   //__________________________________________________________________________
 void AliMUONTrack::AddHitForRec(AliMUONHitForRec* HitForRec)
 {
-  // Add HitForRec
-  new ((*fTrackHitsPtr)[fNTrackHits]) AliMUONTrackHit(HitForRec);
+  // Add HitForRec to the track:
+  // actual TrackHit into TClonesArray of TrackHit's for the event;
+  // pointer to actual TrackHit in TObjArray of pointers to TrackHit's for the track
+  TClonesArray *recTrackHitsPtr = this->fEventReconstructor->GetRecTrackHitsPtr();
+  Int_t eventTrackHits = this->fEventReconstructor->GetNRecTrackHits();
+  // event
+  AliMUONTrackHit* trackHit =
+    new ((*recTrackHitsPtr)[eventTrackHits]) AliMUONTrackHit(HitForRec);
+  this->fEventReconstructor->SetNRecTrackHits(eventTrackHits + 1);
+  // track
+  fTrackHitsPtr->Add(trackHit);
   fNTrackHits++;
 }
 
index acfc47df3964f4a2f4c752d93667c41644d31b9b..7e742e79696a3a20df86de5841e3391c7f4d553c 100644 (file)
@@ -6,7 +6,7 @@
 /*$Id$*/
 
 #include <TROOT.h>
-#include <TClonesArray.h>
+#include <TObjArray.h>
 #include "AliMUONTrackParam.h"
 
 class TClonesArray;
@@ -20,23 +20,25 @@ class AliMUONTrack : public TObject {
   AliMUONTrack(){
     // Constructor
     ;} // Constructor
-  virtual ~AliMUONTrack() {;} // Destructor
+  virtual ~AliMUONTrack(); // Destructor
   AliMUONTrack (const AliMUONTrack& AliMUONTrack); // copy constructor
   AliMUONTrack& operator=(const AliMUONTrack& AliMUONTrack); // assignment operator
 
   AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegment, AliMUONEventReconstructor* EventReconstructor); // Constructor from two Segment's
   AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec, AliMUONEventReconstructor* EventReconstructor); // Constructor from one Segment and one HitForRec
+  void Remove(void);
 
   AliMUONEventReconstructor* GetEventReconstructor(void) {return fEventReconstructor;}
   AliMUONTrackParam* GetTrackParamAtVertex(void) { return &fTrackParamAtVertex;}
   void SetTrackParamAtVertex(void); // Set track parameters at vertex from last stations 4 & 5
   void SetTrackParamAtVertex(AliMUONTrackParam* TrackParam) {fTrackParamAtVertex = *TrackParam;}
 
-  TClonesArray* GetTrackHitsPtr(void) { return fTrackHitsPtr;}
+  TObjArray* GetTrackHitsPtr(void) { return fTrackHitsPtr;}
   Int_t GetNTrackHits(void) { return fNTrackHits;}
   Int_t GetFitMCS(void) {return fFitMCS;}
   Int_t GetFitNParam(void) {return fFitNParam;}
   Int_t GetFitStart(void) {return fFitStart;}
+  Double_t GetFitFMin(void) {return fFitFMin;}
   void SetFitMCS(Int_t FitMCS);
   void SetFitNParam(Int_t FitNParam);
   void SetFitStart(Int_t FitStart);
@@ -48,6 +50,7 @@ class AliMUONTrack : public TObject {
   void AddSegment(AliMUONSegment* Segment); // Add Segment
   void AddHitForRec(AliMUONHitForRec* HitForRec); // Add HitForRec
   void SetTrackParamAtHit(Int_t indexHit, AliMUONTrackParam *TrackParam);
+  Int_t HitsInCommon(AliMUONTrack* Track);
 
   static TVirtualFitter* AliMUONTrack::Fitter(void) {return fgFitter;}
 
@@ -56,11 +59,12 @@ class AliMUONTrack : public TObject {
   static TVirtualFitter* fgFitter; // Pointer to track fitter
   AliMUONEventReconstructor* fEventReconstructor; // Pointer to EventReconstructor
   AliMUONTrackParam fTrackParamAtVertex; // Track parameters at vertex
-  TClonesArray *fTrackHitsPtr; // Pointer to array of TrackHit's
+  TObjArray *fTrackHitsPtr; // Pointer to array of pointers to TrackHit's
   Int_t fNTrackHits; // Number of TrackHit's
   Int_t fFitMCS; // 0(1) for fit without(with) multiple Coulomb scattering
   Int_t fFitNParam; // 3(5) for fit with 3(5) parameters
   Int_t fFitStart; // 0 or 1 for fit starting from parameters at vertex (0) or at first TrackHit(1)
+  Double_t fFitFMin; // minimum value of the function minimized by the fit
   
   ClassDef(AliMUONTrack, 1) // Reconstructed track in ALICE dimuon spectrometer
     };
index fa14a667f2088a76aeab4a49f3c2838b1a5c829d..e0a7f786379c44aec43e7d8395e42c0bddceb111 100644 (file)
 
 /*
 $Log$
+Revision 1.4  2000/07/18 16:04:06  gosset
+AliMUONEventReconstructor package:
+* a few minor modifications and more comments
+* a few corrections
+  * right sign for Z of raw clusters
+  * right loop over chambers inside station
+  * symmetrized covariance matrix for measurements (TrackChi2MCS)
+  * right sign of charge in extrapolation (ExtrapToZ)
+  * right zEndAbsorber for Branson correction below 3 degrees
+* use of TVirtualFitter instead of TMinuit for AliMUONTrack::Fit
+* no parameter for AliMUONTrack::Fit() but more fit parameters in Track object
+
 Revision 1.3  2000/06/25 13:06:39  hristov
 Inline functions moved from *.cxx to *.h files instead of forward declarations
 
@@ -80,21 +92,23 @@ AliMUONTrackHit & AliMUONTrackHit::operator=(const AliMUONTrackHit& MUONTrackHit
 AliMUONTrackHit::~AliMUONTrackHit()
 {
   // Destructor
-//   AliMUONHitForRec * hit; // pointer to HitForRec
-//   // remove current TrackHit in HitForRec links
-//   if (this == hit->GetFirstTrackHitPtr())
-//     hit->SetFirstTrackHitPtr(fNextTrackHitWithSameHitForRec); // if first
-//   if (this == hit->GetLastTrackHitPtr())
-//     hit->SetLastTrackHitPtr(fPrevTrackHitWithSameHitForRec); // if last
-//   hit->SetNTrackHits(hit->GetNTrackHits() - 1); // decrement NTrackHits
-//   // update link to next TrackHit of previous TrackHit
-//   if (fPrevTrackHitWithSameHitForRec != NULL)
-//     fPrevTrackHitWithSameHitForRec->
-//       SetNextTrackHitWithSameHitForRec(fNextTrackHitWithSameHitForRec);
-//   // update link to previous TrackHit of next TrackHit
-//   if (fNextTrackHitWithSameHitForRec)
-//     fNextTrackHitWithSameHitForRec->
-//       SetPrevTrackHitWithSameHitForRec(fPrevTrackHitWithSameHitForRec);
+  // Update links between HitForRec's and TrackHit's
+  // connected to the current TrackHit being removed.
+  AliMUONHitForRec *hit = fHitForRecPtr; // pointer to HitForRec
+  // remove current TrackHit in HitForRec links
+  if (this == hit->GetFirstTrackHitPtr())
+    hit->SetFirstTrackHitPtr(fNextTrackHitWithSameHitForRec); // if first
+  if (this == hit->GetLastTrackHitPtr())
+    hit->SetLastTrackHitPtr(fPrevTrackHitWithSameHitForRec); // if last
+  hit->SetNTrackHits(hit->GetNTrackHits() - 1); // decrement NTrackHits of hit
+  // update link to next TrackHit of previous TrackHit
+  if (fPrevTrackHitWithSameHitForRec != NULL)
+    fPrevTrackHitWithSameHitForRec->
+      SetNextTrackHitWithSameHitForRec(fNextTrackHitWithSameHitForRec);
+  // update link to previous TrackHit of next TrackHit
+  if (fNextTrackHitWithSameHitForRec)
+    fNextTrackHitWithSameHitForRec->
+      SetPrevTrackHitWithSameHitForRec(fPrevTrackHitWithSameHitForRec);
   // to be checked thoroughly !!!!
   // with Root counter of AliMUONTrackHit objects,
   // with loop over all these links after the update