MFT Classes modified for integration with the AOD framework
authorauras <antonio.uras@cern.ch>
Tue, 25 Feb 2014 18:12:06 +0000 (19:12 +0100)
committerauras <antonio.uras@cern.ch>
Tue, 25 Feb 2014 18:12:06 +0000 (19:12 +0100)
MFT/AODtrain.C
MFT/AliMFTClusterFinder.cxx
MFT/AliMFTClusterFinder.h
MFT/AliMFTConstants.cxx
MFT/AliMFTConstants.h
MFT/AliMFTReconstructor.cxx
MFT/AliMFTTrackerMU.cxx
MFT/AliMFTTrackerMU.h
MFT/CMakelibMFTbase.pkg
MFT/Config.C
MFT/MFTbaseLinkDef.h

index b509726..2110816 100644 (file)
@@ -3,6 +3,7 @@
 Int_t       runOnData          = 0;       // Set to 1 if processing real data
 Int_t       iCollision         = 0;       // 0=pp, 1=Pb-Pb
 //==============================================================================
+Bool_t      doCDBconnect        = kFALSE;
 Bool_t      usePhysicsSelection = kTRUE; // use physics selection
 Bool_t      useTender           = kFALSE; // use tender wagon
 Bool_t      useCentrality       = kTRUE; // centrality
@@ -43,6 +44,8 @@ Bool_t LoadCommonLibraries();
 Bool_t LoadAnalysisLibraries();
 Bool_t LoadLibrary(const char *);
 TChain *CreateChain();
+const char *cdbPath = "raw://";
+Int_t run_number = 0;
 
 //______________________________________________________________________________
 void AODtrain(Int_t merge=0)
@@ -92,6 +95,7 @@ void AODtrain(Int_t merge=0)
    // Create input handler (input container created automatically)
    // ESD input handler
    AliESDInputHandler *esdHandler = new AliESDInputHandler();
+   esdHandler->SetNeedField();
    mgr->SetInputEventHandler(esdHandler);       
    // Monte Carlo handler
    if (useMC) {
@@ -109,7 +113,7 @@ void AODtrain(Int_t merge=0)
    // Debugging if needed
    if (useDBG) mgr->SetDebugLevel(3);
 
-   AddAnalysisTasks(merge);
+   AddAnalysisTasks(merge, cdbPath);
    if (merge) {
       AODmerge();
       mgr->InitAnalysis();
@@ -133,7 +137,7 @@ void AODtrain(Int_t merge=0)
 }                                                                                                                                          
                                                                                                                                             
 //______________________________________________________________________________                                                           
-void AddAnalysisTasks(Int_t merge){                                                                                                                                          
+void AddAnalysisTasks(Int_t merge, const char *cdb_location){                                                                                                                                          
   // Add all analysis task wagons to the train                                                                                               
    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();                                                                     
 
@@ -148,6 +152,17 @@ void AddAnalysisTasks(Int_t merge){
 //      tender->SetDebugLevel(2);
    }
 
+  // CDB connection
+  //
+  if (doCDBconnect && !useTender) {
+    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskCDBconnect.C");
+    AliTaskCDBconnect *taskCDB = AddTaskCDBconnect(cdb_location, run_number);
+    if (!taskCDB) return;
+    AliCDBManager *cdb = AliCDBManager::Instance();
+    cdb->SetDefaultStorage(cdb_location);
+//    taskCDB->SetRunNumber(run_number);
+  }    
+
    if (usePhysicsSelection) {
    // Physics selection task
       gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
@@ -171,7 +186,7 @@ void AddAnalysisTasks(Int_t merge){
        
    if (iESDfilter) {
       //  ESD filter task configuration.
-      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C");      
+      gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/ESDfilter/macros/AddTaskESDFilter.C");    
       if (iMUONcopyAOD) {
          printf("Registering delta AOD file\n");
          mgr->RegisterExtraFile("AliAOD.Muons.root");
@@ -279,7 +294,8 @@ void AddAnalysisTasks(Int_t merge){
 //______________________________________________________________________________
 Bool_t LoadCommonLibraries()
 {
-// Load common analysis libraries.
+
+  // Load common analysis libraries.
    if (!gSystem->Getenv("ALICE_ROOT")) {
       ::Error("AnalysisTrainNew.C::LoadCommonLibraries", "Analysis train requires that analysis libraries are compiled with a local AliRoot"); 
       return kFALSE;
@@ -292,6 +308,7 @@ Bool_t LoadCommonLibraries()
    success &= LoadLibrary("libANALYSIS.so");
    success &= LoadLibrary("libOADB.so");
    success &= LoadLibrary("libANALYSISalice.so");
+   success &= LoadLibrary("libESDfilter.so");
    success &= LoadLibrary("libCORRFW.so");
    gROOT->ProcessLine(".include $ALICE_ROOT/include");
    if (success) {
@@ -307,46 +324,52 @@ Bool_t LoadCommonLibraries()
 //______________________________________________________________________________
 Bool_t LoadAnalysisLibraries()
 {
-// Load common analysis libraries.
-   if (useTender) {
-      if (!LoadLibrary("TENDER") ||
-          !LoadLibrary("TENDERSupplies")) return kFALSE;
-   }       
-   if (iESDfilter || iPWGMuonTrain) {
-      if (!LoadLibrary("PWGmuon")) return kFALSE;
-   }   
-   if (iESDMCLabelAddition) {
-     if (!LoadLibrary("PWGmuondep")) return kFALSE;
-   }
-   // JETAN
-   if (iJETAN) {
-      if (!LoadLibrary("JETAN")) return kFALSE;
-   }
-   if (iJETANdelta) {
-      if (!LoadLibrary("JETAN") ||
-          !LoadLibrary("CGAL") ||
-          !LoadLibrary("fastjet") ||
-          !LoadLibrary("siscone") ||
-          !LoadLibrary("SISConePlugin") ||
-          !LoadLibrary("FASTJETAN")) return kFALSE;
-   }     
-   // PWG3 Vertexing HF
-   if (iPWGHFvertexing || iPWGHFd2h) {
-      if (!LoadLibrary("PWGflowBase") ||
-          !LoadLibrary("PWGflowTasks") ||
-          !LoadLibrary("PWGHFvertexingHF")) return kFALSE;
-   }    
- //    if (iPWGHFvertexing || iPWG3d2h) {
- //     if (!LoadLibrary("PWG3base") ||
- //         !LoadLibrary("PWGHFvertexingHF")) return kFALSE;
- //  }   
-   // PWG3 dielectron
-   if (iPWGDQJPSIfilter) {
-      if (!LoadLibrary("PWGDQdielectron")) return kFALSE;
-   }   
-   
-   ::Info("AnalysisTrainNew.C::LoadAnalysisLibraries", "Load other libraries:   SUCCESS");
-   return kTRUE;
+
+  // Load common analysis libraries.
+  if (useTender || doCDBconnect) {
+    if (!LoadLibrary("TENDER") ||
+       !LoadLibrary("TENDERSupplies")) return kFALSE;
+  }       
+  // CDBconnect
+  if (doCDBconnect && !useTender) {
+    if (!LoadLibrary("PWGPP")) return kFALSE;
+  }
+  
+  if (iESDfilter || iPWGMuonTrain) {
+    if (!LoadLibrary("PWGmuon")) return kFALSE;
+  }   
+  if (iESDMCLabelAddition) {
+    if (!LoadLibrary("PWGmuondep")) return kFALSE;
+  }
+  // JETAN
+  if (iJETAN) {
+    if (!LoadLibrary("JETAN")) return kFALSE;
+  }
+  if (iJETANdelta) {
+    if (!LoadLibrary("JETAN") ||
+       !LoadLibrary("CGAL") ||
+       !LoadLibrary("fastjet") ||
+       !LoadLibrary("siscone") ||
+       !LoadLibrary("SISConePlugin") ||
+       !LoadLibrary("FASTJETAN")) return kFALSE;
+  }     
+  // PWG3 Vertexing HF
+  if (iPWGHFvertexing || iPWGHFd2h) {
+    if (!LoadLibrary("PWGflowBase") ||
+       !LoadLibrary("PWGflowTasks") ||
+       !LoadLibrary("PWGHFvertexingHF")) return kFALSE;
+  }    
+  //    if (iPWGHFvertexing || iPWG3d2h) {
+  //     if (!LoadLibrary("PWG3base") ||
+  //         !LoadLibrary("PWGHFvertexingHF")) return kFALSE;
+  //  }   
+  // PWG3 dielectron
+  if (iPWGDQJPSIfilter) {
+    if (!LoadLibrary("PWGDQdielectron")) return kFALSE;
+  }   
+  
+  ::Info("AnalysisTrainNew.C::LoadAnalysisLibraries", "Load other libraries:   SUCCESS");
+  return kTRUE;
 }
 
 //______________________________________________________________________________
index 2031ff7..f09aa00 100644 (file)
 #include "TMath.h"
 #include "AliMFTConstants.h"
 #include "AliMFTClusterFinder.h"
+#include "TRandom.h"
 
 const Double_t AliMFTClusterFinder::fCutForAvailableDigits = AliMFTConstants::fCutForAvailableDigits;
 const Double_t AliMFTClusterFinder::fCutForAttachingDigits = AliMFTConstants::fCutForAttachingDigits;
-
+const Double_t AliMFTClusterFinder::fMisalignmentMagnitude = AliMFTConstants::fMisalignmentMagnitude;
 
 ClassImp(AliMFTClusterFinder)
 
@@ -47,7 +48,8 @@ AliMFTClusterFinder::AliMFTClusterFinder() :
   fCurrentCluster(0),
   fSegmentation(0),
   fNPlanes(0),
-  sw(0)
+  fApplyMisalignment(kFALSE),
+  fStopWatch(0)
 {
 
   // Default constructor
@@ -55,8 +57,8 @@ AliMFTClusterFinder::AliMFTClusterFinder() :
   for (Int_t iPlane=0; iPlane<fNMaxPlanes; iPlane++) fClustersPerPlane[iPlane] = NULL;
   fDigitsInCluster = new TClonesArray("AliMFTDigit", fNMaxDigitsPerCluster);
   fDigitsInCluster -> SetOwner(kTRUE);
-  sw = new TStopwatch();
-  sw -> Reset();
+  fStopWatch = new TStopwatch();
+  fStopWatch -> Reset();
 
 }
 
@@ -72,7 +74,7 @@ AliMFTClusterFinder::~AliMFTClusterFinder() {
   if (fDigitsInCluster) fDigitsInCluster->Delete(); delete fDigitsInCluster; fDigitsInCluster = NULL;
   delete fSegmentation; fSegmentation=NULL;
 
-  delete sw;
+  delete fStopWatch;
   
   AliDebug(1, "... done!");
   
@@ -128,8 +130,8 @@ void AliMFTClusterFinder::DigitsToClusters(const TObjArray *pDigitList) {
   AliInfo("Starting Clusterization for MFT");
   AliDebug(1, Form("nPlanes = %d", fNPlanes));
 
-  if (!sw) sw = new TStopwatch();
-  sw -> Reset();
+  if (!fStopWatch) fStopWatch = new TStopwatch();
+  fStopWatch -> Reset();
 
   StartEvent(); 
   Bool_t isDigAvailableForNewCluster = kTRUE;
@@ -155,7 +157,7 @@ void AliMFTClusterFinder::DigitsToClusters(const TObjArray *pDigitList) {
     Int_t currentDetElemLocal = -1;
     Bool_t areThereSkippedDigits = kFALSE;
 
-    sw -> Start();
+    fStopWatch -> Start();
 
     while (myDigitList->GetEntries()) {
 
@@ -212,23 +214,33 @@ void AliMFTClusterFinder::DigitsToClusters(const TObjArray *pDigitList) {
 
     }   // no more digits to check in current plane!
 
-    sw -> Print("m");
+    fStopWatch -> Print("m");
 
-    printf("Plane %d: clusters found in %f seconds\n",iPlane,sw->CpuTime());
-    sw->Start();
+    printf("Plane %d: clusters found in %f seconds\n",iPlane,fStopWatch->CpuTime());
+    fStopWatch->Start();
 
     // Now we merge the cluster lists coming from each detection element, to build the cluster list of the plane
 
+    Double_t misalignmentPhi = 2.*TMath::Pi()*gRandom->Rndm();
+    Double_t misalignmentX   = fMisalignmentMagnitude*TMath::Cos(misalignmentPhi);
+    Double_t misalignmentY   = fMisalignmentMagnitude*TMath::Sin(misalignmentPhi);
+
     AliMFTCluster *newCluster = NULL;
     for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) {
       for (Int_t iCluster=0; iCluster<clustersPerDetElem[iDetElem]->GetEntries(); iCluster++) {
        newCluster = (AliMFTCluster*) (clustersPerDetElem[iDetElem]->At(iCluster));
        newCluster -> TerminateCluster();
+       if (fApplyMisalignment) {
+         newCluster -> SetClusterEditable(kTRUE);
+         newCluster -> SetX(newCluster->GetX()+misalignmentX);
+         newCluster -> SetY(newCluster->GetY()+misalignmentY);
+         newCluster -> SetClusterEditable(kFALSE);
+       }
        new ((*fClustersPerPlane[iPlane])[fClustersPerPlane[iPlane]->GetEntries()]) AliMFTCluster(*newCluster);
       }
     }
 
-    printf("%d Clusters in plane %02d merged in %f seconds\n", fClustersPerPlane[iPlane]->GetEntries(), iPlane, sw->CpuTime());
+    printf("%d Clusters in plane %02d merged in %f seconds\n", fClustersPerPlane[iPlane]->GetEntries(), iPlane, fStopWatch->CpuTime());
 
     for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) {
       clustersPerDetElem[iDetElem] -> Delete();
index 47ab4cc..f5a7d39 100644 (file)
@@ -38,6 +38,8 @@ public:
   void SetClusterTreeAddress(TTree *treeCluster);
   void CreateClusters();
 
+  void ApplyMisalignment(Bool_t applyMisalignment) { fApplyMisalignment = applyMisalignment; }
+
   void DigitsToClusters(const TObjArray *pDigitList);
 
   void StartEvent();
@@ -49,6 +51,7 @@ private:
   static const Int_t fNMaxDetElemPerPlane = AliMFTConstants::fNMaxDetElemPerPlane;
   static const Double_t fCutForAvailableDigits;
   static const Double_t fCutForAttachingDigits;
+  static const Double_t fMisalignmentMagnitude;
 
   TClonesArray *fClustersPerPlane[fNMaxPlanes];    //! [fNPlanes] list of clusters [per plane]
 
@@ -60,7 +63,9 @@ private:
  
   Int_t fNPlanes;
 
-  TStopwatch *sw;                                  //!
+  Bool_t fApplyMisalignment;                       // For MC, waiting for OCDB...
+
+  TStopwatch *fStopWatch;                          //!
 
   AliMFTClusterFinder(const AliMFTClusterFinder &source);
   AliMFTClusterFinder& operator=(const AliMFTClusterFinder &source);
index 23dfa51..685eb9b 100644 (file)
@@ -46,4 +46,15 @@ const Double_t AliMFTConstants::fWidthChip = 1.0;
 
 const Double_t AliMFTConstants::fPrecisionPointOfClosestApproach = 10.e-4;  // 10 micron
 
+const Double_t AliMFTConstants::fZEvalKinem = 0.;
+
+const Double_t AliMFTConstants::fXVertexTolerance = 500.e-4;    // 500 micron
+const Double_t AliMFTConstants::fYVertexTolerance = 500.e-4;    // 500 micron
+
+const Double_t AliMFTConstants::fPrimaryVertexResX = 5.e-4;   // 5 micron
+const Double_t AliMFTConstants::fPrimaryVertexResY = 5.e-4;   // 5 micron
+const Double_t AliMFTConstants::fPrimaryVertexResZ = 5.e-4;   // 5 micron
+
+const Double_t AliMFTConstants::fMisalignmentMagnitude = 15.e-4;    // 15 micron
+
 //====================================================================================================================================================
index 5bbae2d..175be43 100644 (file)
@@ -49,6 +49,17 @@ public:
 
   static const Double_t fPrecisionPointOfClosestApproach;  ///< precision (along z) for the research of the point of closest approach for a dimuon
 
+  static const Double_t fZEvalKinem;     // z coordinate at which the kinematics is evaluated for the ESD and AOD tracks
+
+  static const Double_t fXVertexTolerance;   // tolerance on the vertex for the first extrapolation of MUON tracks to I.P.
+  static const Double_t fYVertexTolerance;   // tolerance on the vertex for the first extrapolation of MUON tracks to I.P.
+
+  static const Double_t fPrimaryVertexResX;   // expected res. in Pb-Pb for the prim vtx from ITS+MFT combined vertexing (should not be used, depends on contributors)
+  static const Double_t fPrimaryVertexResY;   // expected res. in Pb-Pb for the prim vtx from ITS+MFT combined vertexing (should not be used, depends on contributors)
+  static const Double_t fPrimaryVertexResZ;   // expected res. in Pb-Pb for the prim vtx from ITS+MFT combined vertexing (should not be used, depends on contributors)
+
+  static const Double_t fMisalignmentMagnitude;   // Expected misalignment magnitude (for MC, waiting for OCDB)
+
 protected:
 
   AliMFTConstants() : TObject() {}
index b07dfa0..81054fb 100644 (file)
@@ -128,8 +128,6 @@ void AliMFTReconstructor::Reconstruct(TTree *digitsTree, TTree *clustersTree) co
 
   // Clusterization
 
-  AliDebug(1, Form("nPlanes = %d",fNPlanes));
-
   for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
     AliDebug(1, Form("Setting Address for Branch Plane_%02d", iPlane)); 
     digitsTree->SetBranchAddress(Form("Plane_%02d",iPlane), &(*fDigits)[iPlane]);
@@ -139,16 +137,12 @@ void AliMFTReconstructor::Reconstruct(TTree *digitsTree, TTree *clustersTree) co
 
   AliDebug(1, "Creating clusterFinder");
   AliMFTClusterFinder *clusterFinder = new AliMFTClusterFinder();
+  clusterFinder->ApplyMisalignment(kTRUE);    // only in case of MC !!!
   clusterFinder->Init("AliMFTGeometry.root");
-  AliDebug(1, "clusterFinder->MakeClusterBranch(clustersTree)");
   clusterFinder->MakeClusterBranch(clustersTree);
-  AliDebug(1, "clusterFinder->SetClusterTreeAddress(clustersTree)");
   clusterFinder->SetClusterTreeAddress(clustersTree);
-  AliDebug(1, "clusterFinder->DigitsToClusters(fDigits)");
   clusterFinder->DigitsToClusters(fDigits);
-  AliDebug(1, "clustersTree->Fill()");
   clustersTree->Fill();                         // fill tree for current event
-  AliDebug(1, "delete clusterFinder");
   delete clusterFinder;
 
   for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
index 76944e7..40554a2 100644 (file)
@@ -1,4 +1,4 @@
-/**************************************************************************
+/*************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 #include "AliMFTTrackerMU.h"
 #include "TMath.h"
 #include "AliRun.h"
+#include "AliRunLoader.h"
+#include "AliHeader.h"
+#include "AliGenEventHeader.h"
+#include "TArrayF.h"
 #include "AliMFT.h"
 #include "AliMUONTrackExtrap.h"
 #include "AliMUONTrack.h"
@@ -61,9 +65,11 @@ AliMFTTrackerMU::AliMFTTrackerMU() :
   fMUONTrack(0),
   fCurrentTrack(0),
   fFinalBestCandidate(0),
-  fVertexErrorX(0.015),
-  fVertexErrorY(0.015),
-  fVertexErrorZ(0.010),
+  fXExtrapVertex(0),
+  fYExtrapVertex(0),
+  fZExtrapVertex(0),
+  fXExtrapVertexError(0),
+  fYExtrapVertexError(0),
   fBransonCorrection(kFALSE)
 {
 
@@ -136,9 +142,9 @@ Int_t AliMFTTrackerMU::LoadClusters(TTree *cTree) {
 
 void AliMFTTrackerMU::UnloadClusters() {
   
-//   //--------------------------------------------------------------------
-//   // This function unloads MFT clusters
-//   //--------------------------------------------------------------------
+  //--------------------------------------------------------------------
+  // This function unloads MFT clusters
+  //--------------------------------------------------------------------
 
   for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
     fMFTClusterArray[iPlane]      -> Clear("C");
@@ -168,15 +174,26 @@ Int_t AliMFTTrackerMU::Clusters2Tracks(AliESDEvent *event) {
 
   fESD = event;
 
-  // get the ITS primary vertex
+  fXExtrapVertex = 0;
+  fYExtrapVertex = 0;
+  fZExtrapVertex = 0;
+  fXExtrapVertexError = AliMFTConstants::fXVertexTolerance;
+  fYExtrapVertexError = AliMFTConstants::fYVertexTolerance;
 
-  Double_t vertex[3] = {0., 0., 0.};
+  // Imposing a fixed primary vertex, in order to keep memory of its position. Taking the primary vertex would imply the risk
+  // of loosing memory of its position when passing from ESD to AOD, due to possible refitting
   const AliESDVertex* esdVert = fESD->GetVertex(); 
   if (esdVert->GetNContributors() > 0 || !strcmp(esdVert->GetTitle(),"vertexer: smearMC")) {
-    esdVert->GetXYZ(vertex);
-    AliDebug(1,Form("found vertex (%e,%e,%e)",vertex[0],vertex[1],vertex[2]));
+    fXExtrapVertex = esdVert->GetX();
+    fYExtrapVertex = esdVert->GetY();
+    fZExtrapVertex = esdVert->GetZ();
+    fXExtrapVertexError = TMath::Max(AliMFTConstants::fXVertexTolerance, esdVert->GetXRes());
+    fYExtrapVertexError = TMath::Max(AliMFTConstants::fYVertexTolerance, esdVert->GetYRes());
+    AliInfo(Form("Found ESD vertex from %d contributors (%f +/- %f,  %f +/- %f,  %f)", 
+                esdVert->GetNContributors(),fXExtrapVertex,fXExtrapVertexError,fYExtrapVertex,fYExtrapVertexError,fZExtrapVertex));
   }
-  
+  else GetVertexFromMC();    
+
   //----------- Read ESD MUON tracks -------------------
 
   Int_t nTracksMUON = event->GetNumberOfMuonTracks();
@@ -304,14 +321,12 @@ Int_t AliMFTTrackerMU::Clusters2Tracks(AliESDEvent *event) {
 
       //----------------------- Save the information to the AliESDMuonGlobalTrack object
 
-      newTrack -> EvalKinem(vertex[2]);     // we evaluate the kinematics at the primary vertex
+      newTrack -> EvalKinem(AliMFTConstants::fZEvalKinem);
 
       AliDebug(2,"Creating a new Muon Global Track");
       AliESDMuonGlobalTrack *myESDTrack = event->NewMuonGlobalTrack();
       myESDTrack -> SetPxPyPz(newTrack->Px(), newTrack->Py(), newTrack->Pz());
       
-//       waiting for the commit of the new version of AliESDMuonGlobalTrack...
-
       myESDTrack -> SetLabel(newTrack->GetMCLabel());
       myESDTrack -> SetChi2OverNdf(newTrack->GetChi2OverNdf());
       myESDTrack -> SetCharge(newTrack->GetCharge());
@@ -319,7 +334,7 @@ Int_t AliMFTTrackerMU::Clusters2Tracks(AliESDEvent *event) {
       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 -> SetXYAtVertex(newTrack->GetOffsetX(0., AliMFTConstants::fZEvalKinem), newTrack->GetOffsetY(0., AliMFTConstants::fZEvalKinem));
       myESDTrack -> SetRAtAbsorberEnd(newTrack->GetRAtAbsorberEnd());
       myESDTrack -> SetChi2MatchTrigger(esdTrack->GetChi2MatchTrigger());
       myESDTrack -> SetMuonClusterMap(esdTrack->GetMuonClusterMap());
@@ -327,6 +342,14 @@ Int_t AliMFTTrackerMU::Clusters2Tracks(AliESDEvent *event) {
       myESDTrack -> SetHitsPatternInTrigChTrk(esdTrack->GetHitsPatternInTrigChTrk());
       myESDTrack -> Connected(esdTrack->IsConnected());
 
+      ULong_t mftClusterPattern = 0;
+      for (Int_t iCluster=0; iCluster<newTrack->GetNMFTClusters(); iCluster++) {
+       AliMFTCluster *localCluster = newTrack->GetMFTCluster(iCluster);
+       mftClusterPattern |= 1 << localCluster->GetPlane();
+       mftClusterPattern |= IsCorrectMatch(localCluster, newTrack->GetMCLabel()) << fNMaxPlanes+localCluster->GetPlane();
+      }
+      myESDTrack -> SetMFTClusterPattern(mftClusterPattern);
+      
       //---------------------------------------------------------------------------------
 
     }
@@ -388,19 +411,16 @@ Int_t AliMFTTrackerMU::FindClusterInPlane(Int_t planeId) {
     currentParamBack  = (*((AliMUONTrackParam*)(fMUONTrack->GetTrackParamAtCluster()->First())));
     currentParamForResearchFront = currentParamFront;
     currentParamForResearchBack  = currentParamBack;
-    Double_t xExtrap = gRandom->Gaus(0,fVertexErrorX);
-    Double_t yExtrap = gRandom->Gaus(0,fVertexErrorY);
-    Double_t zExtrap = gRandom->Gaus(0,fVertexErrorZ);
     if (fBransonCorrection) {
-      AliMUONTrackExtrap::ExtrapToVertex(&currentParamFront, xExtrap, yExtrap, zExtrap, fVertexErrorX, fVertexErrorY); 
-      AliMUONTrackExtrap::ExtrapToVertex(&currentParamBack,  xExtrap, yExtrap, zExtrap, fVertexErrorX, fVertexErrorY); 
+      AliMUONTrackExtrap::ExtrapToVertex(&currentParamFront, fXExtrapVertex, fYExtrapVertex, fZExtrapVertex, fXExtrapVertexError, fYExtrapVertexError); 
+      AliMUONTrackExtrap::ExtrapToVertex(&currentParamBack,  fXExtrapVertex, fYExtrapVertex, fZExtrapVertex, fXExtrapVertexError, fYExtrapVertexError); 
     }
     else {
-      AliMUONTrackExtrap::ExtrapToVertexWithoutBranson(&currentParamFront, zExtrap);
-      AliMUONTrackExtrap::ExtrapToVertexWithoutBranson(&currentParamBack,  zExtrap);
+      AliMUONTrackExtrap::ExtrapToVertexWithoutBranson(&currentParamFront, fZExtrapVertex);
+      AliMUONTrackExtrap::ExtrapToVertexWithoutBranson(&currentParamBack,  fZExtrapVertex);
     }
-    AliMUONTrackExtrap::ExtrapToVertex(&currentParamForResearchFront, xExtrap, yExtrap, zExtrap, fVertexErrorX, fVertexErrorY); 
-    AliMUONTrackExtrap::ExtrapToVertex(&currentParamForResearchBack,  xExtrap, yExtrap, zExtrap, fVertexErrorX, fVertexErrorY); 
+    AliMUONTrackExtrap::ExtrapToVertex(&currentParamForResearchFront, fXExtrapVertex, fYExtrapVertex, fZExtrapVertex, fXExtrapVertexError, fYExtrapVertexError); 
+    AliMUONTrackExtrap::ExtrapToVertex(&currentParamForResearchBack,  fXExtrapVertex, fYExtrapVertex, fZExtrapVertex, fXExtrapVertexError, fYExtrapVertexError); 
   }
   else {          // MFT planes others than the last one: mult. scattering correction because of the upstream MFT planes is performed
     currentParamFront = (*((AliMUONTrackParam*)(fCurrentTrack->GetTrackParamAtCluster()->First())));
@@ -531,3 +551,50 @@ Double_t AliMFTTrackerMU::TryOneCluster(const AliMUONTrackParam &trackParam, Ali
 
 //=========================================================================================================================================
 
+Bool_t AliMFTTrackerMU::IsCorrectMatch(AliMFTCluster *cluster, Int_t labelMC) {
+
+  Bool_t result = kFALSE;
+
+  // check if the cluster belongs to the correct MC track
+
+  for (Int_t iTrack=0; iTrack<cluster->GetNMCTracks(); iTrack++) {
+    if (cluster->GetMCLabel(iTrack)==labelMC) {
+      result = kTRUE;
+      break;
+    }
+  }
+
+  return result;
+
+}
+
+//======================================================================================================================================
+
+void AliMFTTrackerMU::GetVertexFromMC() {
+
+  AliRunLoader *fRunLoader = AliRunLoader::Open("galice.root");
+  if (!fRunLoader) {
+    AliError("no run loader found in file galice.root");
+    return;
+  }
+
+  fRunLoader->CdGAFile();
+  fRunLoader->LoadgAlice();
+  fRunLoader->LoadHeader();
+  fRunLoader->GetEvent(gAlice->GetEvNumber());
+  
+  TArrayF vtx(3);
+  fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(vtx);
+
+  fXExtrapVertex = gRandom->Gaus(vtx[0], AliMFTConstants::fPrimaryVertexResX);
+  fYExtrapVertex = gRandom->Gaus(vtx[1], AliMFTConstants::fPrimaryVertexResY);
+  fZExtrapVertex = gRandom->Gaus(vtx[2], AliMFTConstants::fPrimaryVertexResZ);
+  fXExtrapVertexError = AliMFTConstants::fXVertexTolerance;
+  fYExtrapVertexError = AliMFTConstants::fYVertexTolerance;
+  AliInfo(Form("Set ESD vertex from MC (%f +/- %f,  %f +/- %f,  %f)", 
+              fXExtrapVertex,fXExtrapVertexError,fYExtrapVertex,fYExtrapVertexError,fZExtrapVertex));
+  
+}
+
+//======================================================================================================================================
+
index b1703f9..f4c0ddc 100644 (file)
@@ -49,11 +49,14 @@ public:
 
   Int_t FindClusterInPlane(Int_t planeId);
 
-  void SetVertexError(Double_t xErr, Double_t yErr, Double_t zErr) { fVertexErrorX=xErr; fVertexErrorY=yErr; fVertexErrorZ=zErr; }
   void SetMinResearchRadiusAtPlane(Int_t plane, Double_t radius) { if (plane>=0 && plane<fNMaxPlanes) fMinResearchRadiusAtPlane[plane] = radius; }
 
   Double_t TryOneCluster(const AliMUONTrackParam &trackParam, AliMFTCluster *cluster);
 
+  Bool_t IsCorrectMatch(AliMFTCluster *cluster, Int_t labelMC);
+
+  void GetVertexFromMC();
+
   /// Dummy implementation
   virtual Int_t PropagateBack(AliESDEvent* /*event*/) {return 0;}
   /// Dummy implementation
@@ -94,9 +97,11 @@ protected:
   AliMuonForwardTrack *fFinalBestCandidate;     //! best final candidate (if any)
 
   // uncertainty on the x position of the primary vertex (seed for the extrapolation of the MUON tracks)
-  Double_t fVertexErrorX;   
-  Double_t fVertexErrorY;
-  Double_t fVertexErrorZ;
+  Double_t fXExtrapVertex;   
+  Double_t fYExtrapVertex;
+  Double_t fZExtrapVertex;
+  Double_t fXExtrapVertexError;
+  Double_t fYExtrapVertexError;
 
   Bool_t fBransonCorrection;    // if TRUE, Branson Correction is applied when extrapolating the MUON tracks to the vertex region
 
@@ -106,7 +111,7 @@ private:
 
   AliMFTTrackerMU(const AliMFTTrackerMU &tracker);
   AliMFTTrackerMU & operator=(const AliMFTTrackerMU &tracker);
-  ClassDef(AliMFTTrackerMU,1)   //MFT tracker for muon tracks
+  ClassDef(AliMFTTrackerMU,2)   //MFT tracker for muon tracks
 
 };
 
index 965cf99..fdd36fb 100644 (file)
@@ -25,7 +25,7 @@
 # SHLIBS - Shared Libraries and objects for linking (Executables only)           #
 #--------------------------------------------------------------------------------#
 
-set ( SRCS  AliMFTConstants.cxx AliMFTPlane.cxx AliMFTSegmentation.cxx AliMFTDigit.cxx AliMFTCluster.cxx )
+set ( SRCS  AliMFTConstants.cxx AliMFTPlane.cxx AliMFTSegmentation.cxx AliMFTDigit.cxx AliMFTCluster.cxx AliMFTSupport.cxx )
 
 string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
 
index 1501e36..b6f526b 100644 (file)
@@ -40,8 +40,6 @@
 #include "AliMFT.h"
 #endif
 
-// Git push Test: R. Tieulent
-
 enum PDCProc_t {kGenBox,
                kGenMuonLMR,
                kGenParamJpsi,
index 3f4362f..63f7f78 100644 (file)
@@ -11,5 +11,6 @@
 #pragma link C++ class  AliMFTSegmentation+;
 #pragma link C++ class  AliMFTDigit+;
 #pragma link C++ class  AliMFTCluster+;
+#pragma link C++ class  AliMFTSupport;
 
 #endif