Adding MFT (Antonio)
authorhristov <Peter.Hristov@cern.ch>
Tue, 4 Feb 2014 16:54:44 +0000 (17:54 +0100)
committerhristov <Peter.Hristov@cern.ch>
Tue, 4 Feb 2014 16:54:44 +0000 (17:54 +0100)
STEER/CMakelibESD.pkg
STEER/ESD/AliESDEvent.cxx
STEER/ESD/AliESDEvent.h
STEER/ESD/AliESDMuonGlobalTrack.cxx [new file with mode: 0644]
STEER/ESD/AliESDMuonGlobalTrack.h [new file with mode: 0644]
STEER/ESDLinkDef.h
STEER/STEER/AliReconstruction.cxx
STEER/STEER/AliReconstruction.h

index 2263b92..2d1caea 100644 (file)
@@ -9,6 +9,7 @@ set ( SRCS
     ESD/AliESDtrack.cxx 
     ESD/AliESDfriendTrack.cxx 
     ESD/AliESDMuonTrack.cxx 
+    ESD/AliESDMuonGlobalTrack.cxx 
     ESD/AliESDPmdTrack.cxx 
     ESD/AliESDTrdTrack.cxx 
     ESD/AliESDTrdTracklet.cxx 
index 5f72ac6..a92cc2e 100644 (file)
@@ -46,6 +46,7 @@
 #include "AliESDMuonTrack.h"
 #include "AliESDMuonCluster.h"
 #include "AliESDMuonPad.h"
+#include "AliESDMuonGlobalTrack.h"       // AU
 #include "AliESDPmdTrack.h"
 #include "AliESDTrdTrack.h"
 #include "AliESDVertex.h"
@@ -103,6 +104,7 @@ ClassImp(AliESDEvent)
                                                        "MuonTracks",
                                                        "MuonClusters",
                                                        "MuonPads",
+                                                       "MuonGlobalTracks",      // AU
                                                        "PmdTracks",
                                                        "AliESDTrdTrigger",
                                                        "TrdTracks",
@@ -144,6 +146,7 @@ AliESDEvent::AliESDEvent():
   fMuonTracks(0),
   fMuonClusters(0),
   fMuonPads(0),
+  fMuonGlobalTracks(0),    // AU
   fPmdTracks(0),
   fTrdTracks(0),
   fTrdTracklets(0),
@@ -194,6 +197,7 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd):
   fMuonTracks(new TClonesArray(*esd.fMuonTracks)),
   fMuonClusters(new TClonesArray(*esd.fMuonClusters)),
   fMuonPads(new TClonesArray(*esd.fMuonPads)),
+  fMuonGlobalTracks(new TClonesArray(*esd.fMuonGlobalTracks)),     // AU
   fPmdTracks(new TClonesArray(*esd.fPmdTracks)),
   fTrdTracks(new TClonesArray(*esd.fTrdTracks)),
   fTrdTracklets(new TClonesArray(*esd.fTrdTracklets)),
@@ -239,6 +243,7 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd):
   AddObject(fTrkPileupVertices);
   AddObject(fTracks);
   AddObject(fMuonTracks);
+  AddObject(fMuonGlobalTracks);    // AU
   AddObject(fPmdTracks);
   AddObject(fTrdTracks);
   AddObject(fTrdTracklets);
@@ -533,6 +538,7 @@ void AliESDEvent::ResetStdContent()
   if(fMuonTracks)fMuonTracks->Clear("C");
   if(fMuonClusters)fMuonClusters->Clear("C");
   if(fMuonPads)fMuonPads->Clear("C");
+  if(fMuonGlobalTracks)fMuonGlobalTracks->Clear("C");     // AU
   if(fPmdTracks)fPmdTracks->Delete();
   if(fTrdTracks)fTrdTracks->Delete();
   if(fTrdTracklets)fTrdTracklets->Delete();
@@ -610,6 +616,7 @@ void AliESDEvent::Print(Option_t *) const
   printf("Number of tracks: \n");
   printf("                 charged   %d\n", GetNumberOfTracks());
   printf("                 muon      %d\n", GetNumberOfMuonTracks());
+  printf("                 glob muon %d\n", GetNumberOfMuonGlobalTracks());    // AU
   printf("                 pmd       %d\n", GetNumberOfPmdTracks());
   printf("                 trd       %d\n", GetNumberOfTrdTracks());
   printf("                 trd trkl  %d\n", GetNumberOfTrdTracklets());
@@ -1084,6 +1091,16 @@ AliESDMuonTrack* AliESDEvent::GetMuonTrack(Int_t i)
 }
 
 //______________________________________________________________________________
+AliESDMuonGlobalTrack* AliESDEvent::GetMuonGlobalTrack(Int_t i)                      // AU
+{
+  // get the MUON+MFT track at the position i in the internal array of track
+  if (!fMuonGlobalTracks) return 0x0;
+  AliESDMuonGlobalTrack *track = (AliESDMuonGlobalTrack*) fMuonGlobalTracks->UncheckedAt(i);
+  track->SetESDEvent(this);
+  return track;
+}
+
+//______________________________________________________________________________
 void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t) 
 {
   // add a MUON track
@@ -1093,6 +1110,15 @@ void AliESDEvent::AddMuonTrack(const AliESDMuonTrack *t)
 }
 
 //______________________________________________________________________________
+void AliESDEvent::AddMuonGlobalTrack(const AliESDMuonGlobalTrack *t)                             // AU
+{
+  // add a MUON+MFT track
+  TClonesArray &fmu = *fMuonGlobalTracks;
+  new (fmu[fMuonGlobalTracks->GetEntriesFast()]) AliESDMuonGlobalTrack(*t);
+}
+
+//______________________________________________________________________________
+
 AliESDMuonTrack* AliESDEvent::NewMuonTrack() 
 {
   // create a new MUON track at the end of the internal array of track
@@ -1101,6 +1127,14 @@ AliESDMuonTrack* AliESDEvent::NewMuonTrack()
 }
 
 //______________________________________________________________________________
+AliESDMuonGlobalTrack* AliESDEvent::NewMuonGlobalTrack()                                         // AU
+{
+  // create a new MUON+MFT track at the end of the internal array of track
+  TClonesArray &fmu = *fMuonGlobalTracks;
+  return new(fmu[fMuonGlobalTracks->GetEntriesFast()]) AliESDMuonGlobalTrack();
+}
+
+//______________________________________________________________________________
 Int_t AliESDEvent::GetNumberOfMuonClusters()
 {
   // get the number of MUON clusters
@@ -1424,6 +1458,7 @@ void AliESDEvent::GetStdContent()
   fMuonTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonTracks]);
   fMuonClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonClusters]);
   fMuonPads = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonPads]);
+  fMuonGlobalTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kMuonGlobalTracks]);         // AU
   fPmdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kPmdTracks]);
   fTrdTrigger = (AliESDTrdTrigger*)fESDObjects->FindObject(fgkESDListName[kTrdTrigger]);
   fTrdTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTrdTracks]);
@@ -1490,6 +1525,7 @@ void AliESDEvent::CreateStdContent()
   AddObject(new TClonesArray("AliESDMuonTrack",0));
   AddObject(new TClonesArray("AliESDMuonCluster",0));
   AddObject(new TClonesArray("AliESDMuonPad",0));
+  AddObject(new TClonesArray("AliESDMuonGlobalTrack",0));   // AU
   AddObject(new TClonesArray("AliESDPmdTrack",0));
   AddObject(new AliESDTrdTrigger());
   AddObject(new TClonesArray("AliESDTrdTrack",0));
index b16fd19..f92a027 100644 (file)
@@ -61,6 +61,7 @@ class AliESDTrdTracklet;
 class AliESDMuonTrack;
 class AliESDMuonCluster;
 class AliESDMuonPad;
+class AliESDMuonGlobalTrack;    // AU
 class AliESD;
 class AliESDcascade;
 class AliCentrality;
@@ -74,6 +75,7 @@ class AliESDCosmicTrack;
 class TList;
 class TString;
 
+
 class AliESDEvent : public AliVEvent {
 public:
 
@@ -96,6 +98,7 @@ public:
                       kMuonTracks,
                       kMuonClusters,
                       kMuonPads,
+                      kMuonGlobalTracks,   // AU
                       kPmdTracks,
                       kTrdTrigger,
                       kTrdTracks,
@@ -372,6 +375,9 @@ public:
   AliESDMuonPad* FindMuonPad(UInt_t padId);
   AliESDMuonPad* NewMuonPad();
   
+  AliESDMuonGlobalTrack* GetMuonGlobalTrack(Int_t i);      // AU
+  AliESDMuonGlobalTrack* NewMuonGlobalTrack();             // AU
+  
   AliESDPmdTrack *GetPmdTrack(Int_t i) const {
     return (AliESDPmdTrack *)(fPmdTracks?fPmdTracks->At(i):0x0);
   }
@@ -461,6 +467,7 @@ public:
   Int_t GetNumberOfMuonTracks() const {return fMuonTracks?fMuonTracks->GetEntriesFast():0;}
   Int_t GetNumberOfMuonClusters();
   Int_t GetNumberOfMuonPads();
+  Int_t GetNumberOfMuonGlobalTracks() const {return fMuonGlobalTracks?fMuonGlobalTracks->GetEntriesFast():0;}    // AU
   Int_t GetNumberOfPmdTracks() const {return fPmdTracks?fPmdTracks->GetEntriesFast():0;}
   Int_t GetNumberOfTrdTracks() const {return fTrdTracks?fTrdTracks->GetEntriesFast():0;}
   Int_t GetNumberOfTrdTracklets() const {return fTrdTracklets?fTrdTracklets->GetEntriesFast():0;}
@@ -517,6 +524,7 @@ protected:
   static Bool_t ResetWithPlacementNew(TObject *pObject);
 
   void AddMuonTrack(const AliESDMuonTrack *t);
+  void AddMuonGlobalTrack(const AliESDMuonGlobalTrack *t);     // AU
   
   TList *fESDObjects;             // List of esd Objects
 
@@ -542,6 +550,7 @@ protected:
   TClonesArray *fMuonTracks;       //! MUON ESD tracks
   TClonesArray *fMuonClusters;     //! MUON ESD clusters
   TClonesArray *fMuonPads;         //! MUON ESD pads
+  TClonesArray *fMuonGlobalTracks; //! MUON+MFT ESD tracks      // AU
   TClonesArray *fPmdTracks;        //! PMD ESD tracks
   TClonesArray *fTrdTracks;        //! TRD ESD tracks (triggered)
   TClonesArray *fTrdTracklets;     //! TRD tracklets (for trigger)
@@ -577,7 +586,7 @@ protected:
   Int_t fNTOFclusters;     //! N TOF clusters matchable
   TObjArray *fTOFcluster; //! TOF clusters
 
-  ClassDef(AliESDEvent,20)  //ESDEvent class 
+  ClassDef(AliESDEvent,21)  //ESDEvent class 
 };
 #endif 
 
diff --git a/STEER/ESD/AliESDMuonGlobalTrack.cxx b/STEER/ESD/AliESDMuonGlobalTrack.cxx
new file mode 100644 (file)
index 0000000..0ec2f21
--- /dev/null
@@ -0,0 +1,168 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+//====================================================================================================================================================
+//
+//      ESD description of an ALICE muon forward track, combining the information of the Muon Spectrometer and the Muon Forward Tracker
+//
+//      Contact author: antonio.uras@cern.ch
+//
+//====================================================================================================================================================
+
+#include "AliESDMuonGlobalTrack.h"
+#include "AliESDEvent.h"
+
+#include "TClonesArray.h"
+#include "TLorentzVector.h"
+#include "TMath.h"
+#include "TDatabasePDG.h"
+
+ClassImp(AliESDMuonGlobalTrack)
+
+//====================================================================================================================================================
+
+AliESDMuonGlobalTrack::AliESDMuonGlobalTrack():
+  AliVParticle(),
+  fCharge(0),
+  fMatchTrigger(0),
+  fPx(0), 
+  fPy(0), 
+  fPz(0), 
+  fPt(0), 
+  fP(0), 
+  fEta(0), 
+  fRapidity(0),
+  fChi2(0),
+  fChi2MatchTrigger(0),
+  fLabel(-1),
+  fESDEvent(0)
+{
+
+  //  Default constructor
+
+}
+
+//====================================================================================================================================================
+
+AliESDMuonGlobalTrack::AliESDMuonGlobalTrack(Double_t px, Double_t py, Double_t pz):
+  AliVParticle(),
+  fCharge(0),
+  fMatchTrigger(0),
+  fPx(0), 
+  fPy(0), 
+  fPz(0), 
+  fPt(0), 
+  fP(0), 
+  fEta(0), 
+  fRapidity(0),
+  fChi2(0),
+  fChi2MatchTrigger(0),
+  fLabel(-1),
+  fESDEvent(0)
+{
+
+  //  Constructor with kinematics
+
+  SetPxPyPz(px, py, pz);
+
+}
+
+//====================================================================================================================================================
+
+AliESDMuonGlobalTrack::AliESDMuonGlobalTrack(const AliESDMuonGlobalTrack& muonTrack):
+  AliVParticle(muonTrack),
+  fCharge(muonTrack.fCharge),
+  fMatchTrigger(muonTrack.fMatchTrigger),
+  fPx(muonTrack.fPx), 
+  fPy(muonTrack.fPy), 
+  fPz(muonTrack.fPz), 
+  fPt(muonTrack.fPt), 
+  fP(muonTrack.fP), 
+  fEta(muonTrack.fEta), 
+  fRapidity(muonTrack.fRapidity),
+  fChi2(muonTrack.fChi2),
+  fChi2MatchTrigger(muonTrack.fChi2MatchTrigger),
+  fLabel(muonTrack.fLabel),
+  fESDEvent(muonTrack.fESDEvent)
+{
+
+  // Copy constructor
+  
+}
+
+//====================================================================================================================================================
+
+AliESDMuonGlobalTrack& AliESDMuonGlobalTrack::operator=(const AliESDMuonGlobalTrack& muonTrack) {
+
+  // Assignment operator
+
+  if (this == &muonTrack) return *this;
+
+  // Base class assignement
+  AliVParticle::operator=(muonTrack);
+
+  fCharge           = muonTrack.fCharge;
+  fMatchTrigger     = muonTrack.fMatchTrigger;
+  fPx               = muonTrack.fPx; 
+  fPy               = muonTrack.fPy; 
+  fPz               = muonTrack.fPz; 
+  fPt               = muonTrack.fPt; 
+  fP                = muonTrack.fP;
+  fEta              = muonTrack.fEta;
+  fRapidity         = muonTrack.fRapidity;
+  fChi2             = muonTrack.fChi2;
+  fChi2MatchTrigger = muonTrack.fChi2MatchTrigger;
+  fLabel            = muonTrack.fLabel;
+  fESDEvent         = muonTrack.fESDEvent;
+
+  return *this;
+
+}
+
+//====================================================================================================================================================
+
+void AliESDMuonGlobalTrack::Copy(TObject &obj) const {
+  
+  // This overwrites the virtual TObject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if (this==&obj) return;
+  AliESDMuonGlobalTrack *robj = dynamic_cast<AliESDMuonGlobalTrack*>(&obj);
+  if (!robj) return; // not an AliESDMuonGlobalTrack
+  *robj = *this;
+
+}
+
+//====================================================================================================================================================
+
+void AliESDMuonGlobalTrack::SetPxPyPz(Double_t px, Double_t py, Double_t pz) {
+
+  Double_t mMu = TDatabasePDG::Instance()->GetParticle("mu-")->Mass();
+  Double_t eMu = TMath::Sqrt(mMu*mMu + px*px + py*py + pz*pz);
+
+  TLorentzVector kinem(px, py, pz, eMu);
+
+  fPx       =  kinem.Px();
+  fPy       =  kinem.Py();
+  fPz       =  kinem.Pz();
+  fP        =  kinem.P();
+  fPt       =  kinem.Pt();
+  fEta      =  kinem.Eta();
+  fRapidity =  kinem.Rapidity(); 
+
+}
+
+//====================================================================================================================================================
diff --git a/STEER/ESD/AliESDMuonGlobalTrack.h b/STEER/ESD/AliESDMuonGlobalTrack.h
new file mode 100644 (file)
index 0000000..7b096e9
--- /dev/null
@@ -0,0 +1,114 @@
+#ifndef AliESDMuonGlobalTrack_H
+#define AliESDMuonGlobalTrack_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+//====================================================================================================================================================
+//
+//      ESD description of an ALICE muon forward track, combining the information of the Muon Spectrometer and the Muon Forward Tracker
+//
+//      Contact author: antonio.uras@cern.ch
+//
+//====================================================================================================================================================
+
+#include "TMath.h"
+#include "TMatrixD.h"
+#include "TDatabasePDG.h"
+#include "TArrayI.h"
+#include "TLorentzVector.h"
+
+#include "AliVParticle.h"
+
+class AliESDEvent;
+class TClonesArray;
+
+//====================================================================================================================================================
+
+class AliESDMuonGlobalTrack : public AliVParticle {
+
+public:
+
+  AliESDMuonGlobalTrack();
+  AliESDMuonGlobalTrack(Double_t px, Double_t py, Double_t pz);
+  virtual ~AliESDMuonGlobalTrack() {;}
+  AliESDMuonGlobalTrack(const AliESDMuonGlobalTrack& esdTrack);
+  AliESDMuonGlobalTrack& operator=(const AliESDMuonGlobalTrack& esdTrack);
+  virtual void Copy(TObject &obj) const;
+
+  void  SetCharge(Int_t charge) { fCharge = charge; } 
+  Short_t GetCharge() const { return fCharge; }
+
+  /* Double_t GetOffset(Double_t x, Double_t y, Double_t z); */
+  /* Double_t GetOffsetX(Double_t x, Double_t z); */
+  /* Double_t GetOffsetY(Double_t y, Double_t z); */
+
+  // Set and Get methods for kinematics at primary vertex
+  void SetPxPyPz(Double_t px, Double_t py, Double_t pz);
+
+  // Get and Set methods for global tracking info
+  Double_t GetChi2(void) const {return fChi2;}        // chi2/ndf
+  void     SetChi2(Double_t Chi2) {fChi2 = Chi2;}     // chi2/ndf
+  
+  // Get and Set methods for trigger matching
+  void  SetMatchTrigger(Int_t matchTrigger) { fMatchTrigger = matchTrigger; }
+  Int_t GetMatchTrigger() { return fMatchTrigger; }
+
+  // Kinematics
+  Double_t Pt()       const { return fPt;  }
+  Double_t Eta()      const { return fEta; }
+  Double_t Rapidity() const { return fRapidity; }
+  Double_t Px()       const { return fPx; }
+  Double_t Py()       const { return fPy; }
+  Double_t Pz()       const { return fPz; }
+  Double_t P()        const { return fP;  }
+
+  Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
+
+  // Additional methods to comply with AliVParticle
+  Double_t Xv() const {return -999.;} // put reasonable values here
+  Double_t Yv() const {return -999.;} //
+  Double_t Zv() const {return -999.;} //
+  Bool_t   XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }  
+  Double_t OneOverPt() const { return (Pt() != 0.) ? 1./Pt() : FLT_MAX; }
+  Double_t Phi() const { return TMath::Pi()+TMath::ATan2(-Py(), -Px()); }
+  Double_t Theta() const { return TMath::ATan2(Pt(), Pz()); }
+  Double_t E() const { return TMath::Sqrt(M()*M() + P()*P()); }
+  Double_t M() const { return TDatabasePDG::Instance()->GetParticle("mu-")->Mass(); }
+  Double_t Y() const { return Rapidity(); }
+  Short_t  Charge() const { return fCharge; }
+
+  // Dummy
+  const Double_t *PID() const { return (Double_t*)0x0; }
+  Int_t PdgCode() const { return 0; }
+  
+  // Set the corresponding MC track number
+  void  SetLabel(Int_t label) { fLabel = label; }
+  // Return the corresponding MC track number
+  Int_t GetLabel() const { return fLabel; }
+
+  AliESDEvent* GetESDEvent() const { return fESDEvent; }
+  void         SetESDEvent(AliESDEvent* evt) { fESDEvent = evt; }  
+  
+protected:
+
+  Short_t fCharge, fMatchTrigger;
+
+  // kinematics at vertex
+  Double_t fPx, fPy, fPz, fPt, fP, fEta, fRapidity;
+
+  // global tracking info
+  Double_t fChi2;                 //  chi2 in the MUON+MFT track fit
+  Double_t fChi2MatchTrigger;     //  chi2 of trigger/track matching
+
+  Int_t fLabel;                   //  point to the corresponding MC track
+
+  AliESDEvent *fESDEvent;         //! Pointer back to event to which the track belongs
+  
+  ClassDef(AliESDMuonGlobalTrack,1) // MUON+MFT ESD track class 
+
+};
+
+//====================================================================================================================================================
+
+#endif 
index 7b660f7..791fd5b 100644 (file)
@@ -161,4 +161,5 @@ code="{fTrackTime = new Double32_t[AliPID::kSPECIESC];for(Int_t isp=AliPID::kSPE
 #pragma link C++ function operator+(const AliFMDMap&,const AliFMDMap&);
 #pragma link C++ function operator-(const AliFMDMap&,const AliFMDMap&);
   
+#pragma link C++ class  AliESDMuonGlobalTrack+;  
 #endif
index ae3c396..0491320 100644 (file)
@@ -219,6 +219,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename) :
   fRunVertexFinder(kTRUE),
   fRunVertexFinderTracks(kTRUE),
   fRunMuonTracking(kFALSE),
+  fRunMFTTrackingMU(kFALSE),
   fRunV0Finder(kTRUE),
   fRunCascadeFinder(kTRUE),
   fRunMultFinder(kTRUE),
@@ -352,6 +353,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   fRunVertexFinder(rec.fRunVertexFinder),
   fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
   fRunMuonTracking(rec.fRunMuonTracking),
+  fRunMFTTrackingMU(rec.fRunMFTTrackingMU),
   fRunV0Finder(rec.fRunV0Finder),
   fRunCascadeFinder(rec.fRunCascadeFinder),
   fRunMultFinder(rec.fRunMultFinder),
@@ -501,6 +503,7 @@ AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
   fRunVertexFinder       = rec.fRunVertexFinder;
   fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
   fRunMuonTracking       = rec.fRunMuonTracking;
+  fRunMFTTrackingMU      = rec.fRunMFTTrackingMU;
   fRunV0Finder           = rec.fRunV0Finder;
   fRunCascadeFinder      = rec.fRunCascadeFinder;
   fRunMultFinder         = rec.fRunMultFinder;
@@ -2120,6 +2123,20 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
       AliSysInfo::AddStamp(Form("TrackingMUON_%d",iEvent), 0,0,iEvent);      
     }
 
+    //---------------- AU From here...
+
+    // MFT tracking of MUON tracks
+    if (!fRunTracking.IsNull()) {
+      if (fRunMFTTrackingMU && fRunMuonTracking) {
+       if (!RunMFTTrackingMU(fesd)) {
+         if (fStopOnError) {CleanUp(); return kFALSE;}
+       }
+      }
+      AliSysInfo::AddStamp(Form("TrackingMFT_MUON_%d",iEvent), 0,0,iEvent);      
+    }
+
+    //---------------- ...to here
+
     // barrel tracking
     if (!fRunTracking.IsNull()) {
       if (!RunTracking(fesd,*fESDpid)) {
@@ -2921,6 +2938,53 @@ Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
 
 
 //_____________________________________________________________________________
+Bool_t AliReconstruction::RunMFTTrackingMU(AliESDEvent*& esd) {
+
+  // AU
+
+  // run the global muon tracking: matching the MUON tracks with the MFT clusters
+
+  AliCodeTimerAuto("",0)
+
+  if (!fRunLoader) {
+    AliError("Missing runLoader!");
+    return kFALSE;
+  }
+  Int_t iDet = GetDetIndex("MFT"); // for MFT
+
+  // Get a pointer to the MFT reconstructor
+  AliReconstructor *reconstructor = GetReconstructor(iDet);
+  if (!reconstructor) return kFALSE;
+  
+  TString detName = fgkDetectorName[iDet];
+  AliDebug(1, Form("%s tracking for muon tracks", detName.Data()));
+  AliTracker *tracker = reconstructor->CreateTracker();
+  if (!tracker) {
+    AliWarning(Form("couldn't create a Muon tracker for %s", detName.Data()));
+    return kFALSE;
+  }
+     
+  // read RecPoints
+  fLoader[iDet]->LoadRecPoints("read");  
+
+  tracker->LoadClusters(fLoader[iDet]->TreeR());
+  
+  Int_t rv = tracker->Clusters2Tracks(esd);
+  
+  fLoader[iDet]->UnloadRecPoints();
+
+  tracker->UnloadClusters();
+  
+  if (rv) {
+    AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
+    return kFALSE;
+  }
+  
+  return kTRUE;
+
+}
+
+//_____________________________________________________________________________
 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
 {
 // run the barrel tracking
@@ -3519,6 +3583,10 @@ Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
       fRunMuonTracking = kTRUE;
       continue;
     }
+    if (detName == "MFT") {           // AU    
+      fRunMFTTrackingMU = kTRUE;      // AU
+      continue;                              // AU
+    }                                 // AU
 
     fTracker[iDet] = reconstructor->CreateTracker();
     if (!fTracker[iDet] && (iDet < 7)) {
index 176bacf..50f8819 100644 (file)
@@ -229,6 +229,7 @@ private:
   Bool_t         RunLocalEventReconstruction(const TString& detectors);
   Bool_t         RunVertexFinder(AliESDEvent*& esd);
   Bool_t         RunMuonTracking(AliESDEvent*& esd);
+  Bool_t         RunMFTTrackingMU(AliESDEvent*& esd);      // AU
   Bool_t         RunSPDTrackleting(AliESDEvent*& esd);
   Bool_t         RunMultFinder(AliESDEvent*& esd);
   Bool_t         RunTracking(AliESDEvent*& esd, AliESDpid &PID);
@@ -273,6 +274,7 @@ private:
   Bool_t         fRunVertexFinder;    // run the vertex finder
   Bool_t         fRunVertexFinderTracks;    // run the vertex finder with tracks
   Bool_t         fRunMuonTracking;    // run the MUON tracking
+  Bool_t         fRunMFTTrackingMU;   // run the MFT+MUON tracking      // AU
   Bool_t         fRunV0Finder;        // run the ESD V0 finder
   Bool_t         fRunCascadeFinder;   // run the ESD cascade finder
   Bool_t         fRunMultFinder;      // run the trackleter for ITS clusters
@@ -404,7 +406,7 @@ private:
   Int_t                fMaxVMEM;        //  max VMEM memory, MB
   static const char*   fgkStopEvFName;  //  filename for stop.event stamp
   //
-  ClassDef(AliReconstruction, 47)      // class for running the reconstruction
+  ClassDef(AliReconstruction, 48)      // class for running the reconstruction
 };
 
 #endif