Conding conventions violation and Doxygen comments (Philippe Pillot)
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Oct 2006 16:11:24 +0000 (16:11 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Oct 2006 16:11:24 +0000 (16:11 +0000)
13 files changed:
MUON/AliMUONEventRecoCombi.cxx
MUON/AliMUONEventRecoCombi.h
MUON/AliMUONReconstructor.cxx
MUON/AliMUONTrack.cxx
MUON/AliMUONTrack.h
MUON/AliMUONTrackK.cxx
MUON/AliMUONTrackK.h
MUON/AliMUONTrackParam.cxx
MUON/AliMUONTrackParam.h
MUON/AliMUONTrackReconstructor.cxx
MUON/AliMUONTrackReconstructor.h
MUON/MUONrecLinkDef.h
MUON/libMUONrec.pkg

index b6b0619..9ebc40d 100644 (file)
@@ -29,7 +29,7 @@
 #include "AliMUONHitForRec.h"
 #include "AliMUONRawCluster.h"
 #include "AliMUONTrackK.h"
-#include "AliMUONTrackReconstructor.h"
+#include "AliMUONTrackReconstructorK.h"
 #include "AliMUONConstants.h"
 
 #include "AliLoader.h"
@@ -170,7 +170,7 @@ void AliMUONEventRecoCombi::FillEvent(AliMUONData *data, AliMUONClusterFinderAZ
 }
 
 //_________________________________________________________________________
-void AliMUONEventRecoCombi::FillRecP(AliMUONData *dataCluster, AliMUONTrackReconstructor *recoTrack) const
+void AliMUONEventRecoCombi::FillRecP(AliMUONData *dataCluster, AliMUONTrackReconstructorK *recoTrack) const
 {
   // Fill rec. points used for tracking from det. elems
 
index 875a104..569b111 100644 (file)
@@ -15,7 +15,7 @@
 
 class AliMUONData;
 class AliMUONDetElement;
-class AliMUONTrackReconstructor;
+class AliMUONTrackReconstructorK;
 class AliMUONClusterFinderAZ;
 class AliMUONHitForRec;
 class AliLoader;
@@ -26,7 +26,7 @@ class AliMUONEventRecoCombi : public TObject
     virtual ~AliMUONEventRecoCombi();
     static AliMUONEventRecoCombi* Instance();
     void FillEvent(AliMUONData *data, AliMUONClusterFinderAZ *recModel); // fill event info
-    void FillRecP(AliMUONData *dataCluster, AliMUONTrackReconstructor *recoTrack) const; // fill used rec. points from det. elems
+    void FillRecP(AliMUONData *dataCluster, AliMUONTrackReconstructorK *recoTrack) const; // fill used rec. points from det. elems
 
     Int_t Nz() const { return fNZ; } // number of DE different Z-positions
     Double_t Z(Int_t iz) const { return (*fZ)[iz]; } // Z of DE
index 772fd50..626d811 100644 (file)
@@ -36,7 +36,9 @@
 #include "AliMUONDigitMaker.h"
 #include "AliMUONTrack.h"
 #include "AliMUONTrackParam.h"
+#include "AliMUONVTrackReconstructor.h"
 #include "AliMUONTrackReconstructor.h"
+#include "AliMUONTrackReconstructorK.h"
 #include "AliMUONTriggerTrack.h"
 #include "AliMUONTriggerCircuitNew.h"
 #include "AliMUONTriggerCrateStore.h"
@@ -148,16 +150,13 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
   AliMUONData* data = new AliMUONData(loader,"MUON","MUON");
 
 // passing loader as argument.
-  AliMUONTrackReconstructor* recoEvent = new AliMUONTrackReconstructor(data);
+  AliMUONVTrackReconstructor* recoEvent;
+  if (strstr(GetOption(),"Original")) recoEvent = new AliMUONTrackReconstructor(data);
+  else if (strstr(GetOption(),"Combi")) recoEvent = new AliMUONTrackReconstructorK(data,"Combi");
+  else recoEvent = new AliMUONTrackReconstructorK(data,"Kalman");
+  
   recoEvent->SetTriggerCircuit(fTriggerCircuit);
 
-  if (strstr(GetOption(),"Original")) 
-    recoEvent->SetTrackMethod(kOriginal); // Original tracking
-  else if (strstr(GetOption(),"Combi")) 
-    recoEvent->SetTrackMethod(kCombi); // Combined cluster / track
-  else
-    recoEvent->SetTrackMethod(kKalman); // Kalman
-
   AliMUONClusterReconstructor* recoCluster = new AliMUONClusterReconstructor(data);
   
   AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
@@ -174,7 +173,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
   
   TTask* calibration = GetCalibrationTask(data);
   
-  Int_t chBeg = (recoEvent->GetTrackMethod() == kCombi ? 6 : 0); 
+  Int_t chBeg = (strstr(GetOption(),"Combi") ? 6 : 0);
 
   //   Loop over events              
   for(Int_t ievent = 0; ievent < nEvents; ievent++) {
@@ -187,7 +186,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
     if (!loader->TreeR()) loader->MakeRecPointsContainer();
      
     // tracking branch
-    if (recoEvent->GetTrackMethod() != kCombi) {
+    if (!strstr(GetOption(),"Combi")) {
       data->MakeBranch("RC");
       data->SetTreeAddress("D,RC");
     } else {
@@ -207,7 +206,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
     
     recoCluster->Digits2Clusters(chBeg); 
     
-    if (recoEvent->GetTrackMethod() == kCombi) {
+    if (strstr(GetOption(),"Combi")) {
       // Combined cluster / track finder
       AliMUONEventRecoCombi::Instance()->FillEvent(data, (AliMUONClusterFinderAZ*)recModel);
       ((AliMUONClusterFinderAZ*) recModel)->SetReco(2); 
@@ -239,12 +238,12 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
 
     loader->WriteTracks("OVERWRITE"); 
   
-    if (recoEvent->GetTrackMethod() == kCombi) { 
+    if (strstr(GetOption(),"Combi")) { 
       // Combined cluster / track
       ((AliMUONClusterFinderAZ*) recModel)->SetReco(1);
       data->MakeBranch("RC");
       data->SetTreeAddress("RC");
-      AliMUONEventRecoCombi::Instance()->FillRecP(data, recoEvent); 
+      AliMUONEventRecoCombi::Instance()->FillRecP(data, (AliMUONTrackReconstructorK*)recoEvent); 
       data->Fill("RC"); 
     }
     loader->WriteRecPoints("OVERWRITE"); 
@@ -278,22 +277,17 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
   AliMUONData data(loader,"MUON","MUON");
 
   // passing loader as argument.
-  AliMUONTrackReconstructor recoEvent(&data);
-  recoEvent.SetTriggerCircuit(fTriggerCircuit);
-
   fDigitMaker->SetMUONData(&data);
 
   AliMUONClusterReconstructor recoCluster(&data);
 
-  if (strstr(GetOption(),"Original")) 
-  {
-    recoEvent.SetTrackMethod(kOriginal); // Original tracking
-  }
-  else
-  {
-    recoEvent.SetTrackMethod(kKalman);
-  }
+  AliMUONVTrackReconstructor *recoEvent;
+  if (strstr(GetOption(),"Original")) recoEvent = new AliMUONTrackReconstructor(&data);
+  else if (strstr(GetOption(),"Combi")) recoEvent = new AliMUONTrackReconstructorK(&data,"Combi");
+  else recoEvent = new AliMUONTrackReconstructorK(&data,"Kalman");
   
+  recoEvent->SetTriggerCircuit(fTriggerCircuit);
+
   AliMUONClusterFinderVS *recModel = recoCluster.GetRecoModel();
   if (!strstr(GetOption(),"VS")) 
   {
@@ -377,13 +371,13 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
     // trigger branch
     data.MakeBranch("RL"); //trigger track
     data.SetTreeAddress("RL");
-    recoEvent.EventReconstructTrigger();
+    recoEvent->EventReconstructTrigger();
     data.Fill("RL");
 
     // tracking branch
     data.MakeBranch("RT"); //track
     data.SetTreeAddress("RT");
-    recoEvent.EventReconstruct();
+    recoEvent->EventReconstruct();
     data.Fill("RT");
 
     loader->WriteTracks("OVERWRITE");  
@@ -403,6 +397,8 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
   loader->UnloadRecPoints();
   loader->UnloadTracks();
   loader->UnloadDigits();
+  
+  delete recoEvent;
 
   AliInfo(Form("Execution time for converting RAW data to digits in MUON : R:%.2fs C:%.2fs",
                rawTimer.RealTime(),rawTimer.CpuTime()));
index 510c15e..8b1fc0b 100644 (file)
 //
 ///////////////////////////////////////////////////
 
+#include <stdlib.h> // for exit()
+#include <Riostream.h>
+
 #include "AliMUONTrack.h"
 
 #include "AliMUONTrackParam.h" 
 #include "AliMUONHitForRec.h" 
 #include "AliMUONSegment.h" 
-#include "AliMUONTriggerTrack.h"
 #include "AliMUONConstants.h"
 
 #include "AliLog.h"
 
-#include <Riostream.h> // for cout
 #include <TMath.h>
-#include <TMatrixD.h>
-#include <TObjArray.h>
-
-#include <stdlib.h> // for exit()
 
 ClassImp(AliMUONTrack) // Class implementation in ROOT context
 
@@ -56,7 +53,7 @@ AliMUONTrack::AliMUONTrack()
     fChi2MatchTrigger(0.),
     fTrackID(0)
 {
-  // Default constructor
+  /// Default constructor
 }
 
   //__________________________________________________________________________
@@ -71,7 +68,7 @@ AliMUONTrack::AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegmen
     fChi2MatchTrigger(0.),
     fTrackID(0)
 {
-  // Constructor from two Segment's
+  /// Constructor from two Segment's
 
   fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
   fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
@@ -97,7 +94,7 @@ AliMUONTrack::AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec)
     fChi2MatchTrigger(0.),
     fTrackID(0)
 {
-  // Constructor from one Segment and one HitForRec
+  /// Constructor from one Segment and one HitForRec
 
   fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
   fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
@@ -111,7 +108,7 @@ AliMUONTrack::AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec)
   //__________________________________________________________________________
 AliMUONTrack::~AliMUONTrack()
 {
-  // Destructor
+  /// Destructor
   if (fTrackParamAtHit) {
     // delete the TClonesArray of pointers to TrackParam
     delete fTrackParamAtHit;
@@ -137,7 +134,7 @@ AliMUONTrack::AliMUONTrack (const AliMUONTrack& theMUONTrack)
     fChi2MatchTrigger(theMUONTrack.fChi2MatchTrigger),
     fTrackID(theMUONTrack.fTrackID)
 {
-  
+  ///copy constructor
   Int_t maxIndex = 0;
   
   // necessary to make a copy of the objects and not only the pointers in TClonesArray.
@@ -163,7 +160,7 @@ AliMUONTrack::AliMUONTrack (const AliMUONTrack& theMUONTrack)
   //__________________________________________________________________________
 AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& theMUONTrack)
 {
-
+  /// Asignment operator
   // check assignement to self
   if (this == &theMUONTrack)
     return *this;
@@ -209,22 +206,23 @@ AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& theMUONTrack)
   //__________________________________________________________________________
 void AliMUONTrack::AddTrackParamAtHit(AliMUONTrackParam *trackParam, AliMUONHitForRec *hitForRec) 
 {
-  // Add TrackParamAtHit if "trackParam" != NULL else create empty TrackParamAtHit
-  // Update link to HitForRec if "hitForRec" != NULL
+  /// Add TrackParamAtHit if "trackParam" != NULL else create empty TrackParamAtHit
+  /// Update link to HitForRec if "hitForRec" != NULL
   if (!fTrackParamAtHit) {
     fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);  
     fNTrackHits = 0;
   }
-  AliMUONTrackParam* TrackParamAtHit;
-  if (trackParam) TrackParamAtHit = new ((*fTrackParamAtHit)[fNTrackHits]) AliMUONTrackParam(*trackParam);
-  else TrackParamAtHit = new ((*fTrackParamAtHit)[fNTrackHits]) AliMUONTrackParam();
-  if (hitForRec) TrackParamAtHit->SetHitForRecPtr(hitForRec);
+  AliMUONTrackParam* trackParamAtHit;
+  if (trackParam) trackParamAtHit = new ((*fTrackParamAtHit)[fNTrackHits]) AliMUONTrackParam(*trackParam);
+  else trackParamAtHit = new ((*fTrackParamAtHit)[fNTrackHits]) AliMUONTrackParam();
+  if (hitForRec) trackParamAtHit->SetHitForRecPtr(hitForRec);
   fNTrackHits++;
 }
 
   //__________________________________________________________________________
 void AliMUONTrack::AddHitForRecAtHit(const AliMUONHitForRec *hitForRec) 
 {
+  /// Add hitForRec to the array of hitForRec at hit
   if (!fHitForRecAtHit)
     fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10); 
   
@@ -237,7 +235,7 @@ void AliMUONTrack::AddHitForRecAtHit(const AliMUONHitForRec *hitForRec)
   //__________________________________________________________________________
 Bool_t* AliMUONTrack::CompatibleTrack(AliMUONTrack * Track, Double_t Sigma2Cut) const
 {
-  // Return kTRUE/kFALSE for each chamber if hit is compatible or not 
+  /// Return kTRUE/kFALSE for each chamber if hit is compatible or not 
   TClonesArray *hitArray, *thisHitArray;
   AliMUONHitForRec *hit, *thisHit;
   Int_t chamberNumber;
@@ -276,9 +274,8 @@ Bool_t* AliMUONTrack::CompatibleTrack(AliMUONTrack * Track, Double_t Sigma2Cut)
   //__________________________________________________________________________
 Int_t AliMUONTrack::HitsInCommon(AliMUONTrack* Track) const
 {
-  // Returns the number of hits in common
-  // between the current track ("this")
-  // and the track pointed to by "Track".
+  /// Returns the number of hits in common between the current track ("this")
+  /// and the track pointed to by "Track".
   Int_t hitsInCommon = 0;
   AliMUONTrackParam *trackParamAtHit1, *trackParamAtHit2;
   // Loop over hits of first track
@@ -299,7 +296,7 @@ Int_t AliMUONTrack::HitsInCommon(AliMUONTrack* Track) const
   //__________________________________________________________________________
 void AliMUONTrack::RecursiveDump(void) const
 {
-  // Recursive dump of AliMUONTrack, i.e. with dump of TrackParamAtHit's and attached HitForRec's
+  /// Recursive dump of AliMUONTrack, i.e. with dump of TrackParamAtHit's and attached HitForRec's
   AliMUONTrackParam *trackParamAtHit;
   AliMUONHitForRec *hitForRec;
   cout << "Recursive dump of Track: " << this << endl;
@@ -321,10 +318,8 @@ void AliMUONTrack::RecursiveDump(void) const
 //_____________________________________________-
 void AliMUONTrack::Print(Option_t* opt) const
 {
-//
-  // Printing Track information 
-  // "full" option for printing all the information about the track
-  //
+  /// Printing Track information 
+  /// "full" option for printing all the information about the track
   TString sopt(opt);
   sopt.ToUpper();
  
index 007f7f4..be7f2c5 100644 (file)
@@ -32,31 +32,48 @@ class AliMUONTrack : public TObject
   AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegment); // Constructor from two Segment's
   AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec); // Constructor from one Segment and one HitForRec
 
+       /// return pointeur to track parameters at vertex
   AliMUONTrackParam*         GetTrackParamAtVertex(void) {return &fTrackParamAtVertex;}
+       /// set track parameters at vertex
   void                       SetTrackParamAtVertex(AliMUONTrackParam* TrackParam) {fTrackParamAtVertex = *TrackParam;}
 
+       /// return array of track parameters at hit
   TClonesArray*              GetTrackParamAtHit(void) const {return fTrackParamAtHit;}
+       /// reset array of track parameters at hit
   void                       ResetTrackParamAtHit(void) { fTrackParamAtHit->Delete(); }
+       /// add track parameters to the array of track parameters at hit
   void                       AddTrackParamAtHit(AliMUONTrackParam *trackParam, AliMUONHitForRec *hitForRec); 
   
+       /// return array of hitForRec at hit
   TClonesArray*              GetHitForRecAtHit(void) const {return fHitForRecAtHit;}
+       /// reset array of hitForRec at hit
   void                       ResetHitForRecAtHit(void) { fHitForRecAtHit->Delete(); }
   void                       AddHitForRecAtHit(const AliMUONHitForRec *hitForRec); 
 
+       /// return the number of hits attached to the track
   Int_t                      GetNTrackHits(void) const {return fNTrackHits;}
+       /// set the number of hits attached to the track
   void                       SetNTrackHits(Int_t nTrackHits) {fNTrackHits = nTrackHits;}
 
+       /// return the minimum value of the function minimized by the fit
   Double_t                   GetFitFMin(void) const {return fFitFMin;}
+       /// set the minimum value of the function minimized by the fit
   void                       SetFitFMin(Double_t chi2) { fFitFMin = chi2; } // set Chi2
+       /// return kTrue if track matches with trigger track, kFalse if not
   Bool_t                     GetMatchTrigger(void) const {return fMatchTrigger;}
+       /// set the flag telling whether track matches with trigger track or not
   void                      SetMatchTrigger(Bool_t MatchTrigger) {fMatchTrigger = MatchTrigger;}
+       /// return the chi2 of trigger/track matching 
   Double_t                   GetChi2MatchTrigger(void) const {return fChi2MatchTrigger;}
+       /// set the chi2 of trigger/track matching 
   void                       SetChi2MatchTrigger(Double_t Chi2MatchTrigger) {fChi2MatchTrigger = Chi2MatchTrigger;}
   
   Int_t                      HitsInCommon(AliMUONTrack* Track) const;
   Bool_t*                    CompatibleTrack(AliMUONTrack* Track, Double_t Sigma2Cut) const; // return array of compatible chamber
   
+       /// return track number in TrackRefs
   Int_t                      GetTrackID() const {return fTrackID;}
+       /// set track number in TrackRefs
   void                       SetTrackID(Int_t trackID) {fTrackID = trackID;}
 
   void                       RecursiveDump(void) const; // Recursive dump (with track hits)
@@ -68,7 +85,7 @@ class AliMUONTrack : public TObject
   AliMUONTrackParam fTrackParamAtVertex; ///< Track parameters at vertex
   TClonesArray *fTrackParamAtHit; ///< Track parameters at hit
   TClonesArray *fHitForRecAtHit; ///< Cluster parameters at hit
-  Int_t fNTrackHits; ///< Number of TrackHit's
+  Int_t fNTrackHits; ///< Number of hits attached to the track
   
   Double_t fFitFMin; ///< minimum value of the function minimized by the fit
   Bool_t fMatchTrigger; ///< 1 if track matches with trigger track, 0 if not
index 305a0da..328d2cc 100644 (file)
@@ -29,8 +29,9 @@
 
 #include "AliMUONTrackK.h"
 #include "AliMUON.h"
+#include "AliMUONConstants.h"
 
-#include "AliMUONTrackReconstructor.h"
+#include "AliMUONTrackReconstructorK.h"
 #include "AliMagF.h"
 #include "AliMUONSegment.h"
 #include "AliMUONHitForRec.h"
@@ -51,7 +52,7 @@ void mnvertLocal(Double_t* a, Int_t l, Int_t m, Int_t n, Int_t& ifail); // from
 
   Int_t AliMUONTrackK::fgDebug = -1; //-1;
 Int_t AliMUONTrackK::fgNOfPoints = 0; 
-AliMUONTrackReconstructor* AliMUONTrackK::fgTrackReconstructor = NULL; 
+AliMUONTrackReconstructorK* AliMUONTrackK::fgTrackReconstructor = NULL; 
 TClonesArray* AliMUONTrackK::fgHitForRec = NULL; 
 AliMUONEventRecoCombi *AliMUONTrackK::fgCombi = NULL;
 
@@ -95,7 +96,7 @@ AliMUONTrackK::AliMUONTrackK()
 }
 
   //__________________________________________________________________________
-AliMUONTrackK::AliMUONTrackK(AliMUONTrackReconstructor *TrackReconstructor, TClonesArray *hitForRec)
+AliMUONTrackK::AliMUONTrackK(AliMUONTrackReconstructorK *TrackReconstructor, TClonesArray *hitForRec)
   : AliMUONTrack(),
     fStartSegment(0x0),
     fPosition(0.),
index 00a9f74..9e94728 100644 (file)
@@ -21,7 +21,7 @@ class TObjArray;
 class AliMUONEventRecoCombi;
 class AliMUONHitForRec;
 class AliMUONSegment;
-class AliMUONTrackReconstructor;
+class AliMUONTrackReconstructorK;
 #include "AliMUONTrack.h" 
 
 class AliMUONTrackK : public AliMUONTrack {
@@ -31,7 +31,7 @@ class AliMUONTrackK : public AliMUONTrack {
   AliMUONTrackK(); // Default constructor
   virtual ~AliMUONTrackK(); // Destructor
 
-  AliMUONTrackK(AliMUONTrackReconstructor *TrackReconstructor, TClonesArray *hitForRec); // Constructor
+  AliMUONTrackK(AliMUONTrackReconstructorK *TrackReconstructor, TClonesArray *hitForRec); // Constructor
   AliMUONTrackK(AliMUONSegment *segment); // Constructor from a segment
 
   // Pointer to hits on track
@@ -82,7 +82,7 @@ class AliMUONTrackK : public AliMUONTrack {
   static Int_t fgDebug; ///< debug level
   static Int_t fgNOfPoints; ///< number of points in event
   //static AliMUON *fgMUON; ///< pointer to MUON module  
-  static AliMUONTrackReconstructor *fgTrackReconstructor; ///< pointer to event reconstructor
+  static AliMUONTrackReconstructorK *fgTrackReconstructor; ///< pointer to event reconstructor
   static TClonesArray *fgHitForRec; ///< pointer to hits
   static AliMUONEventRecoCombi *fgCombi; ///< pointer to combined cluster/track finder
 
index 156fd69..922149a 100644 (file)
@@ -49,10 +49,10 @@ AliMUONTrackParam::AliMUONTrackParam()
     fkField(0x0),
     fHitForRecPtr(0x0)
 {
-// Constructor
+/// Constructor
   // get field from outside
   fkField = AliTracker::GetFieldMap();
-  if (!fkField) AliWarning("No field available");
+  if (!fkField) AliFatal("No field available");
 }
 
   //_________________________________________________________________________
@@ -67,14 +67,13 @@ AliMUONTrackParam::AliMUONTrackParam(const AliMUONTrackParam& theMUONTrackParam)
     fkField(theMUONTrackParam.fkField),
     fHitForRecPtr(theMUONTrackParam.fHitForRecPtr)
 {
-  // Copy constructor
-
+  /// Copy constructor
 }
 
   //_________________________________________________________________________
 AliMUONTrackParam& AliMUONTrackParam::operator=(const AliMUONTrackParam& theMUONTrackParam)
 {
-  // Asignment operator
+  /// Asignment operator
   if (this == &theMUONTrackParam)
     return *this;
 
@@ -137,7 +136,7 @@ Int_t AliMUONTrackParam::Compare(const TObject* TrackParam) const
   //_________________________________________________________________________
 void AliMUONTrackParam::GetParamFrom(const AliESDMuonTrack& esdMuonTrack)
 {
-  // assigned value form ESD track.
+  /// assigned value form ESD track.
   fInverseBendingMomentum =  esdMuonTrack.GetInverseBendingMomentum();
   fBendingSlope           =  TMath::Tan(esdMuonTrack.GetThetaY());
   fNonBendingSlope        =  TMath::Tan(esdMuonTrack.GetThetaX());
@@ -149,7 +148,7 @@ void AliMUONTrackParam::GetParamFrom(const AliESDMuonTrack& esdMuonTrack)
   //_________________________________________________________________________
 void AliMUONTrackParam::SetParamFor(AliESDMuonTrack& esdMuonTrack)
 {
-  // assigned value form ESD track.
+  /// assigned value form ESD track.
   esdMuonTrack.SetInverseBendingMomentum(fInverseBendingMomentum);
   esdMuonTrack.SetThetaX(TMath::ATan(fNonBendingSlope));
   esdMuonTrack.SetThetaY(TMath::ATan(fBendingSlope));
@@ -161,9 +160,9 @@ void AliMUONTrackParam::SetParamFor(AliESDMuonTrack& esdMuonTrack)
   //__________________________________________________________________________
 void AliMUONTrackParam::ExtrapToZ(Double_t Z)
 {
-  // Track parameter extrapolation to the plane at "Z".
-  // On return, the track parameters resulting from the extrapolation
-  // replace the current track parameters.
+  /// Track parameter extrapolation to the plane at "Z".
+  /// On return, the track parameters resulting from the extrapolation
+  /// replace the current track parameters.
   if (this->fZ == Z) return; // nothing to be done if same Z
   Double_t forwardBackward; // +1 if forward, -1 if backward
   if (Z < this->fZ) forwardBackward = 1.0; // spectro. z<0 
@@ -226,10 +225,10 @@ void AliMUONTrackParam::ExtrapToZ(Double_t Z)
   //__________________________________________________________________________
 void AliMUONTrackParam::SetGeant3Parameters(Double_t *VGeant3, Double_t ForwardBackward)
 {
-  // Set vector of Geant3 parameters pointed to by "VGeant3"
-  // from track parameters in current AliMUONTrackParam.
-  // Since AliMUONTrackParam is only geometry, one uses "ForwardBackward"
-  // to know whether the particle is going forward (+1) or backward (-1).
+  /// Set vector of Geant3 parameters pointed to by "VGeant3"
+  /// from track parameters in current AliMUONTrackParam.
+  /// Since AliMUONTrackParam is only geometry, one uses "ForwardBackward"
+  /// to know whether the particle is going forward (+1) or backward (-1).
   VGeant3[0] = this->fNonBendingCoor; // X
   VGeant3[1] = this->fBendingCoor; // Y
   VGeant3[2] = this->fZ; // Z
@@ -247,10 +246,10 @@ void AliMUONTrackParam::SetGeant3Parameters(Double_t *VGeant3, Double_t ForwardB
   //__________________________________________________________________________
 void AliMUONTrackParam::GetFromGeant3Parameters(Double_t *VGeant3, Double_t Charge)
 {
-  // Get track parameters in current AliMUONTrackParam
-  // from Geant3 parameters pointed to by "VGeant3",
-  // assumed to be calculated for forward motion in Z.
-  // "InverseBendingMomentum" is signed with "Charge".
+  /// Get track parameters in current AliMUONTrackParam
+  /// from Geant3 parameters pointed to by "VGeant3",
+  /// assumed to be calculated for forward motion in Z.
+  /// "InverseBendingMomentum" is signed with "Charge".
   this->fNonBendingCoor = VGeant3[0]; // X
   this->fBendingCoor = VGeant3[1]; // Y
   this->fZ = VGeant3[2]; // Z
@@ -263,10 +262,10 @@ void AliMUONTrackParam::GetFromGeant3Parameters(Double_t *VGeant3, Double_t Char
   //__________________________________________________________________________
 void AliMUONTrackParam::ExtrapToStation(Int_t Station, AliMUONTrackParam *TrackParam)
 {
-  // Track parameters extrapolated from current track parameters ("this")
-  // to both chambers of the station(0..) "Station"
-  // are returned in the array (dimension 2) of track parameters
-  // pointed to by "TrackParam" (index 0 and 1 for first and second chambers).
+  /// Track parameters extrapolated from current track parameters ("this")
+  /// to both chambers of the station(0..) "Station"
+  /// are returned in the array (dimension 2) of track parameters
+  /// pointed to by "TrackParam" (index 0 and 1 for first and second chambers).
   Double_t extZ[2], z1, z2;
   Int_t i1 = -1, i2 = -1; // = -1 to avoid compilation warnings
   // range of Station to be checked ????
@@ -296,10 +295,9 @@ void AliMUONTrackParam::ExtrapToStation(Int_t Station, AliMUONTrackParam *TrackP
   //__________________________________________________________________________
 void AliMUONTrackParam::ExtrapToVertex(Double_t xVtx, Double_t yVtx, Double_t zVtx)
 {
-  // Extrapolation to the vertex.
-  // Returns the track parameters resulting from the extrapolation,
-  // in the current TrackParam.
-  // Changes parameters according to Branson correction through the absorber 
+  /// Extrapolation to the vertex.
+  /// Returns the track parameters resulting from the extrapolation in the current TrackParam.
+  /// Changes parameters according to Branson correction through the absorber 
   
   Double_t zAbsorber = -503.0; // to be coherent with the Geant absorber geometry !!!!
                                // spectro. (z<0) 
@@ -421,7 +419,7 @@ void AliMUONTrackParam::ExtrapToVertex(Double_t xVtx, Double_t yVtx, Double_t zV
 
 void AliMUONTrackParam::BransonCorrection(Double_t xVtx,Double_t yVtx,Double_t zVtx)
 {
-  // Branson correction of track parameters
+  /// Branson correction of track parameters
   // the entry parameters have to be calculated at the end of the absorber
   // simplified version: the z positions of Branson's planes are no longer calculated
   // but are given as inputs. One can use the macros MUONTestAbso.C and DrawTestAbso.C
@@ -429,7 +427,7 @@ void AliMUONTrackParam::BransonCorrection(Double_t xVtx,Double_t yVtx,Double_t z
   // Would it be possible to calculate all that from Geant configuration ????
   // and to get the Branson parameters from a function in ABSO module ????
   // with an eventual contribution from other detectors like START ????
-  //change to take into account the vertex postition (real, reconstruct,....)
+  // change to take into account the vertex postition (real, reconstruct,....)
 
   Double_t  zBP, xBP, yBP;
   Double_t  pYZ, pX, pY, pZ, pTotal, xEndAbsorber, yEndAbsorber, radiusEndAbsorber2, pT, theta;
@@ -501,7 +499,7 @@ void AliMUONTrackParam::BransonCorrection(Double_t xVtx,Double_t yVtx,Double_t z
   //__________________________________________________________________________
 Double_t AliMUONTrackParam::TotalMomentumEnergyLoss(Double_t thetaLimit, Double_t pTotal, Double_t theta)
 {
-  // Returns the total momentum corrected from energy loss in the front absorber
+  /// Returns the total momentum corrected from energy loss in the front absorber
   // One can use the macros MUONTestAbso.C and DrawTestAbso.C
   // to test this correction. 
   // Momentum energy loss behaviour evaluated with the simulation of single muons (april 2002)
@@ -532,10 +530,8 @@ Double_t AliMUONTrackParam::TotalMomentumEnergyLoss(Double_t thetaLimit, Double_
   //__________________________________________________________________________
 void AliMUONTrackParam::FieldCorrection(Double_t Z)
 {
-  // 
-  // Correction of the effect of the magnetic field in the absorber
+  /// Correction of the effect of the magnetic field in the absorber
   // Assume a constant field along Z axis.
-
   Float_t b[3],x[3]; 
   Double_t bZ;
   Double_t pYZ,pX,pY,pZ,pT;
@@ -575,7 +571,7 @@ void AliMUONTrackParam::FieldCorrection(Double_t Z)
   //__________________________________________________________________________
 Double_t AliMUONTrackParam::Px() const
 {
-  // return px from track paramaters
+  /// return px from track paramaters
   Double_t pYZ, pZ, pX;
   pYZ = 0;
   if (  TMath::Abs(fInverseBendingMomentum) > 0 )
@@ -587,7 +583,7 @@ Double_t AliMUONTrackParam::Px() const
   //__________________________________________________________________________
 Double_t AliMUONTrackParam::Py() const
 {
-  // return px from track paramaters
+  /// return px from track paramaters
   Double_t pYZ, pZ, pY;
   pYZ = 0;
   if (  TMath::Abs(fInverseBendingMomentum) > 0 )
@@ -599,7 +595,7 @@ Double_t AliMUONTrackParam::Py() const
   //__________________________________________________________________________
 Double_t AliMUONTrackParam::Pz() const
 {
-  // return px from track paramaters
+  /// return px from track paramaters
   Double_t pYZ, pZ;
   pYZ = 0;
   if (  TMath::Abs(fInverseBendingMomentum) > 0 )
@@ -610,7 +606,7 @@ Double_t AliMUONTrackParam::Pz() const
   //__________________________________________________________________________
 Double_t AliMUONTrackParam::P() const
 {
-  // return p from track paramaters
+  /// return p from track paramaters
   Double_t  pYZ, pZ, p;
   pYZ = 0;
   if (  TMath::Abs(fInverseBendingMomentum) > 0 )
@@ -625,26 +621,25 @@ Double_t AliMUONTrackParam::P() const
 void AliMUONTrackParam::ExtrapOneStepHelix(Double_t charge, Double_t step, 
                                         Double_t *vect, Double_t *vout) const
 {
-//    ******************************************************************
-//    *                                                                *
-//    *  Performs the tracking of one step in a magnetic field         *
-//    *  The trajectory is assumed to be a helix in a constant field   *
-//    *  taken at the mid point of the step.                           *
-//    *  Parameters:                                                   *
-//    *   input                                                        *
-//    *     STEP =arc length of the step asked                         *
-//    *     VECT =input vector (position,direction cos and momentum)   *
-//    *     CHARGE=  electric charge of the particle                   *
-//    *   output                                                       *
-//    *     VOUT = same as VECT after completion of the step           *
-//    *                                                                *
-//    *    ==>Called by : <USER>, GUSWIM                               *
-//    *       Author    m.hansroul  *********                          *
-//    *       modified  s.egli, s.v.levonian                           *
-//    *       modified  v.perevoztchikov
-//    *                                                                *
-//    ******************************************************************
-//
+///    ******************************************************************
+///    *                                                                *
+///    *  Performs the tracking of one step in a magnetic field         *
+///    *  The trajectory is assumed to be a helix in a constant field   *
+///    *  taken at the mid point of the step.                           *
+///    *  Parameters:                                                   *
+///    *   input                                                        *
+///    *     STEP =arc length of the step asked                         *
+///    *     VECT =input vector (position,direction cos and momentum)   *
+///    *     CHARGE=  electric charge of the particle                   *
+///    *   output                                                       *
+///    *     VOUT = same as VECT after completion of the step           *
+///    *                                                                *
+///    *    ==>Called by : <USER>, GUSWIM                               *
+///    *       Author    m.hansroul  *********                          *
+///    *       modified  s.egli, s.v.levonian                           *
+///    *       modified  v.perevoztchikov
+///    *                                                                *
+///    ******************************************************************
 
 // modif: everything in double precision
 
@@ -744,20 +739,18 @@ void AliMUONTrackParam::ExtrapOneStepHelix(Double_t charge, Double_t step,
 void AliMUONTrackParam::ExtrapOneStepHelix3(Double_t field, Double_t step, 
                                               Double_t *vect, Double_t *vout) const
 {
-// 
-//     ******************************************************************
-//     *                                                                *
-//     *       Tracking routine in a constant field oriented            *
-//     *       along axis 3                                             *
-//     *       Tracking is performed with a conventional                *
-//     *       helix step method                                        *
-//     *                                                                *
-//     *    ==>Called by : <USER>, GUSWIM                               *
-//     *       Authors    R.Brun, M.Hansroul  *********                 *
-//     *       Rewritten  V.Perevoztchikov
-//     *                                                                *
-//     ******************************************************************
-// 
+///    ******************************************************************
+///    *                                                                *
+///    *       Tracking routine in a constant field oriented            *
+///    *       along axis 3                                             *
+///    *       Tracking is performed with a conventional                *
+///    *       helix step method                                        *
+///    *                                                                *
+///    *    ==>Called by : <USER>, GUSWIM                               *
+///    *       Authors    R.Brun, M.Hansroul  *********                 *
+///    *       Rewritten  V.Perevoztchikov
+///    *                                                                *
+///    ******************************************************************
 
     Double_t hxp[3];
     Double_t h4, hp, rho, tet;
@@ -822,29 +815,27 @@ void AliMUONTrackParam::ExtrapOneStepHelix3(Double_t field, Double_t step,
 void AliMUONTrackParam::ExtrapOneStepRungekutta(Double_t charge, Double_t step, 
                                                     Double_t* vect, Double_t* vout) const
 {
-// 
-//     ******************************************************************
-//     *                                                                *
-//     *  Runge-Kutta method for tracking a particle through a magnetic *
-//     *  field. Uses Nystroem algorithm (See Handbook Nat. Bur. of     *
-//     *  Standards, procedure 25.5.20)                                 *
-//     *                                                                *
-//     *  Input parameters                                              *
-//     *       CHARGE    Particle charge                                *
-//     *       STEP      Step size                                      *
-//     *       VECT      Initial co-ords,direction cosines,momentum     *
-//     *  Output parameters                                             *
-//     *       VOUT      Output co-ords,direction cosines,momentum      *
-//     *  User routine called                                           *
-//     *       CALL GUFLD(X,F)                                          *
-//     *                                                                *
-//     *    ==>Called by : <USER>, GUSWIM                               *
-//     *       Authors    R.Brun, M.Hansroul  *********                 *
-//     *                  V.Perevoztchikov (CUT STEP implementation)    *
-//     *                                                                *
-//     *                                                                *
-//     ******************************************************************
-// 
+///    ******************************************************************
+///    *                                                                *
+///    *  Runge-Kutta method for tracking a particle through a magnetic *
+///    *  field. Uses Nystroem algorithm (See Handbook Nat. Bur. of     *
+///    *  Standards, procedure 25.5.20)                                 *
+///    *                                                                *
+///    *  Input parameters                                              *
+///    *       CHARGE    Particle charge                                *
+///    *       STEP      Step size                                      *
+///    *       VECT      Initial co-ords,direction cosines,momentum     *
+///    *  Output parameters                                             *
+///    *       VOUT      Output co-ords,direction cosines,momentum      *
+///    *  User routine called                                           *
+///    *       CALL GUFLD(X,F)                                          *
+///    *                                                                *
+///    *    ==>Called by : <USER>, GUSWIM                               *
+///    *       Authors    R.Brun, M.Hansroul  *********                 *
+///    *                  V.Perevoztchikov (CUT STEP implementation)    *
+///    *                                                                *
+///    *                                                                *
+///    ******************************************************************
 
     Double_t h2, h4, f[4];
     Double_t xyzt[3], a, b, c, ph,ph2;
@@ -1067,8 +1058,7 @@ void AliMUONTrackParam::ExtrapOneStepRungekutta(Double_t charge, Double_t step,
 //___________________________________________________________
  void  AliMUONTrackParam::GetField(Double_t *Position, Double_t *Field) const
 {
-    // interface for arguments in double precision (Why ? ChF)
-
+    /// interface for arguments in double precision (Why ? ChF)
     Float_t x[3], b[3];
 
     x[0] = Position[0]; x[1] = Position[1]; x[2] = Position[2];
@@ -1081,10 +1071,8 @@ void AliMUONTrackParam::ExtrapOneStepRungekutta(Double_t charge, Double_t step,
 //_____________________________________________-
 void AliMUONTrackParam::Print(Option_t* opt) const
 {
-//
-  // Printing TrackParam information 
-  // "full" option for printing all the information about the TrackParam
-  //
+  /// Printing TrackParam information 
+  /// "full" option for printing all the information about the TrackParam
   TString sopt(opt);
   sopt.ToUpper();
  
index 4210654..6601aed 100644 (file)
@@ -34,20 +34,33 @@ class AliMUONTrackParam : public TObject
 
 
   // Get and Set methods for data
+       /// return inverse bending momentum (GeV/c ** -1) times the charge (assumed forward motion)
   Double_t GetInverseBendingMomentum(void) const {return fInverseBendingMomentum;}
+       /// set inverse bending momentum (GeV/c ** -1) times the charge (assumed forward motion)
   void     SetInverseBendingMomentum(Double_t InverseBendingMomentum) {fInverseBendingMomentum = InverseBendingMomentum;}
+       /// return bending slope (cm ** -1)
   Double_t GetBendingSlope(void) const {return fBendingSlope;}
+       /// set bending slope (cm ** -1)
   void     SetBendingSlope(Double_t BendingSlope) {fBendingSlope = BendingSlope;}
+       /// return non bending slope (cm ** -1)
   Double_t GetNonBendingSlope(void) const {return fNonBendingSlope;}
+       /// set non bending slope (cm ** -1)
   void     SetNonBendingSlope(Double_t NonBendingSlope) {fNonBendingSlope = NonBendingSlope;}
+       /// return Z coordinate (cm)
   Double_t GetZ(void) const {return fZ;}
+       /// set Z coordinate (cm)
   void     SetZ(Double_t Z) {fZ = Z;}
+       /// return bending coordinate (cm)
   Double_t GetBendingCoor(void) const {return fBendingCoor;}
+       /// set bending coordinate (cm)
   void     SetBendingCoor(Double_t BendingCoor) {fBendingCoor = BendingCoor;}
+       /// return non bending coordinate (cm)
   Double_t GetNonBendingCoor(void) const {return fNonBendingCoor;}
+       /// set non bending coordinate (cm)
   void     SetNonBendingCoor(Double_t NonBendingCoor) {fNonBendingCoor = NonBendingCoor;}
   void              SetTrackParam(AliMUONTrackParam& TrackParam);
   AliMUONHitForRec* GetHitForRecPtr(void) const;
+       /// set pointeur to associated HitForRec if any
   void              SetHitForRecPtr(AliMUONHitForRec* HitForRec) {fHitForRecPtr = HitForRec;}
   
   Double_t Px() const;  // return px
@@ -55,8 +68,10 @@ class AliMUONTrackParam : public TObject
   Double_t Pz() const;  // return pz
   Double_t P()  const;  // return total momentum
 
-  Bool_t IsSortable () const {return kTRUE;} // necessary for sorting TClonesArray of TrackHit's
-  Int_t Compare(const TObject* TrackParam) const; // "Compare" function for sorting
+       /// necessary for sorting TClonesArray of TrackHit's
+  Bool_t IsSortable () const {return kTRUE;}
+       /// "Compare" function for sorting
+  Int_t Compare(const TObject* TrackParam) const;
 
   void ExtrapToZ(Double_t Z);
   void ExtrapToStation(Int_t Station, AliMUONTrackParam *TrackParam);
@@ -76,6 +91,7 @@ class AliMUONTrackParam : public TObject
   
   virtual void Print(Option_t* opt="") const;
  
+       /// set field map
   void SetField(const AliMagF* magField) {fkField = magField;}
 
 
index 7dfa61d..9e0f4c7 100644 (file)
 
 ////////////////////////////////////
 //
-// MUON track reconstructor in ALICE (class renamed from AliMUONEventReconstructor)
+// MUON track reconstructor using the original method
 //
 // This class contains as data:
 // * the parameters for the track reconstruction
-// * a pointer to the array of hits to be reconstructed (the event)
-// * a pointer to the array of segments made with these hits inside each station
-// * a pointer to the array of reconstructed tracks
 //
 // It contains as methods, among others:
-// * MakeEventToBeReconstructed to build the array of hits to be reconstructed
-// * MakeSegments to build the segments
 // * MakeTracks to build the tracks
 //
 ////////////////////////////////////
 
 #include <stdlib.h>
 #include <Riostream.h>
-#include <TDirectory.h>
-#include <TFile.h>
 #include <TMatrixD.h>
 
+#include "AliMUONVTrackReconstructor.h"
 #include "AliMUONTrackReconstructor.h"
 #include "AliMUONData.h"
 #include "AliMUONConstants.h"
-#include "AliMUONHitForRec.h"
-#include "AliMUONTriggerTrack.h"
-#include "AliMUONTriggerCircuitNew.h"
 #include "AliMUONRawCluster.h"
-#include "AliMUONLocalTrigger.h"
-#include "AliMUONGlobalTrigger.h"
+#include "AliMUONHitForRec.h"
 #include "AliMUONSegment.h"
 #include "AliMUONTrack.h"
-#include "AliMagF.h"
-#include "AliMUONTrackK.h" 
 #include "AliLog.h"
-#include "AliTracker.h"
 #include <TVirtualFitter.h>
 
-//************* Defaults parameters for reconstruction
-const Double_t AliMUONTrackReconstructor::fgkDefaultMinBendingMomentum = 3.0;
-const Double_t AliMUONTrackReconstructor::fgkDefaultMaxBendingMomentum = 3000.0;
-const Double_t AliMUONTrackReconstructor::fgkDefaultMaxChi2 = 100.0;
-const Double_t AliMUONTrackReconstructor::fgkDefaultMaxSigma2Distance = 16.0;
-const Double_t AliMUONTrackReconstructor::fgkDefaultBendingResolution = 0.01;
-const Double_t AliMUONTrackReconstructor::fgkDefaultNonBendingResolution = 0.144;
-// Simple magnetic field:
-// Value taken from macro MUONtracking.C: 0.7 T, hence 7 kG
-// Length and Position from reco_muon.F, with opposite sign:
-// Length = ZMAGEND-ZCOIL
-// Position = (ZMAGEND+ZCOIL)/2
-// to be ajusted differently from real magnetic field ????
-const Double_t AliMUONTrackReconstructor::fgkDefaultSimpleBValue = 7.0;
-const Double_t AliMUONTrackReconstructor::fgkDefaultSimpleBLength = 428.0;
-const Double_t AliMUONTrackReconstructor::fgkDefaultSimpleBPosition = 1019.0;
-const Double_t AliMUONTrackReconstructor::fgkDefaultEfficiency = 0.95;
-
-TVirtualFitter* AliMUONTrackReconstructor::fgFitter = NULL; 
-
 // Functions to be minimized with Minuit
 void TrackChi2(Int_t &NParam, Double_t *Gradient, Double_t &Chi2, Double_t *Param, Int_t Flag);
 void TrackChi2MCS(Int_t &NParam, Double_t *Gradient, Double_t &Chi2, Double_t *Param, Int_t Flag);
@@ -85,323 +52,48 @@ Double_t MultipleScatteringAngle2(AliMUONTrackParam *param);
 
 ClassImp(AliMUONTrackReconstructor) // Class implementation in ROOT context
 
+//************* Defaults parameters for reconstruction
+const Double_t AliMUONTrackReconstructor::fgkDefaultMaxChi2 = 100.0;
+
+TVirtualFitter* AliMUONTrackReconstructor::fgFitter = 0x0; 
+
 //__________________________________________________________________________
 AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliMUONData* data)
-  : TObject(),
-    fTrackMethod(1), //AZ - tracking method (1-default, 2-Kalman)
-    fMinBendingMomentum(fgkDefaultMinBendingMomentum),
-    fMaxBendingMomentum(fgkDefaultMaxBendingMomentum),
-    fMaxChi2(fgkDefaultMaxChi2),
-    fMaxSigma2Distance(fgkDefaultMaxSigma2Distance),
-    fRMin(0x0),
-    fRMax(0x0),
-    fSegmentMaxDistBending(0x0),
-    fSegmentMaxDistNonBending(0x0),
-    fBendingResolution(fgkDefaultBendingResolution),
-    fNonBendingResolution(fgkDefaultNonBendingResolution),
-    fChamberThicknessInX0(AliMUONConstants::DefaultChamberThicknessInX0()),
-    fSimpleBValue(fgkDefaultSimpleBValue),
-    fSimpleBLength(fgkDefaultSimpleBLength),
-    fSimpleBPosition(fgkDefaultSimpleBPosition),
-    fEfficiency(fgkDefaultEfficiency),
-    fHitsForRecPtr(0x0),
-    fNHitsForRec(0),
-    fNHitsForRecPerChamber(0x0),
-    fIndexOfFirstHitForRecPerChamber(0x0),
-    fSegmentsPtr(0x0),
-    fNSegments(0x0),
-    fRecTracksPtr(0x0),
-    fNRecTracks(0),
-    fMUONData(data),
-    fMuons(0),
-    fTriggerTrack(new AliMUONTriggerTrack()),
-    fTriggerCircuit(0x0)
+  : AliMUONVTrackReconstructor(data),
+    fMaxChi2(fgkDefaultMaxChi2)
 {
+  /// Constructor for class AliMUONTrackReconstructor
   
-  // Memory allocation
-  fRMin = new Double_t[AliMUONConstants::NTrackingCh()];
-  fRMax = new Double_t[AliMUONConstants::NTrackingCh()];
-  fSegmentMaxDistBending = new Double_t[AliMUONConstants::NTrackingSt()];
-  fSegmentMaxDistNonBending = new Double_t[AliMUONConstants::NTrackingSt()];
-  fNHitsForRecPerChamber = new Int_t[AliMUONConstants::NTrackingCh()];
-  fIndexOfFirstHitForRecPerChamber = new Int_t[AliMUONConstants::NTrackingCh()];
-  
-  // Constructor for class AliMUONTrackReconstructor
-  SetReconstructionParametersToDefaults();
-
-  // Memory allocation for the TClonesArray of hits for reconstruction
-  // Is 10000 the right size ????
-  fHitsForRecPtr = new TClonesArray("AliMUONHitForRec", 10000);
-
-  // Memory allocation for the TClonesArray's of segments in stations
-  // Is 2000 the right size ????
-  fSegmentsPtr = new TClonesArray*[AliMUONConstants::NTrackingSt()];
-  fNSegments = new Int_t[AliMUONConstants::NTrackingSt()];
-  for (Int_t st = 0; st < AliMUONConstants::NTrackingSt(); st++) {
-    fSegmentsPtr[st] = new TClonesArray("AliMUONSegment", 2000);
-    fNSegments[st] = 0; // really needed or GetEntriesFast sufficient ????
-  }
   // Memory allocation for the TClonesArray of reconstructed tracks
-  // Is 10 the right size ????
   fRecTracksPtr = new TClonesArray("AliMUONTrack", 10);
-
-  const AliMagF* kField = AliTracker::GetFieldMap();
-  if (!kField) AliFatal("No field available");
- // Sign of fSimpleBValue according to sign of Bx value at (50,50,-950).
-  Float_t b[3], x[3];
-  x[0] = 50.; x[1] = 50.; x[2] = -950.;
-  kField->Field(x,b);
-
-  fSimpleBValue    = TMath::Sign(fSimpleBValue,(Double_t) b[0]);
-  fSimpleBPosition = TMath::Sign(fSimpleBPosition,(Double_t) x[2]);
-  // See how to get fSimple(BValue, BLength, BPosition)
-  // automatically calculated from the actual magnetic field ????
-
-  return;
 }
 
   //__________________________________________________________________________
 AliMUONTrackReconstructor::~AliMUONTrackReconstructor(void)
 {
-  // Destructor for class AliMUONTrackReconstructor
-  delete [] fRMin;
-  delete [] fRMax;
-  delete [] fSegmentMaxDistBending;
-  delete [] fSegmentMaxDistNonBending;
-  delete [] fNHitsForRecPerChamber;
-  delete [] fIndexOfFirstHitForRecPerChamber;
-  delete fTriggerTrack;
-  delete fHitsForRecPtr;
-  // Correct destruction of everything ????
-  for (Int_t st = 0; st < AliMUONConstants::NTrackingSt(); st++) delete fSegmentsPtr[st];
-  delete [] fSegmentsPtr;
-  delete [] fNSegments;
+  /// Destructor for class AliMUONTrackReconstructor
   delete fRecTracksPtr;
 }
-  //__________________________________________________________________________
-void AliMUONTrackReconstructor::SetReconstructionParametersToDefaults(void)
-{
-  // Set reconstruction parameters to default values
-  // Would be much more convenient with a structure (or class) ????
-
-  // ******** Parameters for making HitsForRec
-  // minimum radius,
-  // like in TRACKF_STAT:
-  // 2 degrees for stations 1 and 2, or ch(0...) from 0 to 3;
-  // 30 cm for stations 3 to 5, or ch(0...) from 4 to 9
-  for (Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++) {
-    if (ch < 4) fRMin[ch] = TMath::Abs(AliMUONConstants::DefaultChamberZ(ch)) *
-                 2.0 * TMath::Pi() / 180.0;
-    else fRMin[ch] = 30.0;
-    // maximum radius at 10 degrees and Z of chamber
-    fRMax[ch] = TMath::Abs(AliMUONConstants::DefaultChamberZ(ch)) *
-                 10.0 * TMath::Pi() / 180.0;
-  }
-
-  // ******** Parameters for making segments
-  // should be parametrized ????
-  // according to interval between chambers in a station ????
-  // Maximum distance in non bending plane
-  // 5 * 0.22 just to remember the way it was made in TRACKF_STAT
-  // SIGCUT*DYMAX(IZ)
-  for (Int_t st = 0; st < AliMUONConstants::NTrackingCh()/2; st++)
-    fSegmentMaxDistNonBending[st] = 5. * 0.22;
-  // Maximum distance in bending plane:
-  // values from TRACKF_STAT, corresponding to (J psi 20cm),
-  // scaled to the real distance between chambers in a station
-  fSegmentMaxDistBending[0] = TMath::Abs( 1.5 *
-                                         (AliMUONConstants::DefaultChamberZ(1) - AliMUONConstants::DefaultChamberZ(0)) / 20.0);
-  fSegmentMaxDistBending[1] = TMath::Abs( 1.5 *
-                                         (AliMUONConstants::DefaultChamberZ(3) - AliMUONConstants::DefaultChamberZ(2)) / 20.0);
-  fSegmentMaxDistBending[2] = TMath::Abs( 3.0 *
-                                         (AliMUONConstants::DefaultChamberZ(5) - AliMUONConstants::DefaultChamberZ(4)) / 20.0);
-  fSegmentMaxDistBending[3] = TMath::Abs( 6.0 *
-                                         (AliMUONConstants::DefaultChamberZ(7) - AliMUONConstants::DefaultChamberZ(6)) / 20.0);
-  fSegmentMaxDistBending[4] = TMath::Abs( 6.0 *
-                                         (AliMUONConstants::DefaultChamberZ(9) - AliMUONConstants::DefaultChamberZ(8)) / 20.0);
-
-  return;
-}
-
-//__________________________________________________________________________
-Double_t AliMUONTrackReconstructor::GetImpactParamFromBendingMomentum(Double_t BendingMomentum) const
-{
-  // Returns impact parameter at vertex in bending plane (cm),
-  // from the signed bending momentum "BendingMomentum" in bending plane (GeV/c),
-  // using simple values for dipole magnetic field.
-  // The sign of "BendingMomentum" is the sign of the charge.
-  return (-0.0003 * fSimpleBValue * fSimpleBLength * fSimpleBPosition /
-         BendingMomentum);
-}
-
-//__________________________________________________________________________
-Double_t AliMUONTrackReconstructor::GetBendingMomentumFromImpactParam(Double_t ImpactParam) const
-{
-  // Returns signed bending momentum in bending plane (GeV/c),
-  // the sign being the sign of the charge for particles moving forward in Z,
-  // from the impact parameter "ImpactParam" at vertex in bending plane (cm),
-  // using simple values for dipole magnetic field.
-  return (-0.0003 * fSimpleBValue * fSimpleBLength * fSimpleBPosition /
-         ImpactParam);
-}
-
-//__________________________________________________________________________
-void AliMUONTrackReconstructor::EventReconstruct(void)
-{
-  // To reconstruct one event
-  AliDebug(1,"Enter EventReconstruct");
-  ResetTracks(); //AZ
-  ResetSegments(); //AZ
-  ResetHitsForRec(); //AZ
-  MakeEventToBeReconstructed();
-  MakeSegments();
-  MakeTracks();
-  if (fMUONData->IsTriggerTrackBranchesInTree()) 
-    ValidateTracksWithTrigger(); 
-  
-  // Add tracks to MUON data container 
-  for(Int_t i=0; i<fNRecTracks; i++) {
-    AliMUONTrack * track = (AliMUONTrack*) fRecTracksPtr->At(i);
-    fMUONData->AddRecTrack(*track);
-  }
-}
-
-//__________________________________________________________________________
-void AliMUONTrackReconstructor::EventReconstructTrigger(void)
-{
-  // To reconstruct one event
-  AliDebug(1,"Enter EventReconstructTrigger");
-  MakeTriggerTracks();  
-}
-
-  //__________________________________________________________________________
-void AliMUONTrackReconstructor::ResetHitsForRec(void)
-{
-  // To reset the array and the number of HitsForRec,
-  // and also the number of HitsForRec
-  // and the index of the first HitForRec per chamber
-  if (fHitsForRecPtr) fHitsForRecPtr->Delete();
-  fNHitsForRec = 0;
-  for (Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++)
-    fNHitsForRecPerChamber[ch] = fIndexOfFirstHitForRecPerChamber[ch] = 0;
-  return;
-}
-
-  //__________________________________________________________________________
-void AliMUONTrackReconstructor::ResetSegments(void)
-{
-  // To reset the TClonesArray of segments and the number of Segments
-  // for all stations
-  for (Int_t st = 0; st < AliMUONConstants::NTrackingCh()/2; st++) {
-    if (fSegmentsPtr[st]) fSegmentsPtr[st]->Clear();
-    fNSegments[st] = 0;
-  }
-  return;
-}
-
-  //__________________________________________________________________________
-void AliMUONTrackReconstructor::ResetTracks(void)
-{
-  // To reset the TClonesArray of reconstructed tracks
-  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 AliMUONTrackReconstructor::MakeEventToBeReconstructed(void)
+void AliMUONTrackReconstructor::AddHitsForRecFromRawClusters()
 {
-  // To make the list of hits to be reconstructed,
-  // either from the track ref. hits or from the raw clusters
-  // according to the parameter set for the reconstructor
-
-  AliDebug(1,"Enter MakeEventToBeReconstructed");
-  //AZ ResetHitsForRec();
-  // Reconstruction from raw clusters
-  // AliMUON *MUON  = (AliMUON*) gAlice->GetModule("MUON"); // necessary ????
-  // Security on MUON ????
-  // TreeR assumed to be be "prepared" in calling function
-  // by "MUON->GetTreeR(nev)" ????
-  TTree *treeR = fMUONData->TreeR();
-
-  //AZ? fMUONData->SetTreeAddress("RC");
-  AddHitsForRecFromRawClusters(treeR);
-  // No sorting: it is done automatically in the previous function
-  
-  AliDebug(1,"End of MakeEventToBeReconstructed");
-    if (AliLog::GetGlobalDebugLevel() > 0) {
-      AliDebug(1, Form("NHitsForRec: %d",fNHitsForRec));
-      for (Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++) {
-       AliDebug(1, Form("Chamber(0...): %d",ch));
-       AliDebug(1, Form("NHitsForRec: %d", fNHitsForRecPerChamber[ch]));
-       AliDebug(1, Form("Index(first HitForRec): %d", fIndexOfFirstHitForRecPerChamber[ch]));
-       for (Int_t hit = fIndexOfFirstHitForRecPerChamber[ch];
-            hit < fIndexOfFirstHitForRecPerChamber[ch] + fNHitsForRecPerChamber[ch];
-            hit++) {
-         AliDebug(1, Form("HitForRec index(0...): %d",hit));
-         ((*fHitsForRecPtr)[hit])->Dump();
-      }
-    }
-  }
-  return;
-}
-
-  //__________________________________________________________________________
-void AliMUONTrackReconstructor::SortHitsForRecWithIncreasingChamber()
-{
-  // Sort HitsForRec's in increasing order with respect to chamber number.
-  // Uses the function "Compare".
-  // Update the information for HitsForRec per chamber too.
-  Int_t ch, nhits, prevch;
-  fHitsForRecPtr->Sort();
-  for (ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++) {
-    fNHitsForRecPerChamber[ch] = 0;
-    fIndexOfFirstHitForRecPerChamber[ch] = 0;
-  }
-  prevch = 0; // previous chamber
-  nhits = 0; // number of hits in current chamber
-  // Loop over HitsForRec
-  for (Int_t hit = 0; hit < fNHitsForRec; hit++) {
-    // chamber number (0...)
-    ch = ((AliMUONHitForRec*)  ((*fHitsForRecPtr)[hit]))->GetChamberNumber();
-    // increment number of hits in current chamber
-    (fNHitsForRecPerChamber[ch])++;
-    // update index of first HitForRec in current chamber
-    // if chamber number different from previous one
-    if (ch != prevch) {
-      fIndexOfFirstHitForRecPerChamber[ch] = hit;
-      prevch = ch;
-    }
-  }
-  return;
-}
-
-  //__________________________________________________________________________
-void AliMUONTrackReconstructor::AddHitsForRecFromRawClusters(TTree* TR)
-{
-  // To add to the list of hits for reconstruction all the raw clusters
-  // No condition added, like in Fortran TRACKF_STAT,
-  // on the radius between RMin and RMax.
+  /// To add to the list of hits for reconstruction all the raw clusters
+  TTree *TR = fMUONData->TreeR();
   AliMUONHitForRec *hitForRec;
   AliMUONRawCluster *clus;
   Int_t iclus, nclus, nTRentries;
   TClonesArray *rawclusters;
   AliDebug(1,"Enter AddHitsForRecFromRawClusters");
-
-  if (fTrackMethod != 3) { //AZ
-    fMUONData->SetTreeAddress("RC"); //AZ
-    nTRentries = Int_t(TR->GetEntries());
-    if (nTRentries != 1) {
-      AliError(Form("nTRentries = %d not equal to 1 ",nTRentries));
-      exit(0);
-    }
-    fMUONData->GetRawClusters(); // only one entry  
+  
+  fMUONData->SetTreeAddress("RC");
+  nTRentries = Int_t(TR->GetEntries());
+  if (nTRentries != 1) {
+    AliError(Form("nTRentries = %d not equal to 1 ",nTRentries));
+    exit(0);
   }
-
+  fMUONData->GetRawClusters(); // only one entry  
+  
   // Loop over tracking chambers
   for (Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++) {
     // number of HitsForRec to 0 for the chamber
@@ -420,9 +112,6 @@ void AliMUONTrackReconstructor::AddHitsForRecFromRawClusters(TTree* TR)
       fNHitsForRec++;
       (fNHitsForRecPerChamber[ch])++;
       // more information into HitForRec
-      //  resolution: info should be already in raw cluster and taken from it ????
-      //hitForRec->SetBendingReso2(fBendingResolution * fBendingResolution);
-      //hitForRec->SetNonBendingReso2(fNonBendingResolution * fNonBendingResolution);
       hitForRec->SetBendingReso2(clus->GetErrY() * clus->GetErrY());
       hitForRec->SetNonBendingReso2(clus->GetErrX() * clus->GetErrX());
       //  original raw cluster
@@ -441,22 +130,34 @@ void AliMUONTrackReconstructor::AddHitsForRecFromRawClusters(TTree* TR)
     } // end of cluster loop
   } // end of chamber loop
   SortHitsForRecWithIncreasingChamber(); 
+  
+  AliDebug(1,"End of AddHitsForRecFromRawClusters");
+    if (AliLog::GetGlobalDebugLevel() > 0) {
+      AliDebug(1, Form("NHitsForRec: %d",fNHitsForRec));
+      for (Int_t ch = 0; ch < AliMUONConstants::NTrackingCh(); ch++) {
+       AliDebug(1, Form("Chamber(0...): %d",ch));
+       AliDebug(1, Form("NHitsForRec: %d", fNHitsForRecPerChamber[ch]));
+       AliDebug(1, Form("Index(first HitForRec): %d", fIndexOfFirstHitForRecPerChamber[ch]));
+       for (Int_t hit = fIndexOfFirstHitForRecPerChamber[ch];
+            hit < fIndexOfFirstHitForRecPerChamber[ch] + fNHitsForRecPerChamber[ch];
+            hit++) {
+         AliDebug(1, Form("HitForRec index(0...): %d",hit));
+         ((*fHitsForRecPtr)[hit])->Dump();
+      }
+    }
+  }
+  
   return;
 }
 
   //__________________________________________________________________________
 void AliMUONTrackReconstructor::MakeSegments(void)
 {
-  // To make the list of segments in all stations,
-  // from the list of hits to be reconstructed
+  /// To make the list of segments in all stations,
+  /// from the list of hits to be reconstructed
   AliDebug(1,"Enter MakeSegments");
-  //AZ ResetSegments();
   // Loop over stations
-  Int_t nb = (fTrackMethod != 1) ? 3 : 0; //AZ
-  for (Int_t st = nb; st < AliMUONConstants::NTrackingCh()/2; st++) 
-  {
-    MakeSegmentsPerStation(st); 
-  }
+  for (Int_t st = 0; st < AliMUONConstants::NTrackingCh()/2; st++) MakeSegmentsPerStation(st); 
   
   StdoutToAliDebug(3,
     cout << "end of MakeSegments" << endl;
@@ -471,288 +172,29 @@ void AliMUONTrackReconstructor::MakeSegments(void)
       }
     }
                    );
-}
-
-  //__________________________________________________________________________
-void AliMUONTrackReconstructor::MakeSegmentsPerStation(Int_t Station)
-{
-  // To make the list of segments in station number "Station" (0...)
-  // from the list of hits to be reconstructed.
-  // Updates "fNSegments"[Station].
-  // Segments in stations 4 and 5 are sorted
-  // according to increasing absolute value of "impact parameter"
-  AliMUONHitForRec *hit1Ptr, *hit2Ptr;
-  AliMUONSegment *segment;
-  Bool_t last2st;
-  Double_t bendingSlope, distBend, distNonBend, extBendCoor, extNonBendCoor,
-      impactParam = 0., maxImpactParam = 0., minImpactParam = 0.; // =0 to avoid compilation warnings.
-  AliDebug(1,Form("Enter MakeSegmentsPerStation (0...) %d",Station));
-  // first and second chambers (0...) in the station
-  Int_t ch1 = 2 * Station;
-  Int_t ch2 = ch1 + 1;
-  // variable true for stations downstream of the dipole:
-  // Station(0..4) equal to 3 or 4
-  if ((Station == 3) || (Station == 4)) {
-    last2st = kTRUE;
-    // maximum impact parameter (cm) according to fMinBendingMomentum...
-    maxImpactParam =
-      TMath::Abs(GetImpactParamFromBendingMomentum(fMinBendingMomentum));
-    // minimum impact parameter (cm) according to fMaxBendingMomentum...
-    minImpactParam =
-      TMath::Abs(GetImpactParamFromBendingMomentum(fMaxBendingMomentum));
-  }
-  else last2st = kFALSE;
-  // extrapolation factor from Z of first chamber to Z of second chamber
-  // dZ to be changed to take into account fine structure of chambers ????
-  Double_t extrapFact;
-  // index for current segment
-  Int_t segmentIndex = 0;
-  // Loop over HitsForRec in the first chamber of the station
-  for (Int_t hit1 = fIndexOfFirstHitForRecPerChamber[ch1];
-       hit1 < fIndexOfFirstHitForRecPerChamber[ch1] + fNHitsForRecPerChamber[ch1];
-       hit1++) {
-    // pointer to the HitForRec
-    hit1Ptr = (AliMUONHitForRec*) ((*fHitsForRecPtr)[hit1]);
-    // extrapolation,
-    // on the straight line joining the HitForRec to the vertex (0,0,0),
-    // to the Z of the second chamber of the station
-    // Loop over HitsForRec in the second chamber of the station
-    for (Int_t hit2 = fIndexOfFirstHitForRecPerChamber[ch2];
-        hit2 < fIndexOfFirstHitForRecPerChamber[ch2] + fNHitsForRecPerChamber[ch2];
-        hit2++) {
-      // pointer to the HitForRec
-      hit2Ptr = (AliMUONHitForRec*) ((*fHitsForRecPtr)[hit2]);
-      // absolute values of distances, in bending and non bending planes,
-      // between the HitForRec in the second chamber
-      // and the previous extrapolation
-      extrapFact = hit2Ptr->GetZ()/ hit1Ptr->GetZ();
-      extBendCoor = extrapFact * hit1Ptr->GetBendingCoor();
-      extNonBendCoor = extrapFact * hit1Ptr->GetNonBendingCoor();
-      distBend = TMath::Abs(hit2Ptr->GetBendingCoor() - extBendCoor);
-      distNonBend = TMath::Abs(hit2Ptr->GetNonBendingCoor() - extNonBendCoor);
-      if (last2st) {
-       // bending slope
-       if ( hit1Ptr->GetZ() - hit2Ptr->GetZ() != 0.0 ) {
-         bendingSlope = (hit1Ptr->GetBendingCoor() - hit2Ptr->GetBendingCoor()) /
-           (hit1Ptr->GetZ() - hit2Ptr->GetZ());
-         // absolute value of impact parameter
-         impactParam =
-           TMath::Abs(hit1Ptr->GetBendingCoor() - hit1Ptr->GetZ() * bendingSlope);
-        } 
-        else {
-          AliWarning("hit1Ptr->GetZ() = hit2Ptr->GetZ(): impactParam set to maxImpactParam");
-          impactParam = maxImpactParam;   
-        }   
-      }
-      // check for distances not too large,
-      // and impact parameter not too big if stations downstream of the dipole.
-      // Conditions "distBend" and "impactParam" correlated for these stations ????
-      if ((distBend < fSegmentMaxDistBending[Station]) &&
-         (distNonBend < fSegmentMaxDistNonBending[Station]) &&
-         (!last2st || (impactParam < maxImpactParam)) &&
-         (!last2st || (impactParam > minImpactParam))) {
-       // make new segment
-       segment = new ((*fSegmentsPtr[Station])[segmentIndex])
-         AliMUONSegment(hit1Ptr, hit2Ptr);
-       // update "link" to this segment from the hit in the first chamber
-       if (hit1Ptr->GetNSegments() == 0)
-         hit1Ptr->SetIndexOfFirstSegment(segmentIndex);
-       hit1Ptr->SetNSegments(hit1Ptr->GetNSegments() + 1);
-       if (AliLog::GetGlobalDebugLevel() > 1) {
-         cout << "segmentIndex(0...): " << segmentIndex
-              << "  distBend: " << distBend
-              << "  distNonBend: " << distNonBend
-              << endl;
-         segment->Dump();
-         cout << "HitForRec in first chamber" << endl;
-         hit1Ptr->Dump();
-         cout << "HitForRec in second chamber" << endl;
-         hit2Ptr->Dump();
-       };
-       // increment index for current segment
-       segmentIndex++;
-      }
-    } //for (Int_t hit2
-  } // for (Int_t hit1...
-  fNSegments[Station] = segmentIndex;
-  // Sorting according to "impact parameter" if station(1..5) 4 or 5,
-  // i.e. Station(0..4) 3 or 4, using the function "Compare".
-  // After this sorting, it is impossible to use
-  // the "fNSegments" and "fIndexOfFirstSegment"
-  // of the HitForRec in the first chamber to explore all segments formed with it.
-  // Is this sorting really needed ????
-  if ((Station == 3) || (Station == 4)) (fSegmentsPtr[Station])->Sort();
-  AliDebug(1,Form("Station: %d  NSegments:  %d ", Station, fNSegments[Station]));
   return;
 }
 
   //__________________________________________________________________________
 void AliMUONTrackReconstructor::MakeTracks(void)
 {
-  // To make the tracks,
-  // from the list of segments and points in all stations
+  /// To make the tracks from the list of segments and points in all stations
   AliDebug(1,"Enter MakeTracks");
-  // The order may be important for the following Reset's
-  //AZ ResetTracks();
-  if (fTrackMethod != 1) { //AZ - Kalman filter
-    MakeTrackCandidatesK();
-    if (fRecTracksPtr->GetEntriesFast() == 0) return;
-    // Follow tracks in stations(1..) 3, 2 and 1
-    FollowTracksK();
-    // Remove double tracks
-    RemoveDoubleTracksK();
-    // Propagate tracks to the vertex thru absorber
-    GoToVertex();
-    // Fill AliMUONTrack data members
-    FillMUONTrack();
-  } else { 
-    // 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();
-    UpdateHitForRecAtHit();
-  }
-  return;
-}
-
-  //__________________________________________________________________________
-void AliMUONTrackReconstructor::ValidateTracksWithTrigger(void)
-{
-  // Try to match track from tracking system with trigger track
-  AliMUONTrack *track;
-  AliMUONTrackParam trackParam; 
-  AliMUONTriggerTrack *triggerTrack;
-  
-  fMUONData->SetTreeAddress("RL");
-  fMUONData->GetRecTriggerTracks();
-  TClonesArray *recTriggerTracks = fMUONData->RecTriggerTracks();
-  
-  Bool_t MatchTrigger;
-  Double_t distSigma[3]={1,1,0.02}; // sigma of distributions (trigger-track) X,Y,slopeY
-  Double_t distTriggerTrack[3];
-  Double_t Chi2MatchTrigger, xTrack, yTrack, ySlopeTrack, dTrigTrackMin2, dTrigTrack2 = 0.;
-  
-  track = (AliMUONTrack*) fRecTracksPtr->First();
-  while (track) {
-    MatchTrigger = kFALSE;
-    Chi2MatchTrigger = 0.;
-    
-    trackParam = *((AliMUONTrackParam*) (track->GetTrackParamAtHit()->Last()));
-    trackParam.ExtrapToZ(AliMUONConstants::DefaultChamberZ(10)); // extrap to 1st trigger chamber
-    
-    xTrack = trackParam.GetNonBendingCoor();
-    yTrack = trackParam.GetBendingCoor();
-    ySlopeTrack = trackParam.GetBendingSlope();
-    dTrigTrackMin2 = 999.;
-  
-    triggerTrack = (AliMUONTriggerTrack*) recTriggerTracks->First();
-    while(triggerTrack){
-      distTriggerTrack[0] = (triggerTrack->GetX11()-xTrack)/distSigma[0];
-      distTriggerTrack[1] = (triggerTrack->GetY11()-yTrack)/distSigma[1];
-      distTriggerTrack[2] = (TMath::Tan(triggerTrack->GetThetay())-ySlopeTrack)/distSigma[2];
-      dTrigTrack2 = 0.;
-      for (Int_t iVar = 0; iVar < 3; iVar++) dTrigTrack2 += distTriggerTrack[iVar]*distTriggerTrack[iVar];
-      if (dTrigTrack2 < dTrigTrackMin2 && dTrigTrack2 < GetMaxSigma2Distance()) {
-        dTrigTrackMin2 = dTrigTrack2;
-        MatchTrigger = kTRUE;
-        Chi2MatchTrigger =  dTrigTrack2/3.; // Normalized Chi2, 3 variables (X,Y,slopeY)
-      }
-      triggerTrack = (AliMUONTriggerTrack*) recTriggerTracks->After(triggerTrack);
-    }
-    
-    track->SetMatchTrigger(MatchTrigger);
-    track->SetChi2MatchTrigger(Chi2MatchTrigger);
-    
-    track = (AliMUONTrack*) fRecTracksPtr->After(track);
-  }
-
-}
-
-  //__________________________________________________________________________
-Bool_t AliMUONTrackReconstructor::MakeTriggerTracks(void)
-{
-    // To make the trigger tracks from Local Trigger
-  AliDebug(1, "Enter MakeTriggerTracks");
-    
-    Int_t nTRentries;
-    UChar_t gloTrigPat;
-    TClonesArray *localTrigger;
-    TClonesArray *globalTrigger;
-    AliMUONLocalTrigger *locTrg;
-    AliMUONGlobalTrigger *gloTrg;
-
-    TTree* treeR = fMUONData->TreeR();
-   
-    nTRentries = Int_t(treeR->GetEntries());
-     
-    treeR->GetEvent(0); // only one entry  
-
-    if (!(fMUONData->IsTriggerBranchesInTree())) {
-      AliWarning(Form("Trigger information is not avalaible, nTRentries = %d not equal to 1",nTRentries));
-      return kFALSE;
-    }
-
-    fMUONData->SetTreeAddress("TC");
-    fMUONData->GetTrigger();
-
-    // global trigger for trigger pattern
-    gloTrigPat = 0;
-    globalTrigger = fMUONData->GlobalTrigger(); 
-    gloTrg = (AliMUONGlobalTrigger*)globalTrigger->UncheckedAt(0);
-    if (gloTrg)
-      gloTrigPat = gloTrg->GetGlobalResponse();
-  
-
-    // local trigger for tracking 
-    localTrigger = fMUONData->LocalTrigger();    
-    Int_t nlocals = (Int_t) (localTrigger->GetEntries());
-
-    Float_t z11 = AliMUONConstants::DefaultChamberZ(10);
-    Float_t z21 = AliMUONConstants::DefaultChamberZ(12);
-
-    Float_t y11 = 0.;
-    Int_t stripX21 = 0;
-    Float_t y21 = 0.;
-    Float_t x11 = 0.;
-
-    for (Int_t i=0; i<nlocals; i++) { // loop on Local Trigger
-      locTrg = (AliMUONLocalTrigger*)localTrigger->UncheckedAt(i);     
-
-      AliDebug(1, "AliMUONTrackReconstructor::MakeTriggerTrack using NEW trigger \n");
-      AliMUONTriggerCircuitNew* circuit = 
-       (AliMUONTriggerCircuitNew*)fTriggerCircuit->At(locTrg->LoCircuit()-1); // -1 !!!
-
-      y11 = circuit->GetY11Pos(locTrg->LoStripX()); 
-      stripX21 = locTrg->LoStripX()+locTrg->LoDev()+1;
-      y21 = circuit->GetY21Pos(stripX21);      
-      x11 = circuit->GetX11Pos(locTrg->LoStripY());
-      
-      AliDebug(1, Form(" MakeTriggerTrack %d %d %d %d %d %f %f %f \n",i,locTrg->LoCircuit(),
-                      locTrg->LoStripX(),locTrg->LoStripX()+locTrg->LoDev()+1,locTrg->LoStripY(),y11, y21, x11));
-      
-      Float_t thetax = TMath::ATan2( x11 , z11 );
-      Float_t thetay = TMath::ATan2( (y21-y11) , (z21-z11) );
-      
-      fTriggerTrack->SetX11(x11);
-      fTriggerTrack->SetY11(y11);
-      fTriggerTrack->SetThetax(thetax);
-      fTriggerTrack->SetThetay(thetay);
-      fTriggerTrack->SetGTPattern(gloTrigPat);
-            
-      fMUONData->AddRecTriggerTrack(*fTriggerTrack);
-    } // end of loop on Local Trigger
-    return kTRUE;    
+  // 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();
+  UpdateHitForRecAtHit();
 }
 
   //__________________________________________________________________________
 void AliMUONTrackReconstructor::MakeTrackCandidates(void)
 {
-  // To make track candidates
-  // with at least 3 aligned points in stations(1..) 4 and 5
-  // (two Segment's or one Segment and one HitForRec)
+  /// To make track candidates
+  /// with at least 3 aligned points in stations(1..) 4 and 5
+  /// (two Segment's or one Segment and one HitForRec)
   Int_t begStation, iBegSegment, nbCan1Seg1Hit, nbCan2Seg;
   AliMUONSegment *begSegment;
   AliDebug(1,"Enter MakeTrackCandidates");
@@ -783,9 +225,9 @@ void AliMUONTrackReconstructor::MakeTrackCandidates(void)
   //__________________________________________________________________________
 Int_t AliMUONTrackReconstructor::MakeTrackCandidatesWithTwoSegments(AliMUONSegment *BegSegment)
 {
-  // To make track candidates with two segments in stations(1..) 4 and 5,
-  // the first segment being pointed to by "BegSegment".
-  // Returns the number of such track candidates.
+  /// To make track candidates with two segments in stations(1..) 4 and 5,
+  /// the first segment being pointed to by "BegSegment".
+  /// Returns the number of such track candidates.
   Int_t endStation, iEndSegment, nbCan2Seg;
   AliMUONSegment *endSegment;
   AliMUONSegment *extrapSegment = NULL;
@@ -835,9 +277,9 @@ Int_t AliMUONTrackReconstructor::MakeTrackCandidatesWithTwoSegments(AliMUONSegme
   //__________________________________________________________________________
 Int_t AliMUONTrackReconstructor::MakeTrackCandidatesWithOneSegmentAndOnePoint(AliMUONSegment *BegSegment)
 {
-  // To make track candidates with one segment and one point
-  // in stations(1..) 4 and 5,
-  // the segment being pointed to by "BegSegment".
+  /// To make track candidates with one segment and one point
+  /// in stations(1..) 4 and 5,
+  /// the segment being pointed to by "BegSegment".
   Int_t ch, ch1, ch2, endStation, iHit, iHitMax, iHitMin, nbCan1Seg1Hit;
   AliMUONHitForRec *extrapHitForRec= NULL;
   AliMUONHitForRec *hit;
@@ -894,13 +336,13 @@ Int_t AliMUONTrackReconstructor::MakeTrackCandidatesWithOneSegmentAndOnePoint(Al
 }
 
   //__________________________________________________________________________
-void AliMUONTrackReconstructor::CalcTrackParamAtVertex(AliMUONTrack *Track)
+void AliMUONTrackReconstructor::CalcTrackParamAtVertex(AliMUONTrack *Track) const
 {
-  // Set track parameters at vertex.
-  // TrackHit's are assumed to be only in stations(1..) 4 and 5,
-  // and sorted according to increasing Z..
-  // Parameters are calculated from information in HitForRec's
-  // of first and last TrackHit's.
+  /// Set track parameters at vertex.
+  /// TrackHit's are assumed to be only in stations(1..) 4 and 5,
+  /// and sorted according to increasing Z.
+  /// Parameters are calculated from information in HitForRec's
+  /// of first and last TrackHit's.
   AliMUONTrackParam *trackParamVertex = Track->GetTrackParamAtVertex(); // pointer to track parameters at vertex
   // Pointer to HitForRec attached to first TrackParamAtHit
   AliMUONHitForRec *firstHit = ((AliMUONTrackParam*) (Track->GetTrackParamAtHit()->First()))->GetHitForRecPtr();
@@ -916,7 +358,7 @@ void AliMUONTrackReconstructor::CalcTrackParamAtVertex(AliMUONTrack *Track)
   // signed bending momentum
   trackParamVertex->SetInverseBendingMomentum(1.0 / GetBendingMomentumFromImpactParam(impactParam));
   // bending slope at vertex
-  trackParamVertex->SetBendingSlope(bendingSlope + impactParam / GetSimpleBPosition());
+  trackParamVertex->SetBendingSlope(bendingSlope + impactParam / fSimpleBPosition);
   // non bending slope
   trackParamVertex->SetNonBendingSlope((firstHit->GetNonBendingCoor() - lastHit->GetNonBendingCoor()) / deltaZ);
   // vertex coordinates at (0,0,0)
@@ -928,7 +370,7 @@ void AliMUONTrackReconstructor::CalcTrackParamAtVertex(AliMUONTrack *Track)
   //__________________________________________________________________________
 void AliMUONTrackReconstructor::FollowTracks(void)
 {
-  // Follow tracks in stations(1..) 3, 2 and 1
+  /// Follow tracks in stations(1..) 3, 2 and 1
   // too long: should be made more modular !!!!
   AliMUONHitForRec *bestHit, *extrapHit, *hit;
   AliMUONSegment *bestSegment, *extrapSegment, *segment;
@@ -1140,10 +582,10 @@ void AliMUONTrackReconstructor::FollowTracks(void)
   //__________________________________________________________________________
 void AliMUONTrackReconstructor::Fit(AliMUONTrack *Track, Int_t FitStart, Int_t FitMCS)
 {
-  // Fit the track "Track",
-  // with or without multiple Coulomb scattering according to "FitMCS",
-  // starting, according to "FitStart",
-  // with track parameters at vertex or at the first TrackHit.
+  /// Fit the track "Track",
+  /// with or without multiple Coulomb scattering according to "FitMCS",
+  /// starting, according to "FitStart",
+  /// with track parameters at vertex or at the first TrackHit.
   
   if ((FitStart != 0) && (FitStart != 1)) {
     cout << "ERROR in AliMUONTrackReconstructor::Fit(...)" << endl;
@@ -1219,25 +661,25 @@ void AliMUONTrackReconstructor::Fit(AliMUONTrack *Track, Int_t FitStart, Int_t F
     trackParam->SetBendingCoor(y);
   }
   // global result of the fit
-  Double_t fedm, errdef, FitFMin;
+  Double_t fedm, errdef, fitFMin;
   Int_t npari, nparx;
-  fgFitter->GetStats(FitFMin, fedm, errdef, npari, nparx);
-  Track->SetFitFMin(FitFMin);
+  fgFitter->GetStats(fitFMin, fedm, errdef, npari, nparx);
+  Track->SetFitFMin(fitFMin);
 }
 
   //__________________________________________________________________________
 void TrackChi2(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double_t *Param, Int_t /*Flag*/)
 {
-  // Return the "Chi2" to be minimized with Minuit for track fitting,
-  // with "NParam" parameters
-  // and their current values in array pointed to by "Param".
-  // Assumes that the track hits are sorted according to increasing Z.
-  // Track parameters at each TrackHit are updated accordingly.
-  // Multiple Coulomb scattering is not taken into account
+  /// Return the "Chi2" to be minimized with Minuit for track fitting,
+  /// with "NParam" parameters
+  /// and their current values in array pointed to by "Param".
+  /// Assumes that the track hits are sorted according to increasing Z.
+  /// Track parameters at each TrackHit are updated accordingly.
+  /// Multiple Coulomb scattering is not taken into account
   AliMUONTrack *trackBeingFitted;
   AliMUONTrackParam param1;
-  AliMUONTrackParam* TrackParamAtHit;
-  AliMUONHitForRec* HitForRec;
+  AliMUONTrackParam* trackParamAtHit;
+  AliMUONHitForRec* hitForRec;
   Chi2 = 0.0; // initialize Chi2
   // copy of track parameters to be fitted
   trackBeingFitted = (AliMUONTrack*) AliMUONTrackReconstructor::Fitter()->GetObjectFit();
@@ -1253,37 +695,37 @@ void TrackChi2(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double_t
     param1.SetBendingCoor(Param[4]);
   }
   // Follow track through all planes of track hits
-  TrackParamAtHit = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->First());
-  while (TrackParamAtHit) {
-    HitForRec = TrackParamAtHit->GetHitForRecPtr();
-    // extrapolation to the plane of the HitForRec attached to the current TrackParamAtHit
-    param1.ExtrapToZ(HitForRec->GetZ());
+  trackParamAtHit = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->First());
+  while (trackParamAtHit) {
+    hitForRec = trackParamAtHit->GetHitForRecPtr();
+    // extrapolation to the plane of the hitForRec attached to the current trackParamAtHit
+    param1.ExtrapToZ(hitForRec->GetZ());
     // update track parameters of the current hit
-    TrackParamAtHit->SetTrackParam(param1);
+    trackParamAtHit->SetTrackParam(param1);
     // Increment Chi2
     // done hit per hit, with hit resolution,
     // and not with point and angle like in "reco_muon.F" !!!!
     // Needs to add multiple scattering contribution ????
-    Double_t dX = HitForRec->GetNonBendingCoor() - param1.GetNonBendingCoor();
-    Double_t dY = HitForRec->GetBendingCoor() - param1.GetBendingCoor();
-    Chi2 = Chi2 + dX * dX / HitForRec->GetNonBendingReso2() + dY * dY / HitForRec->GetBendingReso2();
-    TrackParamAtHit = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->After(TrackParamAtHit));
+    Double_t dX = hitForRec->GetNonBendingCoor() - param1.GetNonBendingCoor();
+    Double_t dY = hitForRec->GetBendingCoor() - param1.GetBendingCoor();
+    Chi2 = Chi2 + dX * dX / hitForRec->GetNonBendingReso2() + dY * dY / hitForRec->GetBendingReso2();
+    trackParamAtHit = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->After(trackParamAtHit));
   }
 }
 
   //__________________________________________________________________________
 void TrackChi2MCS(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double_t *Param, Int_t /*Flag*/)
 {
-  // Return the "Chi2" to be minimized with Minuit for track fitting,
-  // with "NParam" parameters
-  // and their current values in array pointed to by "Param".
-  // Assumes that the track hits are sorted according to increasing Z.
-  // Track parameters at each TrackHit are updated accordingly.
-  // Multiple Coulomb scattering is taken into account with covariance matrix.
+  /// Return the "Chi2" to be minimized with Minuit for track fitting,
+  /// with "NParam" parameters
+  /// and their current values in array pointed to by "Param".
+  /// Assumes that the track hits are sorted according to increasing Z.
+  /// Track parameters at each TrackHit are updated accordingly.
+  /// Multiple Coulomb scattering is taken into account with covariance matrix.
   AliMUONTrack *trackBeingFitted;
   AliMUONTrackParam param1;
-  AliMUONTrackParam* TrackParamAtHit;
-  AliMUONHitForRec* HitForRec;
+  AliMUONTrackParam* trackParamAtHit;
+  AliMUONHitForRec* hitForRec;
   Chi2 = 0.0; // initialize Chi2
   // copy of track parameters to be fitted
   trackBeingFitted = (AliMUONTrack*) AliMUONTrackReconstructor::Fitter()->GetObjectFit();
@@ -1301,8 +743,8 @@ void TrackChi2MCS(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double
 
   Int_t chCurrent, chPrev = 0, hitNumber, hitNumber1, hitNumber2, hitNumber3;
   Double_t z1, z2, z3;
-  AliMUONTrackParam *TrackParamAtHit1, *TrackParamAtHit2, *TrackParamAtHit3;
-  AliMUONHitForRec *HitForRec1, *HitForRec2;
+  AliMUONTrackParam *trackParamAtHit1, *trackParamAtHit2, *trackParamAtHit3;
+  AliMUONHitForRec *hitForRec1, *hitForRec2;
   Double_t hbc1, hbc2, pbc1, pbc2;
   Double_t hnbc1, hnbc2, pnbc1, pnbc2;
   Int_t numberOfHit = trackBeingFitted->GetNTrackHits();
@@ -1312,37 +754,37 @@ void TrackChi2MCS(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double
 
   // Predicted coordinates and  multiple scattering angles are first calculated
   for (hitNumber = 0; hitNumber < numberOfHit; hitNumber++) {
-    TrackParamAtHit = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber));
-    HitForRec = TrackParamAtHit->GetHitForRecPtr();
-    // extrapolation to the plane of the HitForRec attached to the current TrackParamAtHit
-    param1.ExtrapToZ(HitForRec->GetZ());
+    trackParamAtHit = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber));
+    hitForRec = trackParamAtHit->GetHitForRecPtr();
+    // extrapolation to the plane of the hitForRec attached to the current trackParamAtHit
+    param1.ExtrapToZ(hitForRec->GetZ());
     // update track parameters of the current hit
-    TrackParamAtHit->SetTrackParam(param1);
+    trackParamAtHit->SetTrackParam(param1);
     // square of multiple scattering angle at current hit, with one chamber
     msa2[hitNumber] = MultipleScatteringAngle2(&param1);
     // correction for eventual missing hits or multiple hits in a chamber,
     // according to the number of chambers
     // between the current hit and the previous one
-    chCurrent = HitForRec->GetChamberNumber();
+    chCurrent = hitForRec->GetChamberNumber();
     if (hitNumber > 0) msa2[hitNumber] = msa2[hitNumber] * (chCurrent - chPrev);
     chPrev = chCurrent;
   }
 
   // Calculates the covariance matrix
   for (hitNumber1 = 0; hitNumber1 < numberOfHit; hitNumber1++) { 
-    TrackParamAtHit1 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber1));
-    HitForRec1 = TrackParamAtHit1->GetHitForRecPtr();
-    z1 = HitForRec1->GetZ();
+    trackParamAtHit1 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber1));
+    hitForRec1 = trackParamAtHit1->GetHitForRecPtr();
+    z1 = hitForRec1->GetZ();
     for (hitNumber2 = hitNumber1; hitNumber2 < numberOfHit; hitNumber2++) {
-      TrackParamAtHit2 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber2));
-      z2 = TrackParamAtHit2->GetHitForRecPtr()->GetZ();
+      trackParamAtHit2 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber2));
+      z2 = trackParamAtHit2->GetHitForRecPtr()->GetZ();
       // initialization to 0 (diagonal plus upper triangular part)
       (*covBending)(hitNumber2, hitNumber1) = 0.0;
       // contribution from multiple scattering in bending plane:
       // loop over upstream hits
       for (hitNumber3 = 0; hitNumber3 < hitNumber1; hitNumber3++) {    
-        TrackParamAtHit3 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber3));
-       z3 = TrackParamAtHit3->GetHitForRecPtr()->GetZ();
+        trackParamAtHit3 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber3));
+       z3 = trackParamAtHit3->GetHitForRecPtr()->GetZ();
        (*covBending)(hitNumber2, hitNumber1) = (*covBending)(hitNumber2, hitNumber1) + ((z1 - z3) * (z2 - z3) * msa2[hitNumber3]); 
       }
       // equal contribution from multiple scattering in non bending plane
@@ -1350,9 +792,9 @@ void TrackChi2MCS(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double
       if (hitNumber1 == hitNumber2) {
        // Diagonal elements: add contribution from position measurements
        // in bending plane
-       (*covBending)(hitNumber2, hitNumber1) = (*covBending)(hitNumber2, hitNumber1) + HitForRec1->GetBendingReso2();
+       (*covBending)(hitNumber2, hitNumber1) = (*covBending)(hitNumber2, hitNumber1) + hitForRec1->GetBendingReso2();
        // and in non bending plane
-       (*covNonBending)(hitNumber2, hitNumber1) = (*covNonBending)(hitNumber2, hitNumber1) + HitForRec1->GetNonBendingReso2();
+       (*covNonBending)(hitNumber2, hitNumber1) = (*covNonBending)(hitNumber2, hitNumber1) + hitForRec1->GetNonBendingReso2();
       } else {
        // Non diagonal elements: symmetrization
        // for bending plane
@@ -1382,19 +824,19 @@ void TrackChi2MCS(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double
   if ((ifailBending == 0) && (ifailNonBending == 0)) {
     // with Multiple Scattering if inversion correct
     for (hitNumber1 = 0; hitNumber1 < numberOfHit ; hitNumber1++) { 
-      TrackParamAtHit1 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber1));
-      HitForRec1 = TrackParamAtHit1->GetHitForRecPtr();
-      hbc1 = HitForRec1->GetBendingCoor();
-      pbc1 = TrackParamAtHit1->GetBendingCoor();
-      hnbc1 = HitForRec1->GetNonBendingCoor();
-      pnbc1 = TrackParamAtHit1->GetNonBendingCoor();
+      trackParamAtHit1 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber1));
+      hitForRec1 = trackParamAtHit1->GetHitForRecPtr();
+      hbc1 = hitForRec1->GetBendingCoor();
+      pbc1 = trackParamAtHit1->GetBendingCoor();
+      hnbc1 = hitForRec1->GetNonBendingCoor();
+      pnbc1 = trackParamAtHit1->GetNonBendingCoor();
       for (hitNumber2 = 0; hitNumber2 < numberOfHit; hitNumber2++) {
-       TrackParamAtHit2 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber2));
-        HitForRec2 = TrackParamAtHit2->GetHitForRecPtr();
-       hbc2 = HitForRec2->GetBendingCoor();
-       pbc2 = TrackParamAtHit2->GetBendingCoor();
-       hnbc2 = HitForRec2->GetNonBendingCoor();
-       pnbc2 = TrackParamAtHit2->GetNonBendingCoor();
+       trackParamAtHit2 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber2));
+        hitForRec2 = trackParamAtHit2->GetHitForRecPtr();
+       hbc2 = hitForRec2->GetBendingCoor();
+       pbc2 = trackParamAtHit2->GetBendingCoor();
+       hnbc2 = hitForRec2->GetNonBendingCoor();
+       pnbc2 = trackParamAtHit2->GetNonBendingCoor();
        Chi2 += ((*covBending)(hitNumber2, hitNumber1) * (hbc1 - pbc1) * (hbc2 - pbc2)) +
                ((*covNonBending)(hitNumber2, hitNumber1) * (hnbc1 - pnbc1) * (hnbc2 - pnbc2));
       }
@@ -1402,14 +844,14 @@ void TrackChi2MCS(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double
   } else {
     // without Multiple Scattering if inversion impossible
     for (hitNumber1 = 0; hitNumber1 < numberOfHit ; hitNumber1++) { 
-      TrackParamAtHit1 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber1));
-      HitForRec1 = TrackParamAtHit1->GetHitForRecPtr();
-      hbc1 = HitForRec1->GetBendingCoor();
-      pbc1 = TrackParamAtHit1->GetBendingCoor();
-      hnbc1 = HitForRec1->GetNonBendingCoor();
-      pnbc1 = TrackParamAtHit1->GetNonBendingCoor();
-      Chi2 += ((hbc1 - pbc1) * (hbc1 - pbc1) / HitForRec1->GetBendingReso2()) +
-             ((hnbc1 - pnbc1) * (hnbc1 - pnbc1) / HitForRec1->GetNonBendingReso2());
+      trackParamAtHit1 = (AliMUONTrackParam*) (trackBeingFitted->GetTrackParamAtHit()->UncheckedAt(hitNumber1));
+      hitForRec1 = trackParamAtHit1->GetHitForRecPtr();
+      hbc1 = hitForRec1->GetBendingCoor();
+      pbc1 = trackParamAtHit1->GetBendingCoor();
+      hnbc1 = hitForRec1->GetNonBendingCoor();
+      pnbc1 = trackParamAtHit1->GetNonBendingCoor();
+      Chi2 += ((hbc1 - pbc1) * (hbc1 - pbc1) / hitForRec1->GetBendingReso2()) +
+             ((hnbc1 - pnbc1) * (hnbc1 - pnbc1) / hitForRec1->GetNonBendingReso2());
     }
   }
   
@@ -1420,8 +862,8 @@ void TrackChi2MCS(Int_t &NParam, Double_t * /*Gradient*/, Double_t &Chi2, Double
 
 Double_t MultipleScatteringAngle2(AliMUONTrackParam *param)
 {
-  // Returns square of multiple Coulomb scattering angle
-  // from TrackParamAtHit pointed to by "param"
+  /// Returns square of multiple Coulomb scattering angle
+  /// from TrackParamAtHit pointed to by "param"
   Double_t slopeBending, slopeNonBending, radiationLength, inverseBendingMomentum2, inverseTotalMomentum2;
   Double_t varMultipleScatteringAngle;
   // Better implementation in AliMUONTrack class ????
@@ -1443,12 +885,12 @@ Double_t MultipleScatteringAngle2(AliMUONTrackParam *param)
 //______________________________________________________________________________
  void mnvertLocal(Double_t *a, Int_t l, Int_t, Int_t n, Int_t &ifail)
 {
-//*-*-*-*-*-*-*-*-*-*-*-*Inverts a symmetric matrix*-*-*-*-*-*-*-*-*-*-*-*-*
-//*-*                    ==========================
-//*-*        inverts a symmetric matrix.   matrix is first scaled to
-//*-*        have all ones on the diagonal (equivalent to change of units)
-//*-*        but no pivoting is done since matrix is positive-definite.
-//*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
+///*-*-*-*-*-*-*-*-*-*-*-*Inverts a symmetric matrix*-*-*-*-*-*-*-*-*-*-*-*-*
+///*-*                    ==========================
+///*-*        inverts a symmetric matrix.   matrix is first scaled to
+///*-*        have all ones on the diagonal (equivalent to change of units)
+///*-*        but no pivoting is done since matrix is positive-definite.
+///*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
 
   // taken from TMinuit package of Root (l>=n)
   // fVERTs, fVERTq and fVERTpp changed to localVERTs, localVERTq and localVERTpp
@@ -1542,11 +984,11 @@ L100:
   //__________________________________________________________________________
 void AliMUONTrackReconstructor::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.
+  /// 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;
   Int_t hitsInCommon, nHits1, nHits2;
   Bool_t removedTrack1;
@@ -1592,7 +1034,7 @@ void AliMUONTrackReconstructor::RemoveDoubleTracks(void)
   //__________________________________________________________________________
 void AliMUONTrackReconstructor::UpdateHitForRecAtHit()
 {
-  // Set cluster parameters after track fitting. Fill fHitForRecAtHit of AliMUONTrack's
+  /// Set cluster parameters after track fitting. Fill fHitForRecAtHit of AliMUONTrack's
   AliMUONTrack *track;
   AliMUONTrackParam *trackParamAtHit;
   track = (AliMUONTrack*) fRecTracksPtr->First();
@@ -1607,25 +1049,11 @@ void AliMUONTrackReconstructor::UpdateHitForRecAtHit()
   return;
 }
 
-  //__________________________________________________________________________
-void AliMUONTrackReconstructor::FillMUONTrack()
-{
-  // Set track parameters at hits for Kalman track. Fill fTrackParamAtHit of AliMUONTrack's
-  AliMUONTrackK *track;
-  track = (AliMUONTrackK*) fRecTracksPtr->First();
-  while (track) {
-    track->FillMUONTrack();
-    track = (AliMUONTrackK*) fRecTracksPtr->After(track);
-  } 
-  return;
-}
-
   //__________________________________________________________________________
 void AliMUONTrackReconstructor::EventDump(void)
 {
-  // Dump reconstructed event (track parameters at vertex and at first hit),
-  // and the particle parameters
-
+  /// Dump reconstructed event (track parameters at vertex and at first hit),
+  /// and the particle parameters
   AliMUONTrack *track;
   AliMUONTrackParam *trackParam, *trackParam1;
   Double_t bendingSlope, nonBendingSlope, pYZ;
@@ -1638,7 +1066,6 @@ void AliMUONTrackReconstructor::EventDump(void)
   fRecTracksPtr->Compress(); // for simple loop without "Next" since no hole
   // Loop over reconstructed tracks
   for (trackIndex = 0; trackIndex < fNRecTracks; trackIndex++) {
-    if (fTrackMethod != 1) continue; //AZ - skip the rest for now
     AliDebug(1, Form("track number: %d", trackIndex));
     // function for each track for modularity ????
     track = (AliMUONTrack*) ((*fRecTracksPtr)[trackIndex]);
@@ -1685,280 +1112,3 @@ void AliMUONTrackReconstructor::EventDump(void)
 }
 
 
-//__________________________________________________________________________
-void AliMUONTrackReconstructor::EventDumpTrigger(void)
-{
-  // Dump reconstructed trigger event 
-  // and the particle parameters
-    
-  AliMUONTriggerTrack *triggertrack ;
-  Int_t nTriggerTracks = fMUONData->RecTriggerTracks()->GetEntriesFast();
-  AliDebug(1, "****** enter EventDumpTrigger ******");
-  AliDebug(1, Form("Number of Reconstructed tracks : %d ",  nTriggerTracks));
-  
-  // Loop over reconstructed tracks
-  for (Int_t trackIndex = 0; trackIndex < nTriggerTracks; trackIndex++) {
-    triggertrack = (AliMUONTriggerTrack*)fMUONData->RecTriggerTracks()->At(trackIndex);
-      printf(" trigger track number %i x11=%f y11=%f thetax=%f thetay=%f \n",
-            trackIndex,
-            triggertrack->GetX11(),triggertrack->GetY11(),
-            triggertrack->GetThetax(),triggertrack->GetThetay());      
-  } 
-}
-
-//__________________________________________________________________________
-void AliMUONTrackReconstructor::MakeTrackCandidatesK(void)
-{
-  // To make initial tracks for Kalman filter from the list of segments
-  Int_t istat, iseg;
-  AliMUONSegment *segment;
-  AliMUONTrackK *trackK;
-
-  AliDebug(1,"Enter MakeTrackCandidatesK");
-
-  AliMUONTrackK a(this, fHitsForRecPtr);
-  // Loop over stations(1...) 5 and 4
-  for (istat=4; istat>=3; istat--) {
-    // Loop over segments in the station
-    for (iseg=0; iseg<fNSegments[istat]; iseg++) {
-      // Transform segments to tracks and evaluate covariance matrix
-      segment = (AliMUONSegment*) ((*fSegmentsPtr[istat])[iseg]);
-      trackK = new ((*fRecTracksPtr)[fNRecTracks++]) AliMUONTrackK(segment);
-    } // for (iseg=0;...)
-  } // for (istat=4;...)
-  return;
-}
-
-//__________________________________________________________________________
-void AliMUONTrackReconstructor::FollowTracksK(void)
-{
-  // Follow tracks using Kalman filter
-  Bool_t ok;
-  Int_t icand, ichamBeg = 0, ichamEnd, chamBits;
-  Double_t zDipole1, zDipole2;
-  AliMUONTrackK *trackK;
-  AliMUONHitForRec *hit;
-  AliMUONRawCluster *clus;
-  TClonesArray *rawclusters;
-  clus = 0; rawclusters = 0;
-
-  zDipole1 = GetSimpleBPosition() + GetSimpleBLength()/2;
-  zDipole2 = zDipole1 - GetSimpleBLength();
-
-  // Print hits
-  trackK = (AliMUONTrackK*) ((*fRecTracksPtr)[0]);
-
-  if (trackK->DebugLevel() > 0) {
-    for (Int_t i1=0; i1<fNHitsForRec; i1++) {
-      hit = (AliMUONHitForRec*) ((*fHitsForRecPtr)[i1]);
-      printf(" Hit # %d %10.4f %10.4f %10.4f",
-             hit->GetChamberNumber(), hit->GetBendingCoor(),
-             hit->GetNonBendingCoor(), hit->GetZ());
-      // from raw clusters
-      rawclusters = fMUONData->RawClusters(hit->GetChamberNumber());
-      clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->
-                                                          GetHitNumber());
-      printf(" %d", clus->GetTrack(1));
-      if (clus->GetTrack(2) != -1) printf(" %d \n", clus->GetTrack(2));
-      else printf("\n");
-     
-    }
-  } // if (trackK->DebugLevel() > 0)
-
-  icand = -1;
-  Int_t nSeeds;
-  nSeeds = fNRecTracks; // starting number of seeds
-  // Loop over track candidates
-  while (icand < fNRecTracks-1) {
-    icand ++;
-    if (trackK->DebugLevel()>0) cout << " *** Kalman track candidate No. " << icand << endl;
-    trackK = (AliMUONTrackK*) ((*fRecTracksPtr)[icand]);
-    if (trackK->GetRecover() < 0) continue; // failed track
-
-    // Discard candidate which will produce the double track
-    /*
-    if (icand > 0) {
-      ok = CheckCandidateK(icand,nSeeds);
-      if (!ok) {
-        trackK->SetRecover(-1); // mark candidate to be removed
-        continue;
-      }
-    }
-    */
-
-    ok = kTRUE;
-    if (trackK->GetRecover() == 0) 
-      hit = (AliMUONHitForRec*) trackK->GetTrackHits()->Last(); // last hit
-    else 
-      hit = trackK->GetHitLastOk(); // hit where track stopped
-
-    if (hit) ichamBeg = hit->GetChamberNumber();
-    ichamEnd = 0;
-    // Check propagation direction
-    if (!hit) { ichamBeg = ichamEnd; AliFatal(" ??? "); }
-    else if (trackK->GetTrackDir() < 0) {
-      ichamEnd = 9; // forward propagation
-      ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kFALSE,zDipole1,zDipole2);
-      if (ok) {
-        ichamBeg = ichamEnd;
-        ichamEnd = 6; // backward propagation
-       // Change weight matrix and zero fChi2 for backpropagation
-        trackK->StartBack();
-       trackK->SetTrackDir(1);
-        ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kTRUE,zDipole1,zDipole2);
-        ichamBeg = ichamEnd;
-        ichamEnd = 0;
-      }
-    } else {
-      if (trackK->GetBPFlag()) {
-       // backpropagation
-        ichamEnd = 6; // backward propagation
-       // Change weight matrix and zero fChi2 for backpropagation
-        trackK->StartBack();
-        ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kTRUE,zDipole1,zDipole2);
-        ichamBeg = ichamEnd;
-        ichamEnd = 0;
-      }
-    }
-
-    if (ok) {
-      trackK->SetTrackDir(1);
-      trackK->SetBPFlag(kFALSE);
-      ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kFALSE,zDipole1,zDipole2);
-    }
-    if (!ok) { trackK->SetRecover(-1); continue; } // mark candidate to be removed
-
-    // Apply smoother
-    if (trackK->GetRecover() >= 0) {
-      ok = trackK->Smooth();
-      if (!ok) trackK->SetRecover(-1); // mark candidate to be removed
-    }
-
-    // Majority 3 of 4 in first 2 stations
-    if (!ok) continue;
-    chamBits = 0;
-    Double_t chi2max = 0;
-    for (Int_t i=0; i<trackK->GetNTrackHits(); i++) {
-      hit = (AliMUONHitForRec*) (*trackK->GetTrackHits())[i];
-      chamBits |= BIT(hit->GetChamberNumber());
-      if (trackK->GetChi2PerPoint(i) > chi2max) chi2max = trackK->GetChi2PerPoint(i);
-    }
-    if (!((chamBits&3)==3 || (chamBits>>2&3)==3) && chi2max > 25) {
-      //trackK->Recover();
-      trackK->SetRecover(-1); //mark candidate to be removed
-      continue;
-    }
-    if (ok) trackK->SetTrackQuality(0); // compute "track quality"
-  } // while
-
-  for (Int_t i=0; i<fNRecTracks; i++) {
-    trackK = (AliMUONTrackK*) ((*fRecTracksPtr)[i]);
-    if (trackK->GetRecover() < 0) fRecTracksPtr->RemoveAt(i);
-  }
-
-  // Compress TClonesArray
-  fRecTracksPtr->Compress();
-  fNRecTracks = fRecTracksPtr->GetEntriesFast();
-  return;
-}
-
-//__________________________________________________________________________
-Bool_t AliMUONTrackReconstructor::CheckCandidateK(Int_t icand, Int_t nSeeds) const
-{
-  // Discards track candidate if it will produce the double track (having
-  // the same seed segment hits as hits of a good track found before)
-  AliMUONTrackK *track1, *track2;
-  AliMUONHitForRec *hit1, *hit2, *hit;
-
-  track1 = (AliMUONTrackK*) ((*fRecTracksPtr)[icand]);
-  hit1 = (AliMUONHitForRec*) (*track1->GetTrackHits())[0]; // 1'st hit
-  hit2 = (AliMUONHitForRec*) (*track1->GetTrackHits())[1]; // 2'nd hit
-
-  for (Int_t i=0; i<icand; i++) {
-    track2 = (AliMUONTrackK*) ((*fRecTracksPtr)[i]);
-    //if (track2->GetRecover() < 0) continue;
-    if (track2->GetRecover() < 0 && icand >= nSeeds) continue;
-
-    if (track1->GetStartSegment() == track2->GetStartSegment()) {
-      return kFALSE;
-    } else {
-      Int_t nSame = 0;
-      for (Int_t j=0; j<track2->GetNTrackHits(); j++) {
-        hit = (AliMUONHitForRec*) (*track2->GetTrackHits())[j];
-        if (hit == hit1 || hit == hit2) {
-          nSame++;
-          if (nSame == 2) return kFALSE;
-        }
-      } // for (Int_t j=0;
-    }
-  } // for (Int_t i=0;
-  return kTRUE;
-}
-
-//__________________________________________________________________________
-void AliMUONTrackReconstructor::RemoveDoubleTracksK(void)
-{
-  // Removes double tracks (sharing more than half of their hits). Keeps
-  // the track with higher quality
-  AliMUONTrackK *track1, *track2, *trackToKill;
-
-  // Sort tracks according to their quality
-  fRecTracksPtr->Sort();
-
-  // Loop over first track of the pair
-  track1 = (AliMUONTrackK*) fRecTracksPtr->First();
-  Int_t debug = track1->DebugLevel();
-  while (track1) {
-    // Loop over second track of the pair
-    track2 = (AliMUONTrackK*) fRecTracksPtr->After(track1);
-    while (track2) {
-      // Check whether or not to keep track2
-      if (!track2->KeepTrack(track1)) {
-        if (debug >= 0) cout << " Killed track: " << 1/(*track2->GetTrackParameters())(4,0) <<
-         " " << track2->GetTrackQuality() << endl;
-        trackToKill = track2;
-        track2 = (AliMUONTrackK*) fRecTracksPtr->After(track2);
-        trackToKill->Kill();
-        fRecTracksPtr->Compress();
-      } else track2 = (AliMUONTrackK*) fRecTracksPtr->After(track2);
-    } // track2
-    track1 = (AliMUONTrackK*) fRecTracksPtr->After(track1);
-  } // track1
-
-  fNRecTracks = fRecTracksPtr->GetEntriesFast();
-  if (debug >= 0) cout << " Number of Kalman tracks: " << fNRecTracks << endl;
-}
-
-//__________________________________________________________________________
-void AliMUONTrackReconstructor::GoToVertex(void)
-{
-  // Propagates track to the vertex thru absorber
-  // (using Branson correction for now)
-
-  Double_t zVertex;
-  zVertex = 0;
-  for (Int_t i=0; i<fNRecTracks; i++) {
-    //((AliMUONTrackK*)(*fRecTracksPtr)[i])->Branson();
-    ((AliMUONTrackK*)(*fRecTracksPtr)[i])->SetTrackQuality(1); // compute Chi2
-    //((AliMUONTrackK*)(*fRecTracksPtr)[i])->GoToZ(zVertex); // w/out absorber
-    ((AliMUONTrackK*)(*fRecTracksPtr)[i])->GoToVertex(1); // with absorber
-  }
-}
-
-//__________________________________________________________________________
-void AliMUONTrackReconstructor::SetTrackMethod(Int_t iTrackMethod)
-{
-  // Set track method and recreate track container if necessary
-  
-  fTrackMethod = TMath::Min (iTrackMethod, 3);
-  fTrackMethod = TMath::Max (fTrackMethod, 1);
-  if (fTrackMethod != 1) {
-    if (fRecTracksPtr) delete fRecTracksPtr;
-    fRecTracksPtr = new TClonesArray("AliMUONTrackK", 10);
-    if (fTrackMethod == 2) cout << " *** Tracking with the Kalman filter *** " << endl;
-    else cout << " *** Combined cluster / track finder ***" << endl;
-  } else cout << " *** Original tracking *** " << endl;
-
-}
index 189ab4c..79da29a 100644 (file)
 
 /// \ingroup rec
 /// \class AliMUONTrackReconstructor
-/// \brief Class for the MUON track reconstruction
+/// \brief Standard class for the MUON track reconstruction
 ///
-/////////////////////////////////////
-/// MUON track reconstructor in ALICE
-/////////////////////////////////////
+//////////////////////////////////////////////
+/// Standard MUON track reconstructor in ALICE
+//////////////////////////////////////////////
 
 #include <TObject.h>
-#include "AliMUONConstants.h"
+#include "AliMUONVTrackReconstructor.h"
 
-class AliMUONHitForRec;
 class AliMUONSegment;
-class TClonesArray;
-class TFile;
-class TTree;
-class AliMUONData;
-class AliRunLoader;
-class AliMUONTriggerTrack;
 class AliMUONTrack;
 class TVirtualFitter;
 
-class AliMUONTrackReconstructor : public TObject {
+class AliMUONTrackReconstructor : public AliMUONVTrackReconstructor {
 
  public:
   AliMUONTrackReconstructor(AliMUONData* data); // default Constructor
   virtual ~AliMUONTrackReconstructor(); // Destructor
 
-  // Parameters for track reconstruction: public methods
-  // Get and Set, Set to defaults
-
-           /// Return minimum value (GeV/c) of momentum in bending plane
-  Double_t GetMinBendingMomentum(void) const {return fMinBendingMomentum;}
-           /// Set minimum value (GeV/c) of momentum in bending plane
-  void SetMinBendingMomentum(Double_t MinBendingMomentum) {fMinBendingMomentum = MinBendingMomentum;}
-
-           /// Return maximum value (GeV/c) of momentum in bending plane
-  Double_t GetMaxBendingMomentum(void) const {return fMaxBendingMomentum;}
-           /// Set maximum value (GeV/c) of momentum in bending plane
-  void SetMaxBendingMomentum(Double_t MaxBendingMomentum) {fMaxBendingMomentum = MaxBendingMomentum;}
-
-           /// Return maximum Chi2 per degree of Freedom
-  Double_t GetMaxChi2(void) const {return fMaxChi2;}
-           /// Set maximum Chi2 per degree of Freedom
-  void SetMaxChi2(Double_t MaxChi2) {fMaxChi2 = MaxChi2;}
-
-           /// Return maximum square distance in units of the variance (maximum chi2)
-  Double_t GetMaxSigma2Distance(void) const {return fMaxSigma2Distance;}
-           /// Set maximum square distance in units of the variance (maximum chi2)
-  void SetMaxSigma2Distance(Double_t MaxSigma2Distance) {fMaxSigma2Distance = MaxSigma2Distance;}
-
-           /// Return chamber resolution (cm) in bending plane
-  Double_t GetBendingResolution(void) const {return fBendingResolution;}
-           /// Set chamber resolution (cm) in bending plane
-  void SetBendingResolution(Double_t BendingResolution) {fBendingResolution = BendingResolution;}
-
-           /// Return chamber resolution (cm) in non-bending plane
-  Double_t GetNonBendingResolution(void) const {return fNonBendingResolution;}
-           /// set chamber resolution (cm) in non-bending plane
-  void SetNonBendingResolution(Double_t NonBendingResolution) {fNonBendingResolution = NonBendingResolution;}
-
-           /// Return chamber thickness in number of radiation lengths
-  Double_t GetChamberThicknessInX0(void) const {return fChamberThicknessInX0;}
-           /// Set chamber thickness in number of radiation lengths
-  void SetChamberThicknessInX0(Double_t ChamberThicknessInX0) {fChamberThicknessInX0 = ChamberThicknessInX0;}
-
-           /// Return simple magnetic field: value (kG)
-  Double_t GetSimpleBValue(void) const {return fSimpleBValue;}
-           /// Set simple magnetic field: value (kG)
-  void SetSimpleBValue(Double_t SimpleBValue) {fSimpleBValue = SimpleBValue;}
-
-           /// Return simple magnetic field: length (cm)
-  Double_t GetSimpleBLength(void) const {return fSimpleBLength;}
-           /// Set simple magnetic field: length (cm)
-  void SetSimpleBLength(Double_t SimpleBLength) {fSimpleBLength = SimpleBLength;}
-
-           /// Return simple magnetic field: Z central position (cm)
-  Double_t GetSimpleBPosition(void) const {return fSimpleBPosition;}
-           /// Set simple magnetic field: Z central position (cm)
-  void SetSimpleBPosition(Double_t SimpleBPosition) {fSimpleBPosition = SimpleBPosition;}
-
-           /// Return chamber efficiency (used for track ref. hits only
-  Double_t GetEfficiency(void) const {return fEfficiency;}
-           /// Set chamber efficiency (used for track ref. hits only
-  void SetEfficiency(Double_t Efficiency) {fEfficiency = Efficiency;}
-
-  void SetReconstructionParametersToDefaults(void);
-
            /// Return track fitter
   static TVirtualFitter* Fitter(void) {return fgFitter;}
+  
+  virtual void EventDump(void);  // dump reconstructed event
 
-           /// Return number of hits for reconstruction
-  Int_t GetNHitsForRec(void) const {return fNHitsForRec;} // Number
 
-           /// Return number of reconstructed tracks
-  Int_t GetNRecTracks() const {return fNRecTracks;} // Number
-           /// Set number of reconstructed tracks
-  void SetNRecTracks(Int_t NRecTracks) {fNRecTracks = NRecTracks;}
+ protected:
 
-           /// Return array of reconstructed tracks
-  TClonesArray* GetRecTracksPtr(void) const {return fRecTracksPtr;} // Array
   // Functions
-  Double_t GetImpactParamFromBendingMomentum(Double_t BendingMomentum) const;
-  Double_t GetBendingMomentumFromImpactParam(Double_t ImpactParam) const;
-  void EventReconstruct(void);
-  void EventReconstructTrigger(void);
-  void EventDump(void);  // dump reconstructed event
-  void EventDumpTrigger(void);  // dump reconstructed trigger event
-  //PH  void FillEvent();      // fill and write tree of reconstructed events
-  void SetTrackMethod(Int_t iTrackMethod); //AZ
-          /// Return track method
-  Int_t GetTrackMethod(void) const {return fTrackMethod;}   
-  void FillMUONTrack(void); // set track parameters at hits for Kalman track
-  //Int_t fMuons; // AZ - number of muons within acceptance - just for tests
-
-          /// Return MUON data
-  AliMUONData*  GetMUONData() {return fMUONData;}
-
-          /// Set trigger circuit
-  void SetTriggerCircuit(TClonesArray* circuit) {fTriggerCircuit = circuit;}
-
+  virtual void AddHitsForRecFromRawClusters();
+  virtual void MakeSegments(void);
+  virtual void MakeTracks(void);
+  virtual void MakeTrackCandidates(void);
+  virtual void FollowTracks(void);
+  virtual void RemoveDoubleTracks(void);
+  
 
  private:
-
+  
   // Defaults parameters for reconstruction
-  static const Double_t fgkDefaultMinBendingMomentum; ///< default min. bending momentum for reconstruction
-  static const Double_t fgkDefaultMaxBendingMomentum; ///< default max. bending momentum for reconstruction
   static const Double_t fgkDefaultMaxChi2; ///< default max. track chi2 for reconstruction
-  static const Double_t fgkDefaultMaxSigma2Distance; ///< default square of max. distance for window size 
-  static const Double_t fgkDefaultBendingResolution; ///< default bending coordinate resolution for reconstruction 
-  static const Double_t fgkDefaultNonBendingResolution; ///< default non bending coordinate resolution for reconstruction
-  // Simple magnetic field:
-  // Value taken from macro MUONtracking.C: 0.7 T, hence 7 kG
-  // Length and Position from reco_muon.F, with opposite sign:
-  // Length = ZMAGEND-ZCOIL
-  // Position = (ZMAGEND+ZCOIL)/2
-  // to be ajusted differently from real magnetic field ????
-  static const Double_t fgkDefaultSimpleBValue; ///< default value of magnetic field (dipole)
-  static const Double_t fgkDefaultSimpleBLength; ///< default length of magnetic field (dipole)
-  static const Double_t fgkDefaultSimpleBPosition; ///< default position of magnetic field (dipole)
-  static const Double_t fgkDefaultEfficiency; ///< default chamber efficiency for track ref. hits recontruction
 
   static TVirtualFitter* fgFitter; //!< Pointer to track fitter
 
-  Int_t fTrackMethod; ///< AZ - tracking method
-
-  // Parameters for track reconstruction
-  Double_t fMinBendingMomentum; ///< minimum value (GeV/c) of momentum in bending plane
   // Parameters for track reconstruction
-  Double_t fMaxBendingMomentum; ///< maximum value (GeV/c) of momentum in bending plane
   Double_t fMaxChi2; ///< maximum Chi2 per degree of Freedom
-  Double_t fMaxSigma2Distance; ///< maximum square distance in units of the variance (maximum chi2)
-  Double_t* fRMin; ///< minimum radius (cm)
-  Double_t* fRMax; ///< maximum radius (cm)
-  Double_t* fSegmentMaxDistBending; ///< maximum distance (cm) for segments in bending plane
-  Double_t* fSegmentMaxDistNonBending; ///< maximum distance (cm) for segments in non bending plane
-  Double_t fBendingResolution; ///< chamber resolution (cm) in bending plane
-  Double_t fNonBendingResolution; ///< chamber resolution (cm) in non bending plane
-  Double_t fChamberThicknessInX0; ///< chamber thickness in number of radiation lengths
-                                  // how to take it from simulation ????
-  Double_t fSimpleBValue; ///< simple magnetic field: value (kG)
-  Double_t fSimpleBLength; ///< simple magnetic field: length (cm)
-  Double_t fSimpleBPosition; ///< simple magnetic field: Z central position (cm)
-  Double_t fEfficiency; ///< chamber efficiency (used for track ref. hits only)
   
-  // Hits for reconstruction (should be in AliMUON ????)
-  TClonesArray* fHitsForRecPtr; ///< pointer to the array of hits for reconstruction
-  Int_t fNHitsForRec; ///< number of hits for reconstruction
-  // Information per chamber (should be in AliMUONChamber ????)
-  Int_t* fNHitsForRecPerChamber; ///< number of HitsForRec
-  Int_t* fIndexOfFirstHitForRecPerChamber; ///< index (0...) of first HitForRec
-
-  // Segments inside a station
-  TClonesArray** fSegmentsPtr; ///< array of pointers to the segments for each station
-  Int_t* fNSegments; ///< number of segments for each station
-
-  // Reconstructed tracks
-  TClonesArray *fRecTracksPtr; ///< pointer to array of reconstructed tracks
-  Int_t fNRecTracks; ///< number of reconstructed tracks
-
-  // data container
-  AliMUONData* fMUONData; ///< Data container for MUON subsystem 
-
-  Int_t fMuons; ///< AZ - number of muons within acceptance - just for tests
-
-  AliMUONTriggerTrack* fTriggerTrack; ///< Trigger track structure
-
-  TClonesArray* fTriggerCircuit;      //!< trigger circuit array
-
   // Functions
-  AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); // copy constructor
-  AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs); // assignment operator
-  void ResetHitsForRec(void);
-  void MakeEventToBeReconstructed(void);
-  void AddHitsForRecFromRawClusters(TTree* TR);
-  void SortHitsForRecWithIncreasingChamber();
-  void MakeSegments(void);
-  void ResetSegments(void);
-  void MakeSegmentsPerStation(Int_t Station);
-  void MakeTracks(void);
-  Bool_t MakeTriggerTracks(void);
-  void ResetTracks(void);
-  void MakeTrackCandidates(void);
+  AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); ///< copy constructor
+  AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs); ///< assignment operator
+  
   Int_t MakeTrackCandidatesWithTwoSegments(AliMUONSegment *BegSegment);
   Int_t MakeTrackCandidatesWithOneSegmentAndOnePoint(AliMUONSegment *BegSegment);
-  void CalcTrackParamAtVertex(AliMUONTrack *Track);
-  void FollowTracks(void);
+  void CalcTrackParamAtVertex(AliMUONTrack *Track) const;
   void Fit(AliMUONTrack *Track, Int_t FitStart, Int_t FitMCS);
-  void RemoveDoubleTracks(void);
   void UpdateHitForRecAtHit(void);
-  void ValidateTracksWithTrigger(void);
-
-
-  //AZ - for Kalman Filter
-  void MakeTrackCandidatesK(void);
-  void FollowTracksK(void);
-  void RemoveDoubleTracksK(void);
-  void GoToVertex(void);
-  Bool_t CheckCandidateK(Int_t icand, Int_t nSeeds) const;
 
 
   ClassDef(AliMUONTrackReconstructor, 0) // MUON track reconstructor in ALICE
index 128daca..1e5360b 100644 (file)
@@ -11,7 +11,9 @@
 #pragma link C++ class AliMUONPixel+; 
 #pragma link C++ class AliMUONClusterInput+; 
 #pragma link C++ class AliMUONReconstructor+;
+#pragma link C++ class AliMUONVTrackReconstructor+; 
 #pragma link C++ class AliMUONTrackReconstructor+; 
+#pragma link C++ class AliMUONTrackReconstructorK+; 
 #pragma link C++ class AliMUONTrack+; 
 #pragma link C++ class AliMUONTrackK+; 
 #pragma link C++ class AliMUONTrackParam+; 
index 2520ff2..65ed2f0 100644 (file)
@@ -7,7 +7,9 @@ SRCS:= AliMUONClusterReconstructor.cxx \
        AliMUONPixel.cxx \
        AliMUONClusterInput.cxx \
        AliMUONReconstructor.cxx \
+       AliMUONVTrackReconstructor.cxx \
        AliMUONTrackReconstructor.cxx \
+       AliMUONTrackReconstructorK.cxx \
        AliMUONTrack.cxx \
        AliMUONTrackK.cxx \
        AliMUONTrackParam.cxx \