Updated MFT code (Antonio)
authorhristov <Peter.Hristov@cern.ch>
Fri, 14 Feb 2014 08:14:45 +0000 (09:14 +0100)
committerhristov <Peter.Hristov@cern.ch>
Fri, 14 Feb 2014 08:14:45 +0000 (09:14 +0100)
13 files changed:
MFT/AliMFTTrackerMU.cxx
MFT/runMFT.sh
PWG/muon/AliAODMuonReplicator.cxx
PWG/muon/AliAnalysisNonMuonTrackCuts.cxx
PWG/muon/AliAnalysisTaskESDMuonFilter.cxx
STEER/AOD/AliAODEvent.cxx
STEER/AOD/AliAODEvent.h
STEER/AOD/AliAODHeader.cxx
STEER/AOD/AliAODHeader.h
STEER/AOD/AliAODTrack.cxx
STEER/AOD/AliAODTrack.h
STEER/ESD/AliESDMuonGlobalTrack.cxx
STEER/ESD/AliESDMuonGlobalTrack.h

index 75549ec..76944e7 100644 (file)
@@ -200,7 +200,13 @@ Int_t AliMFTTrackerMU::Clusters2Tracks(AliESDEvent *event) {
     if (fMUONTrack) delete fMUONTrack;
     fMUONTrack = new AliMUONTrack();
 
-    AliMUONESDInterface::ESDToMUON(*esdTrack, *fMUONTrack, kTRUE);     // last arguments should be kTRUE or kFALSE??
+    AliMUONESDInterface::ESDToMUON(*esdTrack, *fMUONTrack, kFALSE);
+
+    if (!fMUONTrack->GetTrackParamAtCluster()->First()) {
+      AliInfo("Skipping track, no parameters available!!!");
+      iTrack++;
+      continue;
+    }
 
     // the track we are going to build, starting from fMUONTrack and adding the MFT clusters
     AliMuonForwardTrack *track = new ((*fCandidateTracks)[0]) AliMuonForwardTrack();
@@ -306,17 +312,20 @@ Int_t AliMFTTrackerMU::Clusters2Tracks(AliESDEvent *event) {
       
 //       waiting for the commit of the new version of AliESDMuonGlobalTrack...
 
-//       myESDTrack -> SetChi2OverNdf(newTrack->GetChi2OverNdf());
-//       myESDTrack -> SetCharge(newTrack->GetCharge());
-//       myESDTrack -> SetMatchTrigger(newTrack->GetMatchTrigger());
-//       myESDTrack -> SetFirstTrackingPoint(newTrack->GetMFTCluster(0)->GetX(), newTrack->GetMFTCluster(0)->GetY(), newTrack->GetMFTCluster(0)->GetZ());
-//       myESDTrack -> SetXYAtVertex(newTrack->GetOffsetX(vertex[0], vertex[2]), newTrack->GetOffsetX(vertex[1], vertex[2]));
-//       myESDTrack -> SetRAtAbsorberEnd(newTrack->GetRAtAbsorberEnd());
-//       myESDTrack -> SetChi2MatchTrigger(esdTrack->GetChi2MatchTrigger());
-//       myESDTrack -> SetMuonClusterMap(esdTrack->GetMuonClusterMap());
-//       myESDTrack -> SetHitsPatternInTrigCh(esdTrack->GetHitsPatternInTrigCh());
-//       myESDTrack -> SetHitsPatternInTrigChTrk(esdTrack->GetHitsPatternInTrigChTrk());
-//       myESDTrack -> Connected(esdTrack->IsConnected());
+      myESDTrack -> SetLabel(newTrack->GetMCLabel());
+      myESDTrack -> SetChi2OverNdf(newTrack->GetChi2OverNdf());
+      myESDTrack -> SetCharge(newTrack->GetCharge());
+      myESDTrack -> SetMatchTrigger(newTrack->GetMatchTrigger());
+      myESDTrack -> SetNMFTClusters(newTrack->GetNMFTClusters());
+      myESDTrack -> SetNWrongMFTClustersMC(newTrack->GetNWrongClustersMC());
+      myESDTrack -> SetFirstTrackingPoint(newTrack->GetMFTCluster(0)->GetX(), newTrack->GetMFTCluster(0)->GetY(), newTrack->GetMFTCluster(0)->GetZ());
+      myESDTrack -> SetXYAtVertex(newTrack->GetOffsetX(vertex[0], vertex[2]), newTrack->GetOffsetX(vertex[1], vertex[2]));
+      myESDTrack -> SetRAtAbsorberEnd(newTrack->GetRAtAbsorberEnd());
+      myESDTrack -> SetChi2MatchTrigger(esdTrack->GetChi2MatchTrigger());
+      myESDTrack -> SetMuonClusterMap(esdTrack->GetMuonClusterMap());
+      myESDTrack -> SetHitsPatternInTrigCh(esdTrack->GetHitsPatternInTrigCh());
+      myESDTrack -> SetHitsPatternInTrigChTrk(esdTrack->GetHitsPatternInTrigChTrk());
+      myESDTrack -> Connected(esdTrack->IsConnected());
 
       //---------------------------------------------------------------------------------
 
index f0e4326..424046d 100644 (file)
@@ -14,48 +14,51 @@ SIMDIR="generated" # sub-directory where to move simulated files prior to reco
 # Copy *ALL* the macros we need in the output directory, not to mess
 # with our source dir in any way.
 cp $ALICE_ROOT/MFT/.rootrc \
-   $ALICE_ROOT/MFT/Config.C \
+   $ALICE_ROOT/Config.C \
    $ALICE_ROOT/MFT/rootlogon.C \
-   $ALICE_ROOT/MFT/runReconstruction.C \
-   $ALICE_ROOT/MFT/runSimulation.C \
-   $ALICE_ROOT/MFT/AliMuonForwardTrackFinder.C \
-   $ALICE_ROOT/MFT/FilterMuonGlobalTracks.C \
+   $ALICE_ROOT/runReconstruction.C \
+   $ALICE_ROOT/runSimulation.C \
    $ALICE_ROOT/MFT/AliMFTClusterQA.C \
    $ALICE_ROOT/MFT/AliMFTGeometry.root \
+   $ALICE_ROOT/AODtrain.C \
    $OUTDIR 
 cd $OUTDIR
+
 ###############################################################################
 # 
 # Performing SIMULATION
 # 
 ###############################################################################
-  echo "Running simulation  ..."
-  aliroot -l -b -q runSimulation.C\($SEED,$NEVENTS,\""$SIMCONFIG"\",$RUN\) >$OUTDIR/testSim.out 2>$OUTDIR/testSim.err
-  mkdir $SIMDIR
-  echo "Copying generated files to $SIMDIR"
-  cp $OUTDIR/Kinematics*.root $OUTDIR/galice.root $OUTDIR/TrackRefs*.root $OUTDIR/$SIMDIR
+
+echo "Running simulation  ..."
+aliroot -l -b -q runSimulation.C\($SEED,$NEVENTS,\""$SIMCONFIG"\",$RUN\) >$OUTDIR/testSim.out 2>$OUTDIR/testSim.err
+mkdir $SIMDIR
+echo "Copying generated files to $SIMDIR"
+cp $OUTDIR/Kinematics*.root $OUTDIR/galice.root $OUTDIR/TrackRefs*.root $OUTDIR/$SIMDIR
+
 ###############################################################################
 # 
-# Performing RECONSTRUCTION
+# Performing RECONSTRUCTION and QA
 # 
 ###############################################################################
-  rm -f AliESD*.root *QA*.root
-  echo "Running reconstruction  ..."
-  cd $OUTDIR
-
-  aliroot -l -b -q runReconstruction.C\($SEED,\""SAVEDIGITS"\"\) >$OUTDIR/testReco.out 2>$OUTDIR/testReco.err
-
-  aliroot -l -b -q AliMFTClusterQA.C\(\) >$OUTDIR/mftClusterQA.out 2>$OUTDIR/mftClusterQA.err
 
-  aliroot -l -b -q AliMuonForwardTrackFinder.C\($RUN,1\) >$OUTDIR/globalTracking.withBransonCorrection.out 2>$OUTDIR/globalTracking.withBransonCorrection.err
-  mv MuonGlobalTracking.QA.run$RUN.root MuonGlobalTracking.QA.run$RUN.withBransonCorrection.root 
-  mv MuonGlobalTracks.root MuonGlobalTracks.withBransonCorrection.root 
+rm -f AliESD*.root *QA*.root
+echo "Running reconstruction  ..."
+cd $OUTDIR
 
-  aliroot -l -b -q AliMuonForwardTrackFinder.C\($RUN,0\) >$OUTDIR/globalTracking.withoutBransonCorrection.out 2>$OUTDIR/globalTracking.withoutBransonCorrection.err
-  mv MuonGlobalTracking.QA.run$RUN.root MuonGlobalTracking.QA.run$RUN.withoutBransonCorrection.root 
-  mv MuonGlobalTracks.root MuonGlobalTracks.withoutBransonCorrection.root 
+aliroot -l -b -q runReconstruction.C\($SEED,\""SAVEDIGITS"\"\) >$OUTDIR/testReco.out 2>$OUTDIR/testReco.err
+      
+aliroot -l -b -q AliMFTClusterQA.C\(\) >$OUTDIR/mftClusterQA.out 2>$OUTDIR/mftClusterQA.err
 
-  aliroot -l -b -q FilterMuonGlobalTracks.C+\(\) >$OUTDIR/filterGlobalTracks.out 2>$OUTDIR/filterGlobalTracks.err
+###############################################################################
+# 
+# Creating AODs
+#
+###############################################################################
+  
+echo "Creating AODs  ..."
+echo aliroot -l -b -q AODtrain.C
+aliroot -l -b -q AODtrain.C >$OUTDIR/AODLog.out 2>$OUTDIR/AODLog.err
 
 echo "Finished"  
 echo "... see results in $OUTDIR"
index a2860ea..8f7a1bf 100644 (file)
@@ -342,12 +342,12 @@ TList* AliAODMuonReplicator::GetList() const
     }
 
     fTracks = new TClonesArray("AliAODTrack",30);
-               fTracks->SetName("tracks");    
+    fTracks->SetName("tracks");    
     
     fVertices = new TClonesArray("AliAODVertex",2);
-               fVertices->SetName("vertices");    
+    fVertices->SetName("vertices");    
     
-    fDimuons = new TClonesArray("AliAODDimuon",2);
+    fDimuons = new TClonesArray("AliAODDimuon",20);
     fDimuons->SetName("dimuons");
     
     fVZERO = new AliAODVZERO;
@@ -407,20 +407,18 @@ void AliAODMuonReplicator::ReplicateAndFilter(const AliAODEvent& source)
   fTracks->Clear("C");
   TIter next(source.GetTracks());
   AliAODTrack* t;
-  Int_t ntracks(0);
-  Int_t input(0);
+  Int_t nMuons=0;
+  Int_t inputMuons=0;
   
-  while ( ( t = static_cast<AliAODTrack*>(next()) ) )
-  {
-    if ( t->IsMuonTrack() ) 
-    {
-      ++input;
-    }
-    
-    if ( !fTrackCut || fTrackCut->IsSelected(t) )
-    {
-      new((*fTracks)[ntracks++]) AliAODTrack(*t);
+  while (( t = static_cast<AliAODTrack*>(next()) )) {
+
+    if (t->IsMuonTrack() || t->IsMuonGlobalTrack()) ++inputMuons;    // just a counter: MUON and MUON+MFT tracks before track cuts are applied
+     
+    // MUON and MUON+MFT tracks selected                    // AU
+    if (!fTrackCut || fTrackCut->IsSelected(t)) {
+      new ((*fTracks)[nMuons++]) AliAODTrack(*t);
     }
+
   }
   
   assert(fVertices!=0x0);
@@ -429,10 +427,8 @@ void AliAODMuonReplicator::ReplicateAndFilter(const AliAODEvent& source)
   AliAODVertex* v;
   Int_t nvertices(0);
   
-  while ( ( v = static_cast<AliAODVertex*>(nextV()) ) )
-  {
-    if ( !fVertexCut || fVertexCut->IsSelected(v) ) 
-    {
+  while ( ( v = static_cast<AliAODVertex*>(nextV()) ) ) {
+    if ( !fVertexCut || fVertexCut->IsSelected(v) ) {
       AliAODVertex* tmp = v->CloneWithoutRefs();
       AliAODVertex* copiedVertex = new((*fVertices)[nvertices++]) AliAODVertex(*tmp);
       // to insure the main vertex retains the ncontributors information
@@ -449,24 +445,24 @@ void AliAODMuonReplicator::ReplicateAndFilter(const AliAODEvent& source)
   // as there might be a track cut (different from the one of the main filtering),
   // we must recreate the dimuon completely from scratch to be 100% safe...
 
-  Int_t ndimuons(0);
+  Int_t nDimuons=0;
 
-  for ( Int_t i = 0; i < ntracks; ++i ) 
-  {
-    for ( Int_t j = i+1; j < ntracks; ++j ) 
-    {
-      new((*fDimuons)[ndimuons++]) AliAODDimuon(fTracks->At(i),fTracks->At(j));
+  // Dimuons built of 2 MUON tracks or 2 MUON+MFT tracks                   // AU
+  for (Int_t i=0; i<nMuons; ++i) {
+    for (Int_t j=i+1; j<nMuons; ++j) {
+      if ( (((AliAODTrack*) fTracks->At(i))->IsMuonTrack()       && ((AliAODTrack*) fTracks->At(j))->IsMuonTrack()) ||
+          (((AliAODTrack*) fTracks->At(i))->IsMuonGlobalTrack() && ((AliAODTrack*) fTracks->At(j))->IsMuonGlobalTrack()) ) {
+       new((*fDimuons)[nDimuons++]) AliAODDimuon(fTracks->At(i), fTracks->At(j));
+      }
     }
   }
 
   AliDebug(1,Form("input mu tracks=%d tracks=%d vertices=%d ndimuons=%d",
-                  input,fTracks->GetEntries(),fVertices->GetEntries(),fDimuons->GetEntries()));
+                  inputMuons,fTracks->GetEntries(),fVertices->GetEntries(),fDimuons->GetEntries()));
 
   // Finally, deal with MC information, if needed
 
-  if ( fMCMode > 0 )
-  {
-    FilterMC(source);      
-  }
+  if (fMCMode>0) FilterMC(source);
+
 }
 
index 2651d34..22762e7 100644 (file)
@@ -20,7 +20,7 @@
 ClassImp(AliAnalysisNonMuonTrackCuts)
 /// \endcond
 
-////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
 
 AliAnalysisNonMuonTrackCuts::AliAnalysisNonMuonTrackCuts()
 {
@@ -31,6 +31,7 @@ Bool_t AliAnalysisNonMuonTrackCuts::IsSelected(TObject* obj)
 {
   /// Returns true if the object is a muon track
   AliAODTrack* track = dynamic_cast<AliAODTrack*>(obj);
-  if (track && track->IsMuonTrack()) return kTRUE;
+  //  if (track && track->IsMuonTrack()) return kTRUE;
+  if (track && (track->IsMuonTrack() || track->IsMuonGlobalTrack())) return kTRUE;
   return kFALSE;
 }
index df4a100..2c6f4f6 100644 (file)
@@ -50,6 +50,7 @@
 #include "AliESDInputHandler.h"
 #include "AliESDMuonTrack.h"
 #include "AliESDtrack.h"
+#include "AliESDMuonGlobalTrack.h"   // AU
 #include "AliESDVertex.h"
 #include "AliLog.h"
 #include "AliMCEvent.h"
@@ -249,6 +250,8 @@ void AliAnalysisTaskESDMuonFilter::ConvertESDtoAOD()
   AliAODVertex *primary = AODEvent()->GetPrimaryVertex();
   if (fDebug && primary) primary->Print();
   
+  // ----------------- MUON TRACKS -----------------------------------------------------
+
   // Loop on muon tracks to fill the AOD track branch
   Int_t nMuTracks = esd->GetNumberOfMuonTracks();
 
@@ -364,6 +367,117 @@ void AliAnalysisTaskESDMuonFilter::ConvertESDtoAOD()
   header->SetNumberOfMuons(nMuons);
   header->SetNumberOfDimuons(nDimuons);
   
+  // ----------------- MFT + MUON TRACKS -----------------------------------------------------
+
+  AliESDMuonGlobalTrack *esdMuGlobalTrack = 0x0;
+
+  // Loop on muon global tracks to fill the AOD track branch. 
+  // We won't update the number of total, pos and neg tracks in the event
+
+  Int_t nMuGlobalTracks = esd->GetNumberOfMuonGlobalTracks();
+
+  for (Int_t iTrack=0; iTrack<nMuGlobalTracks; ++iTrack) esd->GetMuonGlobalTrack(iTrack)->SetESDEvent(esd);
+  
+  Int_t nGlobalMuons=0;
+  Int_t nGlobalDimuons=0;
+  Int_t jGlobalDimuons=0;
+  Int_t nMuonGlobalTrack[100];
+  itsClusMap = 0;
+  
+  for (Int_t iMuon=0; iMuon<100; iMuon++) nMuonGlobalTrack[iMuon]=0;    // position of the i-th muon track in the tracks array of the AOD event
+  
+  for (Int_t nMuTrack=0; nMuTrack<nMuGlobalTracks; ++nMuTrack) {
+
+    esdMuGlobalTrack = esd->GetMuonGlobalTrack(nMuTrack);
+
+    if (!esdMuGlobalTrack->ContainTrackerData()) continue;
+    
+    UInt_t selectInfo(0);
+    
+    // Track selection
+    if (fTrackFilter) {
+       selectInfo = fTrackFilter->IsSelected(esdMuGlobalTrack);
+       if (!selectInfo) {
+         continue;
+       }  
+    }
+    
+    p[0] = esdMuGlobalTrack->Px(); 
+    p[1] = esdMuGlobalTrack->Py(); 
+    p[2] = esdMuGlobalTrack->Pz();
+    
+    esdMuGlobalTrack -> GetFirstTrackingPoint(pos);
+
+    if (mcH) mcH->SelectParticle(esdMuGlobalTrack->GetLabel()); // to insure that particle's ancestors will be in output MC branches
+    
+    aodTrack = new(tracks[jTracks++]) AliAODTrack(esdMuGlobalTrack->GetUniqueID(), // ID
+                                                  esdMuGlobalTrack->GetLabel(),    // label
+                                                  p,                               // momentum
+                                                  kTRUE,                           // cartesian coordinate system
+                                                  pos,                             // position
+                                                  kFALSE,                          // isDCA
+                                                  0x0,                             // covariance matrix
+                                                  esdMuGlobalTrack->Charge(),      // charge
+                                                  itsClusMap,                      // ITSClusterMap
+                                                  primary,                         // primary vertex
+                                                  kFALSE,                          // used for vertex fit?
+                                                  kFALSE,                          // used for primary vertex fit?
+                                                  AliAODTrack::kPrimary,           // track type
+                                                  selectInfo); 
+    
+    Double_t xyAtVertex[2] = {0};
+    esdMuGlobalTrack -> GetXYAtVertex(xyAtVertex);
+    
+    aodTrack->SetIsMuonGlobalTrack(kTRUE);
+
+    aodTrack->SetXYAtDCA(xyAtVertex[0], xyAtVertex[1]);
+    aodTrack->SetPxPyPzAtDCA(p[0], p[1], p[2]);
+    aodTrack->SetRAtAbsorberEnd(esdMuGlobalTrack->GetRAtAbsorberEnd());
+    aodTrack->ConvertAliPIDtoAODPID();
+    aodTrack->SetChi2perNDF(esdMuGlobalTrack->GetChi2OverNdf());
+    aodTrack->SetChi2MatchTrigger(esdMuGlobalTrack->GetChi2MatchTrigger());
+    aodTrack->SetHitsPatternInTrigCh(esdMuGlobalTrack->GetHitsPatternInTrigCh());
+    UInt_t pattern = esdMuGlobalTrack->GetHitsPatternInTrigCh();
+    AliESDMuonTrack::AddEffInfo(pattern, 0, esdMuGlobalTrack->GetLoCircuit(), (AliESDMuonTrack::EAliTriggerChPatternFlag)0);
+    aodTrack->SetMUONtrigHitsMapTrg(pattern);
+    aodTrack->SetMUONtrigHitsMapTrk(esdMuGlobalTrack->GetHitsPatternInTrigChTrk());
+    aodTrack->SetMuonClusterMap(esdMuGlobalTrack->GetMuonClusterMap());
+    aodTrack->SetMatchTrigger(esdMuGlobalTrack->GetMatchTrigger());
+    aodTrack->Connected(esdMuGlobalTrack->IsConnected());
+
+    printf("Added Muon Global Track %d of %d\n",nMuTrack,nMuGlobalTracks);
+    aodTrack->Print();     // to be removed!!!
+
+    primary->AddDaughter(aodTrack);
+    
+    nMuonGlobalTrack[nGlobalMuons] = jTracks-1;
+    ++nGlobalMuons;
+  }
+  
+  if (nGlobalMuons >= 2) { 
+    for (Int_t i=0; i<nGlobalMuons; i++) {
+      Int_t index0 = nMuonGlobalTrack[i];
+      for (Int_t j=i+1; j<nGlobalMuons; j++) {
+        Int_t index1 = nMuonGlobalTrack[j];
+        new (dimuons[jGlobalDimuons++]) AliAODDimuon(tracks.At(index0), tracks.At(index1));
+        ++nDimuons;
+        if (fDebug > 1) {
+          AliAODDimuon *dimuon0 = (AliAODDimuon*)dimuons.At(jGlobalDimuons-1);
+          printf("Dimuon: mass = %f, px=%f, py=%f, pz=%f\n",dimuon0->M(),dimuon0->Px(),dimuon0->Py(),dimuon0->Pz());  
+          AliAODTrack  *mu0 = (AliAODTrack*) dimuon0->GetMu(0);
+          AliAODTrack  *mu1 = (AliAODTrack*) dimuon0->GetMu(1);
+          printf("Muon0 px=%f py=%f pz=%f\n",mu0->Px(),mu0->Py(),mu0->Pz());
+          printf("Muon1 px=%f py=%f pz=%f\n",mu1->Px(),mu1->Py(),mu1->Pz());
+        }  
+      }
+    }
+  }
+  
+  header->SetNumberOfGlobalMuons(nGlobalMuons);
+  header->SetNumberOfGlobalDimuons(nGlobalDimuons);
+  
+  // -----------------------------------------------------------------------
+
   AliAODHandler* handler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
   
   if ( handler && fEnableMuonAOD && ( (nMuons>0) || fKeepAllEvents ) )
index c4efafe..3c908d3 100644 (file)
@@ -633,6 +633,39 @@ Int_t AliAODEvent::GetNumberOfMuonTracks() const
 }
 
 //______________________________________________________________________________
+Int_t AliAODEvent::GetMuonGlobalTracks(TRefArray *muonGlobalTracks) const           // AU
+{
+  // fills the provided TRefArray with all found muon global tracks
+
+  muonGlobalTracks->Clear();
+
+  AliAODTrack *track = 0;
+  for (Int_t iTrack = 0; iTrack < GetNTracks(); iTrack++) {
+    track = GetTrack(iTrack);
+    if (track->IsMuonGlobalTrack()) {
+      muonGlobalTracks->Add(track);
+    }
+  }
+  
+  return muonGlobalTracks->GetEntriesFast();
+}
+
+
+//______________________________________________________________________________
+Int_t AliAODEvent::GetNumberOfMuonGlobalTracks() const                                    // AU
+{
+  // get number of muon global tracks
+  Int_t nMuonGlobalTracks=0;
+  for (Int_t iTrack = 0; iTrack < GetNTracks(); iTrack++) {
+    if ((GetTrack(iTrack))->IsMuonGlobalTrack()) {
+       nMuonGlobalTracks++;
+    }
+  }
+  
+  return nMuonGlobalTracks;
+}
+
+//______________________________________________________________________________
 void AliAODEvent::ReadFromTree(TTree *tree, Option_t* opt /*= ""*/)
 {
     // Connects aod event to tree
index 2b6e39e..20ae27d 100644 (file)
@@ -147,6 +147,8 @@ class AliAODEvent : public AliVEvent {
   Int_t         AddTrack(const AliAODTrack* trk);
   Int_t         GetMuonTracks(TRefArray *muonTracks) const;
   Int_t         GetNumberOfMuonTracks() const;
+  Int_t         GetMuonGlobalTracks(TRefArray *muonGlobalTracks) const;    // AU
+  Int_t         GetNumberOfMuonGlobalTracks() const;                       // AU
 
   // -- Vertex
   TClonesArray *GetVertices()            const { return fVertices; }
index 46edc3c..e9475e8 100644 (file)
@@ -54,6 +54,8 @@ AliAODHeader::AliAODHeader() :
   fRefMultNeg(-999),
   fNMuons(0),
   fNDimuons(0),
+  fNGlobalMuons(0),               // AU
+  fNGlobalDimuons(0),             // AU
   fEventType(0),
   fOrbitNumber(0),
   fPeriodNumber(0),
@@ -118,6 +120,8 @@ AliAODHeader::AliAODHeader(Int_t nRun,
   fRefMultNeg(-999),
   fNMuons(0),
   fNDimuons(0),
+  fNGlobalMuons(0),               // AU
+  fNGlobalDimuons(0),             // AU
   fEventType(0),
   fOrbitNumber(nOrbit),
   fPeriodNumber(nPeriod),
@@ -179,7 +183,9 @@ AliAODHeader::AliAODHeader(Int_t nRun,
                           const Float_t *vzeroEqFactors,
                           const Char_t *title,
                           Int_t nMuons,
-                          Int_t nDimuons) :
+                          Int_t nDimuons,
+                          Int_t nGlobalMuons,                 // AU
+                          Int_t nGlobalDimuons) :             // AU
   AliVHeader(),
   fMagneticField(magField),
   fMuonMagFieldScale(muonMagFieldScale),
@@ -202,6 +208,8 @@ AliAODHeader::AliAODHeader(Int_t nRun,
   fRefMultNeg(refMultNeg),
   fNMuons(nMuons),
   fNDimuons(nDimuons),
+  fNGlobalMuons(nGlobalMuons),               // AU
+  fNGlobalDimuons(nGlobalDimuons),           // AU
   fEventType(evttype),
   fOrbitNumber(nOrbit),
   fPeriodNumber(nPeriod),
@@ -272,6 +280,8 @@ AliAODHeader::AliAODHeader(const AliAODHeader& hdr) :
   fRefMultNeg(hdr.fRefMultNeg),
   fNMuons(hdr.fNMuons),
   fNDimuons(hdr.fNDimuons),
+  fNGlobalMuons(hdr.fNGlobalMuons),           // AU
+  fNGlobalDimuons(hdr.fNGlobalDimuons),       // AU
   fEventType(hdr.fEventType),
   fOrbitNumber(hdr.fOrbitNumber),
   fPeriodNumber(hdr.fPeriodNumber),
@@ -358,6 +368,8 @@ AliAODHeader& AliAODHeader::operator=(const AliAODHeader& hdr)
     fTriggerCluster   = hdr.fTriggerCluster;
     fNMuons           = hdr.fNMuons;
     fNDimuons         = hdr.fNDimuons;
+    fNGlobalMuons     = hdr.fNGlobalMuons;           // AU
+    fNGlobalDimuons   = hdr.fNGlobalDimuons;         // AU
     fDiamondZ         = hdr.fDiamondZ;
     fDiamondSig2Z     = hdr.fDiamondSig2Z;
     fOfflineTrigger   = hdr.fOfflineTrigger;
index 73b1fa2..b73fde0 100644 (file)
@@ -53,7 +53,9 @@ class AliAODHeader : public AliVHeader {
               const Float_t *vzeroEqFactors,
               const Char_t *title="",
               Int_t nMuons=0,
-              Int_t nDimuons=0);
+              Int_t nDimuons=0,
+              Int_t nGlobalMuons=0,             // AU
+              Int_t nGlobalDimuons=0);          // AU
   
   virtual ~AliAODHeader();
   AliAODHeader(const AliAODHeader& evt); 
@@ -88,6 +90,8 @@ class AliAODHeader : public AliVHeader {
   Int_t     GetRefMultiplicityNeg() const { return fRefMultNeg; }
   Int_t     GetNumberOfMuons()      const { return fNMuons; }
   Int_t     GetNumberOfDimuons()    const { return fNDimuons; }
+  Int_t     GetNumberOfGlobalMuons()   const { return fNGlobalMuons; }      // AU
+  Int_t     GetNumberOfGlobalDimuons() const { return fNGlobalDimuons; }    // AU
   Int_t     GetRefMultiplicityComb05() const { return fRefMultComb05; }
   Int_t     GetRefMultiplicityComb08() const { return fRefMultComb08; }
 
@@ -135,6 +139,8 @@ class AliAODHeader : public AliVHeader {
   void SetRefMultiplicityNeg(Int_t refMultNeg) { fRefMultNeg = refMultNeg; }
   void SetNumberOfMuons(Int_t nMuons) { fNMuons = nMuons; }
   void SetNumberOfDimuons(Int_t nDimuons) { fNDimuons = nDimuons; }
+  void SetNumberOfGlobalMuons(Int_t nGlobalMuons) { fNGlobalMuons = nGlobalMuons; }            // AU
+  void SetNumberOfGlobalDimuons(Int_t nGlobalDimuons) { fNGlobalDimuons = nGlobalDimuons; }    // AU
   void SetRefMultiplicityComb05(Int_t refMult)   { fRefMultComb05 = refMult; }
   void SetRefMultiplicityComb08(Int_t refMult)   { fRefMultComb08 = refMult; }  
 
@@ -226,6 +232,8 @@ class AliAODHeader : public AliVHeader {
   Int_t       fRefMultNeg;          // reference multiplicity of negative particles
   Int_t       fNMuons;              // number of muons in the forward spectrometer
   Int_t       fNDimuons;            // number of dimuons in the forward spectrometer
+  Int_t       fNGlobalMuons;        // number of muons in the forward spectrometer + MFT       // AU
+  Int_t       fNGlobalDimuons;      // number of dimuons in the forward spectrometer + MFT     // AU
   UInt_t      fEventType;           // Type of Event
   UInt_t      fOrbitNumber;         // Orbit Number
   UInt_t      fPeriodNumber;        // Period Number
@@ -254,7 +262,7 @@ class AliAODHeader : public AliVHeader {
   Float_t     fT0spread[kT0SpreadSize]; // spread of time distributions: (TOA+T0C/2), T0A, T0C, (T0A-T0C)/2
   TBits   fIRInt2InteractionsMap;  // map of the Int2 events (normally 0TVX) near the event, that's Int2Id-EventId in a -90 to 90 window
   TBits   fIRInt1InteractionsMap;  // map of the Int1 events (normally V0A&V0C) near the event, that's Int1Id-EventId in a -90 to 90 window
-  ClassDef(AliAODHeader, 23);
+  ClassDef(AliAODHeader, 24);
 };
 inline
 void AliAODHeader::SetCentrality(const AliCentrality* cent)      { 
index 5acb341..81771a1 100644 (file)
@@ -66,8 +66,10 @@ AliAODTrack::AliAODTrack() :
   fTrackPhiOnEMCal(-999),
   fTrackEtaOnEMCal(-999),
   fTrackPtOnEMCal(-999),
+  fIsMuonGlobalTrack(kFALSE),    // AU
   fTPCsignalTuned(0),
   fTOFsignalTuned(99999),
+  fMFTClusterPattern(0),         // AU
   fAODEvent(NULL)
 {
   // default constructor
@@ -125,8 +127,10 @@ AliAODTrack::AliAODTrack(Short_t id,
   fTrackPhiOnEMCal(-999),
   fTrackEtaOnEMCal(-999),
   fTrackPtOnEMCal(-999),
+  fIsMuonGlobalTrack(kFALSE),    // AU
   fTPCsignalTuned(0),
   fTOFsignalTuned(99999),
+  fMFTClusterPattern(0),         // AU
   fAODEvent(NULL)
 {
   // constructor
@@ -188,8 +192,10 @@ AliAODTrack::AliAODTrack(Short_t id,
   fTrackPhiOnEMCal(-999),
   fTrackEtaOnEMCal(-999),
   fTrackPtOnEMCal(-999),
+  fIsMuonGlobalTrack(kFALSE),    // AU
   fTPCsignalTuned(0),
   fTOFsignalTuned(99999),
+  fMFTClusterPattern(0),         // AU
   fAODEvent(NULL)
 {
   // constructor
@@ -248,8 +254,10 @@ AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
   fTrackPhiOnEMCal(trk.fTrackPhiOnEMCal),
   fTrackEtaOnEMCal(trk.fTrackEtaOnEMCal),
   fTrackPtOnEMCal(trk.fTrackPtOnEMCal),
+  fIsMuonGlobalTrack(trk.fIsMuonGlobalTrack),    // AU
   fTPCsignalTuned(trk.fTPCsignalTuned),
   fTOFsignalTuned(trk.fTOFsignalTuned),
+  fMFTClusterPattern(trk.fMFTClusterPattern),    // AU
   fAODEvent(trk.fAODEvent)
 {
   // Copy constructor
@@ -303,9 +311,11 @@ AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
     fTrackPhiOnEMCal   = trk.fTrackPhiOnEMCal;
     fTrackEtaOnEMCal   = trk.fTrackEtaOnEMCal;
     fTrackPtOnEMCal    = trk.fTrackPtOnEMCal;
+    fIsMuonGlobalTrack = trk.fIsMuonGlobalTrack;     // AU
     fTPCsignalTuned    = trk.fTPCsignalTuned;
     fTOFsignalTuned    = trk.fTOFsignalTuned;
-
+    fMFTClusterPattern = trk.fMFTClusterPattern;     // AU
+    
     delete fCovMatrix;
     if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
     else fCovMatrix=NULL;
index 4163dea..686b262 100644 (file)
@@ -332,6 +332,9 @@ class AliAODTrack : public AliVTrack {
   Int_t     GetNumberOfTRDslices() const { return fDetPid?fDetPid->GetTRDnSlices():0; }
   void      GetHMPIDpid(Double_t */*p*/) const { return; } // TODO: To be implemented properly with the new HMPID object
 
+  void SetMFTClusterPattern(ULong_t mftClusterPattern) { fMFTClusterPattern = mftClusterPattern; }   // AU
+  ULong_t GetMFTClusterPattern() { return fMFTClusterPattern; }                                      // AU
+
   const AliAODEvent* GetAODEvent() const {return fAODEvent;}
   virtual const AliVEvent* GetEvent() const {return (AliVEvent*)fAODEvent;}
   void SetAODEvent(const AliAODEvent* ptr){fAODEvent = ptr;}
@@ -403,8 +406,11 @@ class AliAODTrack : public AliVTrack {
   Double_t GetChi2MatchTrigger() const  { return fChi2MatchTrigger;}
   void     SetChi2MatchTrigger(Double_t Chi2MatchTrigger) {fChi2MatchTrigger = Chi2MatchTrigger; }
   Bool_t   HitsMuonChamber(Int_t MuonChamber, Int_t cathode = -1) const;  // Check if track hits Muon chambers
-  Bool_t   IsMuonTrack() const { return (GetMUONClusterMap()>0) ? kTRUE : kFALSE; }
+  Bool_t   IsMuonTrack() const { return ( (GetMUONClusterMap()>0) && !fIsMuonGlobalTrack ) ? kTRUE : kFALSE; }
   
+  Bool_t   IsMuonGlobalTrack() const { return fIsMuonGlobalTrack; }                                     // AU
+  void     SetIsMuonGlobalTrack(Bool_t isMuonGlobalTrack) { fIsMuonGlobalTrack = isMuonGlobalTrack; }   // AU
+
   void     Connected(Bool_t flag) {flag ? SETBIT(fITSMuonClusterMap,26) : CLRBIT(fITSMuonClusterMap,26);}
   Bool_t   IsConnected() const {return TESTBIT(fITSMuonClusterMap,26);}
 
@@ -469,12 +475,16 @@ class AliAODTrack : public AliVTrack {
   Double_t      fTrackEtaOnEMCal;   // eta of track after being propagated to the EMCal surface (default r = 440 cm)
   Double_t      fTrackPtOnEMCal;    // pt of track after being propagated to the EMCal surface (default r = 440 cm)
 
+  Bool_t fIsMuonGlobalTrack;        // True if the track is built from the combination of MUON and MFT clusters     // AU
+
   Double_t      fTPCsignalTuned;    //! TPC signal tuned on data when using MC
   Double_t      fTOFsignalTuned;    //! TOF signal tuned on data when using MC
 
+  ULong_t fMFTClusterPattern;       // Tells us which MFT clusters are contained in the track, and which one is a good one (if MC)  // AU
+
   const AliAODEvent* fAODEvent;     //! pointer back to the event the track belongs to
 
-  ClassDef(AliAODTrack, 23);
+  ClassDef(AliAODTrack, 24);
 };
 
 inline Bool_t  AliAODTrack::IsPrimaryCandidate() const
index 0ec2f21..93acbc6 100644 (file)
@@ -37,6 +37,9 @@ AliESDMuonGlobalTrack::AliESDMuonGlobalTrack():
   AliVParticle(),
   fCharge(0),
   fMatchTrigger(0),
+  fNMFTClusters(0),
+  fNWrongMFTClustersMC(-1),
+  fMFTClusterPattern(0),
   fPx(0), 
   fPy(0), 
   fPz(0), 
@@ -44,9 +47,20 @@ AliESDMuonGlobalTrack::AliESDMuonGlobalTrack():
   fP(0), 
   fEta(0), 
   fRapidity(0),
-  fChi2(0),
+  fFirstTrackingPointX(0),
+  fFirstTrackingPointY(0),
+  fFirstTrackingPointZ(0),
+  fXAtVertex(0),
+  fYAtVertex(0),
+  fRAtAbsorberEnd(0),
+  fChi2OverNdf(0),
   fChi2MatchTrigger(0),
   fLabel(-1),
+  fMuonClusterMap(0),
+  fHitsPatternInTrigCh(0),
+  fHitsPatternInTrigChTrk(0),
+  fLoCircuit(0),
+  fIsConnected(kFALSE),
   fESDEvent(0)
 {
 
@@ -60,6 +74,9 @@ AliESDMuonGlobalTrack::AliESDMuonGlobalTrack(Double_t px, Double_t py, Double_t
   AliVParticle(),
   fCharge(0),
   fMatchTrigger(0),
+  fNMFTClusters(0),
+  fNWrongMFTClustersMC(-1),
+  fMFTClusterPattern(0),
   fPx(0), 
   fPy(0), 
   fPz(0), 
@@ -67,9 +84,20 @@ AliESDMuonGlobalTrack::AliESDMuonGlobalTrack(Double_t px, Double_t py, Double_t
   fP(0), 
   fEta(0), 
   fRapidity(0),
-  fChi2(0),
+  fFirstTrackingPointX(0),
+  fFirstTrackingPointY(0),
+  fFirstTrackingPointZ(0),
+  fXAtVertex(0),
+  fYAtVertex(0),
+  fRAtAbsorberEnd(0),
+  fChi2OverNdf(0),
   fChi2MatchTrigger(0),
   fLabel(-1),
+  fMuonClusterMap(0),
+  fHitsPatternInTrigCh(0),
+  fHitsPatternInTrigChTrk(0),
+  fLoCircuit(0),
+  fIsConnected(kFALSE),
   fESDEvent(0)
 {
 
@@ -85,6 +113,9 @@ AliESDMuonGlobalTrack::AliESDMuonGlobalTrack(const AliESDMuonGlobalTrack& muonTr
   AliVParticle(muonTrack),
   fCharge(muonTrack.fCharge),
   fMatchTrigger(muonTrack.fMatchTrigger),
+  fNMFTClusters(muonTrack.fNMFTClusters),
+  fNWrongMFTClustersMC(muonTrack.fNWrongMFTClustersMC),
+  fMFTClusterPattern(muonTrack.fMFTClusterPattern),
   fPx(muonTrack.fPx), 
   fPy(muonTrack.fPy), 
   fPz(muonTrack.fPz), 
@@ -92,9 +123,20 @@ AliESDMuonGlobalTrack::AliESDMuonGlobalTrack(const AliESDMuonGlobalTrack& muonTr
   fP(muonTrack.fP), 
   fEta(muonTrack.fEta), 
   fRapidity(muonTrack.fRapidity),
-  fChi2(muonTrack.fChi2),
+  fFirstTrackingPointX(muonTrack.fFirstTrackingPointX),
+  fFirstTrackingPointY(muonTrack.fFirstTrackingPointY),
+  fFirstTrackingPointZ(muonTrack.fFirstTrackingPointZ),
+  fXAtVertex(muonTrack.fXAtVertex),
+  fYAtVertex(muonTrack.fYAtVertex),
+  fRAtAbsorberEnd(muonTrack.fRAtAbsorberEnd),
+  fChi2OverNdf(muonTrack.fChi2OverNdf),
   fChi2MatchTrigger(muonTrack.fChi2MatchTrigger),
   fLabel(muonTrack.fLabel),
+  fMuonClusterMap(muonTrack.fMuonClusterMap),
+  fHitsPatternInTrigCh(muonTrack.fHitsPatternInTrigCh),
+  fHitsPatternInTrigChTrk(muonTrack.fHitsPatternInTrigChTrk),
+  fLoCircuit(muonTrack.fLoCircuit),
+  fIsConnected(muonTrack.fIsConnected),
   fESDEvent(muonTrack.fESDEvent)
 {
 
@@ -113,19 +155,33 @@ AliESDMuonGlobalTrack& AliESDMuonGlobalTrack::operator=(const AliESDMuonGlobalTr
   // 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;
+  fCharge                 = muonTrack.fCharge;
+  fMatchTrigger           = muonTrack.fMatchTrigger;
+  fNMFTClusters           = muonTrack.fNMFTClusters;
+  fNWrongMFTClustersMC    = muonTrack.fNWrongMFTClustersMC;
+  fMFTClusterPattern      = muonTrack.fMFTClusterPattern;
+  fPx                     = muonTrack.fPx; 
+  fPy                     = muonTrack.fPy; 
+  fPz                     = muonTrack.fPz; 
+  fPt                     = muonTrack.fPt; 
+  fP                      = muonTrack.fP;
+  fEta                    = muonTrack.fEta;
+  fRapidity               = muonTrack.fRapidity;
+  fFirstTrackingPointX    = muonTrack.fFirstTrackingPointX;
+  fFirstTrackingPointY    = muonTrack.fFirstTrackingPointY;
+  fFirstTrackingPointZ    = muonTrack.fFirstTrackingPointZ;
+  fXAtVertex              = muonTrack.fXAtVertex;
+  fYAtVertex              = muonTrack.fYAtVertex;
+  fRAtAbsorberEnd         = muonTrack.fRAtAbsorberEnd;
+  fChi2OverNdf            = muonTrack.fChi2OverNdf;
+  fChi2MatchTrigger       = muonTrack.fChi2MatchTrigger;
+  fLabel                  = muonTrack.fLabel;
+  fMuonClusterMap         = muonTrack.fMuonClusterMap;
+  fHitsPatternInTrigCh    = muonTrack.fHitsPatternInTrigCh;
+  fHitsPatternInTrigChTrk = muonTrack.fHitsPatternInTrigChTrk;
+  fLoCircuit              = muonTrack.fLoCircuit;
+  fIsConnected            = muonTrack.fIsConnected;
+  fESDEvent               = muonTrack.fESDEvent;
 
   return *this;
 
index 7b096e9..dd1fa4d 100644 (file)
@@ -47,13 +47,37 @@ public:
   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
-  
+  Double_t GetChi2OverNdf() const { return fChi2OverNdf; }            // chi2/ndf
+  void     SetChi2OverNdf(Double_t chi2) { fChi2OverNdf = chi2; }     // chi2/ndf
+
+  Double_t GetChi2MatchTrigger() const { return fChi2MatchTrigger; }
+  void     SetChi2MatchTrigger(Double_t chi2MatchTrigger) { fChi2MatchTrigger = chi2MatchTrigger; }
+
+  // Get and Set methods for various info copied and pasted from the MUON track
+  UShort_t GetHitsPatternInTrigCh() const {return fHitsPatternInTrigCh;}
+  void     SetHitsPatternInTrigCh(UShort_t hitsPatternInTrigCh) {fHitsPatternInTrigCh = hitsPatternInTrigCh;}
+  UInt_t   GetHitsPatternInTrigChTrk() const {return fHitsPatternInTrigChTrk;}
+  void     SetHitsPatternInTrigChTrk(UInt_t hitsPatternInTrigChTrk) {fHitsPatternInTrigChTrk = hitsPatternInTrigChTrk;}
+  UInt_t   GetMuonClusterMap() const {return fMuonClusterMap;}
+  void     SetMuonClusterMap(UInt_t muonClusterMap) {fMuonClusterMap = muonClusterMap;}
+  Int_t    GetLoCircuit() const { return fLoCircuit; }
+  void     SetLoCircuit(Int_t loCircuit) { fLoCircuit = loCircuit; }
+  Bool_t   IsConnected() const { return fIsConnected; }
+  void     Connected(Bool_t flag) { fIsConnected = flag; }
+
   // Get and Set methods for trigger matching
   void  SetMatchTrigger(Int_t matchTrigger) { fMatchTrigger = matchTrigger; }
   Int_t GetMatchTrigger() { return fMatchTrigger; }
 
+  void SetNMFTClusters(Int_t nMFTClusters) { fNMFTClusters = nMFTClusters; }
+  Short_t GetNMFTClusters() { return fNMFTClusters; }
+
+  void SetNWrongMFTClustersMC(Int_t nWrongMFTClustersMC) { fNWrongMFTClustersMC = nWrongMFTClustersMC; }
+  Short_t GetNWrongMFTClustersMC() { return fNWrongMFTClustersMC; }
+
+  void SetMFTClusterPattern(ULong_t mftClusterPattern) { fMFTClusterPattern = mftClusterPattern; }
+  ULong_t GetMFTClusterPattern() { return fMFTClusterPattern; }
+
   // Kinematics
   Double_t Pt()       const { return fPt;  }
   Double_t Eta()      const { return fEta; }
@@ -65,6 +89,15 @@ public:
 
   Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
 
+  void SetFirstTrackingPoint(Double_t x, Double_t y, Double_t z) {fFirstTrackingPointX = x; fFirstTrackingPointY = y; fFirstTrackingPointZ = z; }
+  void GetFirstTrackingPoint(Double_t x[3]) { x[0] = fFirstTrackingPointX; x[1] = fFirstTrackingPointY; x[2] = fFirstTrackingPointZ; }
+
+  void SetXYAtVertex(Double_t x, Double_t y) { fXAtVertex = x; fYAtVertex = y; }
+  void GetXYAtVertex(Double_t x[2]) { x[0] = fXAtVertex; x[1] = fYAtVertex; }
+
+  Double_t GetRAtAbsorberEnd() { return fRAtAbsorberEnd; }
+  void SetRAtAbsorberEnd(Double_t r) { fRAtAbsorberEnd = r; }
+
   // Additional methods to comply with AliVParticle
   Double_t Xv() const {return -999.;} // put reasonable values here
   Double_t Yv() const {return -999.;} //
@@ -78,6 +111,9 @@ public:
   Double_t Y() const { return Rapidity(); }
   Short_t  Charge() const { return fCharge; }
 
+  // Return kTRUE if the track contain tracker data
+  Bool_t ContainTrackerData() const {return (fMuonClusterMap>0) ? kTRUE : kFALSE;}
+
   // Dummy
   const Double_t *PID() const { return (Double_t*)0x0; }
   Int_t PdgCode() const { return 0; }
@@ -92,20 +128,35 @@ public:
   
 protected:
 
-  Short_t fCharge, fMatchTrigger;
+  Short_t fCharge, fMatchTrigger, fNMFTClusters, fNWrongMFTClustersMC;
+  ULong_t fMFTClusterPattern;  // Tells us which MFT clusters are contained in the track, and which one is a good one (if MC)
 
   // kinematics at vertex
   Double_t fPx, fPy, fPz, fPt, fP, fEta, fRapidity;
 
+  // coordinates of the first tracking point
+  Double_t fFirstTrackingPointX, fFirstTrackingPointY, fFirstTrackingPointZ;
+
+  // transverse coordinates at DCA to the primary vertex (offset)
+  Double_t fXAtVertex, fYAtVertex;
+
+  Double_t fRAtAbsorberEnd;
+
   // global tracking info
-  Double_t fChi2;                 //  chi2 in the MUON+MFT track fit
-  Double_t fChi2MatchTrigger;     //  chi2 of trigger/track matching
+  Double_t fChi2OverNdf;            //  chi2/ndf in the MUON+MFT track fit
+  Double_t fChi2MatchTrigger;       //  chi2 of trigger/track matching
 
-  Int_t fLabel;                   //  point to the corresponding MC track
+  Int_t fLabel;                     //  point to the corresponding MC track
 
-  AliESDEvent *fESDEvent;         //! Pointer back to event to which the track belongs
+  UInt_t   fMuonClusterMap;         // Map of clusters in MUON tracking chambers
+  UShort_t fHitsPatternInTrigCh;    // Word containing info on the hits left in trigger chambers
+  UInt_t   fHitsPatternInTrigChTrk; // Trigger hit map from tracker track extrapolation
+  Int_t    fLoCircuit;
+  Bool_t   fIsConnected;
+  
+  AliESDEvent *fESDEvent;           //! Pointer back to event to which the track belongs
   
-  ClassDef(AliESDMuonGlobalTrack,1) // MUON+MFT ESD track class 
+  ClassDef(AliESDMuonGlobalTrack,2) // MUON+MFT ESD track class 
 
 };