- AliMUONRecoParam.cxx:

Fill in the "event specie" variable according what the set of
parameters is designed for, as defined in AliRecoParam:

- AliMUONESDInterface.h, AliMUONESDInterface.cxx,
AliMUONTrackReconstructor.cxx, AliMUONTrackReconstructorK.cxx,
AliMUONRecoCheck.h, AliMUONRecoCheck.cxx, MUONRefit.C,
MUONAlignment.C, AliEveMUONData.cxx, AliEveMUONTrack.cxx:
Use the Kalman filter + smoother to recompute track parameters at
each clusters when recovering a MUONTrack from an ESDTtrack.
You can use the static method ResetTracker(...) to change it by
providing a new AliMUONRecoParam object to the interface.

- AliMUONRefitter.h, AliMUONRefitter.cxx, AliMUONTrackHitPattern.h:
fix compilation warning

- AliMUONVTrackReconstructor.h, AliMUONTrackHitPattern.cxx,
AliMUONTrackExtrap.cxx, AliMUONTrack.cxx:
Remove unnecessary include

- AliMUONReconstructor.cxx, AliMUONVTrackReconstructor.cxx,
AliMUONTracker.cxx, MUONClusterInfo.C:

Philippe

diff --git a/EVE/EveDet/AliEveMUONData.cxx b/EVE/EveDet/AliEveMUONData.cxx
index 88297c18915c0388544c34cd74cd0b59dddaf299..57edfcb75aa18126e43eb71c40df9d702640e7a5 100644 (file)
--- a/EVE/EveDet/AliEveMUONData.cxx
+++ b/EVE/EveDet/AliEveMUONData.cxx
@@ -28,7 +28,6 @@
 #include "AliMUONTrack.h"
 #include "AliMUONESDInterface.h"
 #include "AliESDMuonTrack.h"
-#include "AliMUONRecoParam.h"
 #include "AliESDEvent.h"
 #include "TTree.h"
 #include "TString.h"
@@ -276,15 +275,11 @@ void AliEveMUONData::LoadRecPointsFromESD(Char_t *fileName)
     return;
   }
     
-  AliMUONRecoParam* recoParam = AliMUONRecoParam::GetCosmicParam();
-  
-  cout << "FIXME: I should get the RecoParams from the OCDB at this point !" << endl;
-  
   Int_t nTracks = Int_t(esdEvent->GetNumberOfMuonTracks());
   for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
     esdTrack = esdEvent->GetMuonTrack(iTrack);
     if (!esdTrack->ClustersStored()) continue;
-    AliMUONESDInterface::ESDToMUON(recoParam,*esdTrack,muonTrack);
+    AliMUONESDInterface::ESDToMUON(*esdTrack,muonTrack);
     nTrackParam = muonTrack.GetTrackParamAtCluster()->GetEntries();
     for(Int_t iCluster = 0; iCluster < nTrackParam; iCluster++) {
       trackParam = (AliMUONTrackParam *) muonTrack.GetTrackParamAtCluster()->At(iCluster);
@@ -304,8 +299,6 @@ void AliEveMUONData::LoadRecPointsFromESD(Char_t *fileName)
 
   delete esdEvent;
   
-  delete recoParam;
-  
   esdFile->Close();
 
 }

diff --git a/EVE/EveDet/AliEveMUONTrack.cxx b/EVE/EveDet/AliEveMUONTrack.cxx
index e38290fa7cdbd444169a1e77f57d2b370badcce2..6bb0e9ed659c1d1be0f2aa1ee75470576906e0b2 100644 (file)
--- a/EVE/EveDet/AliEveMUONTrack.cxx
+++ b/EVE/EveDet/AliEveMUONTrack.cxx
@@ -26,7 +26,6 @@
 #include <AliMUONConstants.h>
 #include <AliMUONESDInterface.h>
 #include <AliMUONVCluster.h>
-#include <AliMUONRecoParam.h>
 
 #include <TClonesArray.h>
 #include <TStyle.h>
@@ -676,14 +675,8 @@ void AliEveMUONTrack::MakeESDTrack(AliESDMuonTrack *mtrack)
 
   fTrack = new AliMUONTrack();
 
-  AliMUONRecoParam* recoParam = AliMUONRecoParam::GetCosmicParam();
-  
-  cout << "FIXME: should get recoParam from OCDB here !" << endl;
-  
   // create a simple track from the ESD track
-  AliMUONESDInterface::ESDToMUON(recoParam,*mtrack,*fTrack);
-
-  delete recoParam;
+  AliMUONESDInterface::ESDToMUON(*mtrack,*fTrack);
   
   // reset track parameters at vertex to the ones at DCA
   AliMUONTrackParam paramAtDCA;

diff --git a/MUON/AliMUONESDInterface.cxx b/MUON/AliMUONESDInterface.cxx
index 3c1299552d5f699b48b9ef303e1e893615b7e90d..605765bbcb2e35c0b1f27f07a90e11d98678f800 100644 (file)
--- a/MUON/AliMUONESDInterface.cxx
+++ b/MUON/AliMUONESDInterface.cxx
@@ -61,6 +61,9 @@
 /// 2) loading a whole ESDEvent and using the finders and/or the iterators
 ///    to access the corresponding MUON objects
 ///
+/// note: You can set the recoParam used to refit the MUON track with ResetTracker(...);
+///       By default we use Kalman filter + Smoother
+///
 /// \author Philippe Pillot
 //-----------------------------------------------------------------------------
 
@@ -68,6 +71,7 @@
 ClassImp(AliMUONESDInterface)
 /// \endcond
 
+AliMUONRecoParam* AliMUONESDInterface::fgRecoParam = 0x0;
 AliMUONVTrackReconstructor* AliMUONESDInterface::fgTracker = 0x0;
 
 TString AliMUONESDInterface::fgTrackStoreName = "AliMUONTrackStoreV1";
@@ -76,9 +80,8 @@ TString AliMUONESDInterface::fgDigitStoreName = "AliMUONDigitStoreV2R";
 TString AliMUONESDInterface::fgTriggerStoreName = "AliMUONTriggerStoreV1";
 
 //_____________________________________________________________________________
-AliMUONESDInterface::AliMUONESDInterface(AliMUONRecoParam* recoParam)
+AliMUONESDInterface::AliMUONESDInterface()
 : TObject(),
-fRecoParam(recoParam),
 fTracks(0x0),
 fDigits(0x0),
 fTriggers(0x0),
@@ -159,7 +162,7 @@ void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent)
     if (!esdTrack->ContainTrackerData()) continue;
     
     // add it to track store
-    AliMUONTrack* track = Add(GetRecoParam(),*esdTrack, *fTracks);
+    AliMUONTrack* track = Add(*esdTrack, *fTracks);
     
     // prepare cluster map
     AliMpExMap* cMap = new AliMpExMap;
@@ -431,6 +434,32 @@ AliMUONVCluster* AliMUONESDInterface::FindClusterInTrack(const AliMUONTrack& tra
 //                                static methods                               //
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
 
+//_____________________________________________________________________________
+void AliMUONESDInterface::ResetTracker(const AliMUONRecoParam* recoParam)
+{
+  /// Reset the MUON tracker using "recoParam" if provided.
+  /// If not provided, will use Kalman filter + Smoother
+  
+  delete fgTracker;
+  delete fgRecoParam;
+  
+  if (recoParam) {
+    
+    fgRecoParam = new AliMUONRecoParam(*recoParam);
+    
+  }else {
+    
+    fgRecoParam = AliMUONRecoParam::GetLowFluxParam();
+    fgRecoParam->SetTrackingMode("KALMAN");
+    fgRecoParam->UseSmoother(kTRUE);
+    fgRecoParam->SetBendingVertexDispersion(10.);
+    
+  }
+  
+  fgTracker = AliMUONTracker::CreateTrackReconstructor(fgRecoParam,0x0);
+  
+}
+
 //_____________________________________________________________________________
 AliMUONVTrackStore* AliMUONESDInterface::NewTrackStore()
 {
@@ -609,9 +638,12 @@ void AliMUONESDInterface::SetParamCov(const AliMUONTrackParam& trackParam, AliES
 }
 
 //_____________________________________________________________________________
-void AliMUONESDInterface::ESDToMUON(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONTrack& track)
+void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track)
 {
   /// Transfert data from ESDMuon track to MUON track
+  /// note: The MUON track recovered from ESD is refitted by using the provided recoParams.
+  ///       If not provided (=0x0), the parameters at each cluster are simply the
+  ///       extrapolation of parameters at the first one.
   
   // if the ESDMuon track is a ghost then return an empty MUON track
   if (!esdTrack.ContainTrackerData()) {
@@ -679,7 +711,7 @@ void AliMUONESDInterface::ESDToMUON(const AliMUONRecoParam* recoParam, const Ali
     AliMUONTrackExtrap::ExtrapToZCov(firstTrackParam,firstTrackParam->GetClusterPtr()->GetZ());
     
     // refit the track to get better parameters and covariances at each cluster (temporary disable track improvement)
-    if (!fgTracker) fgTracker = AliMUONTracker::CreateTrackReconstructor(recoParam,0x0);
+    if (!fgTracker) ResetTracker();
     if (!fgTracker->RefitTrack(track, kFALSE)) track.UpdateCovTrackParamAtCluster();
     
   } else {
@@ -924,14 +956,13 @@ void AliMUONESDInterface::MUONToESD(const AliMUONVDigit& digit, AliESDMuonPad& e
 }
 
 //___________________________________________________________________________
-AliMUONTrack* 
-AliMUONESDInterface::Add(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore)
+AliMUONTrack* AliMUONESDInterface::Add(const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore)
 {
   /// Create MUON track from ESDMuon track and add it to the store
   /// return a pointer to the track into the store (0x0 if the track already exist)
   if(trackStore.FindObject(esdTrack.GetUniqueID())) return 0x0;
   AliMUONTrack* track = trackStore.Add(AliMUONTrack());
-  ESDToMUON(recoParam,esdTrack, *track);
+  ESDToMUON(esdTrack, *track);
   return track;
 }
 

diff --git a/MUON/AliMUONESDInterface.h b/MUON/AliMUONESDInterface.h
index 5541e861f01f119b7ef190ff5e14c244fcee52a5..8d566436ad9ce04d03ef286858f78f77c295384c 100644 (file)
--- a/MUON/AliMUONESDInterface.h
+++ b/MUON/AliMUONESDInterface.h
@@ -38,7 +38,7 @@ class AliMUONESDInterface : public TObject
 {
 public: // methods to play with internal objects
   
-  AliMUONESDInterface(AliMUONRecoParam* recoParam);
+  AliMUONESDInterface();
   virtual ~AliMUONESDInterface();
   
   virtual void Clear(Option_t* = "");
@@ -79,10 +79,12 @@ public: // methods to play with internal objects
   TIterator* CreateDigitIteratorInCluster(UInt_t clusterId) const;
   TIterator* CreateLocalTriggerIterator() const;
   
-  const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
   
 public: // static methods
   
+  /// Reset the MUON tracker (using "recoParam" if provided)
+  static void ResetTracker(const AliMUONRecoParam* recoParam = 0x0);
+  
   /// Set the version of track store
   static void UseTrackStore(TString name) {fgTrackStoreName = name;}
   /// Set the version of cluster store
@@ -111,7 +113,7 @@ public: // static methods
   static void SetParamCov(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack);
   
   // ESDMuon objects --> MUON objects conversion
-  static void ESDToMUON(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONTrack& track);
+  static void ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track);
   static void ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONLocalTrigger& locTrg);
   static void ESDToMUON(const AliESDMuonCluster& esdCluster, AliMUONVCluster& cluster);
   static void ESDToMUON(const AliESDMuonPad& esdPad, AliMUONVDigit& digit);
@@ -125,7 +127,7 @@ public: // static methods
   
   // Add ESD object into the corresponding MUON store
   // return a pointer to the corresponding MUON object into the store
-  static AliMUONTrack*    Add(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore);
+  static AliMUONTrack*    Add(const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore);
   static void             Add(const AliESDMuonTrack& esdTrack, AliMUONVTriggerStore& triggerStore);
   static AliMUONVCluster* Add(const AliESDMuonCluster& esdCluster, AliMUONVClusterStore& clusterStore);
   static AliMUONVDigit*   Add(const AliESDMuonPad& esdPad, AliMUONVDigitStore& digitStore);
@@ -145,7 +147,8 @@ private:
   
 private:
   
-  static AliMUONVTrackReconstructor* fgTracker; ///< track reconstructor for refitting
+  static AliMUONRecoParam*           fgRecoParam; ///< reconstruction parameters for refitting
+  static AliMUONVTrackReconstructor* fgTracker;   ///< track reconstructor for refitting
     
   static TString fgTrackStoreName;   ///< class name of the track store to use
   static TString fgClusterStoreName; ///< class name of the cluster store to use
@@ -161,7 +164,6 @@ private:
   AliMpExMap* fClusterMap; ///< map of clusters
   AliMpExMap* fDigitMap;   ///< map of digits
   
-  const AliMUONRecoParam* fRecoParam; ///< get reco param
   
   ClassDef(AliMUONESDInterface,0)
 };

diff --git a/MUON/AliMUONRecoCheck.cxx b/MUON/AliMUONRecoCheck.cxx
index 7bc85de0e1d525c6d4913488939e4fe21c98aefc..fd9e35aca12ae2a178518fa0a642e230778a5916 100644 (file)
--- a/MUON/AliMUONRecoCheck.cxx
+++ b/MUON/AliMUONRecoCheck.cxx
@@ -39,7 +39,6 @@
 #include "AliMUONVClusterStore.h"
 #include "AliMUONConstants.h"
 #include "AliMUONESDInterface.h"
-#include "AliMUONRecoParam.h"
 #include "AliMCEventHandler.h"
 #include "AliMCEvent.h"
 #include "AliStack.h"
@@ -59,9 +58,8 @@ ClassImp(AliMUONRecoCheck)
 /// \endcond
 
 //_____________________________________________________________________________
-AliMUONRecoCheck::AliMUONRecoCheck(AliMUONRecoParam* recoParam, Char_t *esdFileName, Char_t *pathSim)
+AliMUONRecoCheck::AliMUONRecoCheck(Char_t *esdFileName, Char_t *pathSim)
 : TObject(),
-fRecoParam(recoParam),
 fMCEventHandler(new AliMCEventHandler()),
 fESDEvent(new AliESDEvent()),
 fESDTree (0x0),
@@ -191,7 +189,7 @@ void AliMUONRecoCheck::MakeReconstructedTracks()
   Int_t nTracks = (Int_t) fESDEvent->GetNumberOfMuonTracks();
   for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
     AliESDMuonTrack* esdTrack = fESDEvent->GetMuonTrack(iTrack);
-    if (esdTrack->ContainTrackerData()) AliMUONESDInterface::Add(GetRecoParam(),*esdTrack, *fRecoTrackStore);
+    if (esdTrack->ContainTrackerData()) AliMUONESDInterface::Add(*esdTrack, *fRecoTrackStore);
   }
   
 }

diff --git a/MUON/AliMUONRecoCheck.h b/MUON/AliMUONRecoCheck.h
index 4e937c503b51cbb4e30c825e6aea44022a0c0f69..5600a2c99e54217b969543e7528fb0510c0df576 100644 (file)
--- a/MUON/AliMUONRecoCheck.h
+++ b/MUON/AliMUONRecoCheck.h
@@ -18,12 +18,11 @@ class TTree;
 class AliESDEvent;
 class AliMCEventHandler;
 class AliMUONVTrackStore;
-class AliMUONRecoParam;
 
 class AliMUONRecoCheck : public TObject 
 {
 public:
-  AliMUONRecoCheck(AliMUONRecoParam* recoParam, Char_t *chLoader, Char_t *pathSim = "./");
+  AliMUONRecoCheck(Char_t *chLoader, Char_t *pathSim = "./");
   virtual ~AliMUONRecoCheck();
 
   /// Return the list of reconstructed tracks
@@ -50,8 +49,6 @@ private:
   /// Not implemented
   AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
 
-  const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; }
-  
   void ResetStores();
   
   void MakeReconstructedTracks();
@@ -74,8 +71,6 @@ private:
   AliMUONVTrackStore* fRecoTrackRefStore; ///< current reconstructible tracks (owner)
   AliMUONVTrackStore* fRecoTrackStore;    ///< current reconstructed tracks (owner)
   
-  const AliMUONRecoParam* fRecoParam; ///< pointer to reco param
-  
   ClassDef(AliMUONRecoCheck, 0)   //Utility class to check reconstruction
 };
 

diff --git a/MUON/AliMUONRecoParam.cxx b/MUON/AliMUONRecoParam.cxx
index 33f88ecbf528bc8f517f9cc7bad7ce1ec56bdb5a..a5fb04f614ce349bd887c7cb3a7a480e993efab1 100644 (file)
--- a/MUON/AliMUONRecoParam.cxx
+++ b/MUON/AliMUONRecoParam.cxx
@@ -26,9 +26,10 @@
 
 
 #include "AliMUONRecoParam.h"
+#include "AliMUONPadStatusMaker.h"
 
+#include "AliRecoParam.h"
 #include "AliLog.h"
-#include "AliMUONPadStatusMaker.h"
 
 #include <Riostream.h>
 
@@ -70,12 +71,9 @@ AliMUONRecoParam::AliMUONRecoParam()
   fChargeSigmaCut(4.0)
 {
   /// Constructor
-  SetNameTitle("MUON","MUON");
   
-       SetDefaultLimits();
-       
-  // use the default parameters for low flux environment
-  SetLowFluxParam();
+  SetNameTitle("Dummy","Dummy");
+  SetDefaultLimits();
 }
 
 //_____________________________________________________________________________
@@ -147,6 +145,8 @@ void AliMUONRecoParam::SetLowFluxParam()
 {
   /// Set reconstruction parameters for low flux environment
   
+  SetNameTitle("Low Flux","Low Flux");
+  SetEventSpecie(AliRecoParam::kLowMult);
   fMinBendingMomentum = 1.;
   fMaxBendingMomentum = 3000.;
   fMaxNonBendingSlope = 0.3;
@@ -180,6 +180,8 @@ void AliMUONRecoParam::SetHighFluxParam()
 {
   /// Set reconstruction parameters for high flux environment
   
+  SetNameTitle("High Flux","High Flux");
+  SetEventSpecie(AliRecoParam::kHighMult);
   fMinBendingMomentum = 1.;
   fMaxBendingMomentum = 3000.;
   fMaxNonBendingSlope = 0.3;
@@ -229,6 +231,8 @@ void AliMUONRecoParam::SetCosmicParam()
 {
   /// Set reconstruction parameters for high flux environment
   
+  SetNameTitle("Cosmic","Cosmic");
+  SetEventSpecie(AliRecoParam::kCosmic);
   fMinBendingMomentum = 1.;
   fMaxBendingMomentum = 10000000.;
   fMaxNonBendingSlope = 0.3;
@@ -263,7 +267,9 @@ void AliMUONRecoParam::Print(Option_t *option) const
   /// print reconstruction parameters
   /// if option = FULL then print also unused parameters
   
-  cout<<endl<<"\t------Reconstruction parameters------"<<endl;
+  cout<<endl<<"\t------Reconstruction parameters ("<<GetName()<<")------"<<endl;
+  
+  if (IsDefault()) cout<<"\t\t*** Parameters used by default ***"<<endl;
   
   cout<<Form("Calibration mode = %s",fCalibrationMode.Data())<<endl;
   cout<<Form("Clustering mode = %s",fClusteringMode.Data())<<endl;
@@ -402,7 +408,7 @@ void AliMUONRecoParam::Print(Option_t *option) const
   
   cout << Form("And we cut on charge >= %7.2f x ( pedestal sigma ) ",ChargeSigmaCut()) << endl;
   
-  cout<<"\t-------------------------------------"<<endl<<endl;
+  cout<<"\t----------------------------------------------"<<endl<<endl;
   
 }
 

diff --git a/MUON/AliMUONReconstructor.cxx b/MUON/AliMUONReconstructor.cxx
index 935c2f9e6fe0051a690672c9bae3623fbea38045..bbb4e15c8012f1e5105c51d8d43d2bdd723e5f98 100644 (file)
--- a/MUON/AliMUONReconstructor.cxx
+++ b/MUON/AliMUONReconstructor.cxx
@@ -19,10 +19,9 @@
 ///
 /// Implementation of AliReconstructor for MUON subsystem.
 ///
-/// The clustering mode and the associated parameters can be changed by using
-/// AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLow(High)FluxParam();
-/// muonRecoParam->Set...(); // see methods in AliMUONRecoParam.h for details
-/// AliRecoParam::Instance()->RegisterRecoParam(muonRecoParam);
+/// The clustering mode and the associated parameters can be changed through the
+/// AliMUONRecoParam object set in the reconstruction macro or read from the CDB
+/// (see methods in AliMUONRecoParam.h file for details)
 ///
 /// Valid modes are :
 ///

diff --git a/MUON/AliMUONRefitter.cxx b/MUON/AliMUONRefitter.cxx
index 75ec6eff6c700915f06bd15c6578cd979f75c448..6664980318644654d915f0ffd33f597880d40b46 100644 (file)
--- a/MUON/AliMUONRefitter.cxx
+++ b/MUON/AliMUONRefitter.cxx
@@ -38,7 +38,9 @@
 //-----------------------------------------------------------------------------
 /// \class AliMUONRefitter
 ///
-/// create new MUON object from ESD objects given as input (through the ESDInterface):
+/// This class has been developped to simplify the re-reconstruction of the MUON tracks
+/// stored into ESD with different recoParams and/or after having re-calibrated the digits.
+/// It creates new MUON object from ESD objects given as input (through the ESDInterface) then:
 ///
 /// - re-clusterize the ESD clusters using the attached ESD pads
 ///   (several new clusters can be reconstructed per ESD cluster)
@@ -61,6 +63,7 @@ ClassImp(AliMUONRefitter)
 //_____________________________________________________________________________
 AliMUONRefitter::AliMUONRefitter(const AliMUONRecoParam* recoParam)
 : TObject(),
+  fRecoParam(recoParam),
   fGeometryTransformer(0x0),
   fClusterServer(0x0),
   fTracker(0x0),

diff --git a/MUON/AliMUONRefitter.h b/MUON/AliMUONRefitter.h
index eca74280f5d74e2eaf002816b9478179381bd909..fd5229591136716895adce61cfa279cb10355399 100644 (file)
--- a/MUON/AliMUONRefitter.h
+++ b/MUON/AliMUONRefitter.h
@@ -66,12 +66,12 @@ private:
   
 private:
     
+  const AliMUONRecoParam*     fRecoParam;           ///< pointer to reco param (not owner)
   AliMUONGeometryTransformer* fGeometryTransformer; ///< geometry transformer (owner)
   AliMUONVClusterServer*      fClusterServer;       ///< clusterizer (owner)
   AliMUONVTrackReconstructor* fTracker;             ///< tracker (owner)
   AliMUONESDInterface*        fESDInterface;        ///< container of MUON tracks/clusters/digits (not owner)
   
-  const AliMUONRecoParam* fRecoParam; ///< pointer to reco param
   
   ClassDef(AliMUONRefitter,0)
 };

diff --git a/MUON/AliMUONTrack.cxx b/MUON/AliMUONTrack.cxx
index 7a6de3b8197efd21aa7e260ede63ec61e3bad0a8..10f0460415bf6e52819e31ecaf8648acaad8465d 100644 (file)
--- a/MUON/AliMUONTrack.cxx
+++ b/MUON/AliMUONTrack.cxx
@@ -24,7 +24,6 @@
 #include "AliMUONTrack.h"
 
 #include "AliMUONReconstructor.h"
-#include "AliMUONRecoParam.h"
 #include "AliMUONVCluster.h"
 #include "AliMUONVClusterStore.h"
 #include "AliMUONObjectPair.h"
@@ -457,25 +456,15 @@ Bool_t AliMUONTrack::IsValid(UInt_t requestedStationMask)
   Int_t nClusters = GetNClusters();
   AliMUONTrackParam *trackParam;
   Int_t currentStation(0);
+  UInt_t presentStationMask(0);
   
-  UInt_t m(0);
-  
-  for (Int_t i = 0; i < nClusters; i++) 
-  {
+  for (Int_t i = 0; i < nClusters; i++) {
     trackParam = (AliMUONTrackParam*) fTrackParamAtCluster->UncheckedAt(i);
-    
-    // skip unrequested stations
-//    while (expectedStation < AliMUONConstants::NTrackingSt() &&
-//        !AliMUONReconstructor::GetRecoParam()->RequestStation(expectedStation)) expectedStation++;
-//    
-
     currentStation = trackParam->GetClusterPtr()->GetChamberId()/2;
-    
-    m |= ( 1 << currentStation );
-    
+    presentStationMask |= ( 1 << currentStation );
   }
   
-  return ( (requestedStationMask & m) == requestedStationMask ) ;
+  return ( (requestedStationMask & presentStationMask) == requestedStationMask );
 }
 
   //__________________________________________________________________________

diff --git a/MUON/AliMUONTrackExtrap.cxx b/MUON/AliMUONTrackExtrap.cxx
index e7762acbff43e0f3e0e75dd3297a308ecaf9475b..19c34641ebca1ff4d2b2d66a9f82dcb4a36e327e 100644 (file)
--- a/MUON/AliMUONTrackExtrap.cxx
+++ b/MUON/AliMUONTrackExtrap.cxx
@@ -26,7 +26,6 @@
 #include "AliMUONTrackParam.h"
 #include "AliMUONConstants.h"
 #include "AliMUONReconstructor.h"
-#include "AliMUONRecoParam.h"
 
 #include "AliMagF.h" 
 

diff --git a/MUON/AliMUONTrackHitPattern.cxx b/MUON/AliMUONTrackHitPattern.cxx
index 6a2277007605ab82dc1b7ef3dca77018790670fb..57c59848b2e1b0ec96c43b1c4700e5a0c4fb70e0 100644 (file)
--- a/MUON/AliMUONTrackHitPattern.cxx
+++ b/MUON/AliMUONTrackHitPattern.cxx
@@ -58,7 +58,6 @@
 #include "AliMpVSegmentation.h"
 #include "AliMpDEManager.h"
 #include "AliMUONReconstructor.h"
-#include "AliMUONRecoParam.h"
 #include "AliMUONTriggerTrack.h"
 #include "AliMUONVTriggerTrackStore.h"
 

diff --git a/MUON/AliMUONTrackHitPattern.h b/MUON/AliMUONTrackHitPattern.h
index febe7982d8673aa9ae5d7271e49375bdd2da91dc..e946edc97c28220d2ccecdceb0f992c16e783600 100644 (file)
--- a/MUON/AliMUONTrackHitPattern.h
+++ b/MUON/AliMUONTrackHitPattern.h
@@ -98,6 +98,7 @@ private:
 
   void CheckConstants() const;
 
+  const AliMUONRecoParam* fRecoParam; //!< pointer to reco parameters
   const AliMUONGeometryTransformer& fTransformer; //!< geometry transformer
   const AliMUONDigitMaker& fDigitMaker; //!< pointer to digit maker
 
@@ -117,8 +118,6 @@ private:
     kSlatEff,
     kBoardEff
   };
-
-  const AliMUONRecoParam* fRecoParam; //!< pointer to reco parameters
   
   ClassDef(AliMUONTrackHitPattern, 0) // MUON track hit pattern
 };

diff --git a/MUON/AliMUONTrackReconstructor.cxx b/MUON/AliMUONTrackReconstructor.cxx
index 3e9ba9ba690e4a2fe30c5fbf251e825e89465247..d087b33c5ebf19e8cd70d83ab8bf0239214028c0 100644 (file)
--- a/MUON/AliMUONTrackReconstructor.cxx
+++ b/MUON/AliMUONTrackReconstructor.cxx
@@ -1421,7 +1421,7 @@ Bool_t AliMUONTrackReconstructor::RefitTrack(AliMUONTrack &track, Bool_t enableI
   /// re-fit the given track
   
   // check validity of the track
-  if (!track.IsValid(GetRecoParam()->RequestedStationMask())) {
+  if (track.GetNClusters() < 3) {
     AliWarning("the track does not contain enough clusters --> unable to refit");
     return kFALSE;
   }

diff --git a/MUON/AliMUONTrackReconstructorK.cxx b/MUON/AliMUONTrackReconstructorK.cxx
index 1e83ef4571e2d53006c0ed8ba172dee2df3e6e2f..d876a331c53c95659b9c7c2f64dbab42eaa55d50 100644 (file)
--- a/MUON/AliMUONTrackReconstructorK.cxx
+++ b/MUON/AliMUONTrackReconstructorK.cxx
@@ -1384,9 +1384,11 @@ void AliMUONTrackReconstructorK::ComplementTracks(const AliMUONVClusterStore& cl
        if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 1) || (AliLog::GetGlobalDebugLevel() >= 1)) {
          cout << "ComplementTracks: found one cluster in chamber(1..): " << chamberId+1 << endl;
          bestTrackParamAtCluster.GetClusterPtr()->Print();
-         cout<<endl<<"Track parameters and covariances at cluster:"<<endl;
-         bestTrackParamAtCluster.GetParameters().Print();
-         bestTrackParamAtCluster.GetCovariances().Print();
+         if ((AliLog::GetDebugLevel("MUON","AliMUONTrackReconstructorK") >= 2) || (AliLog::GetGlobalDebugLevel() >= 2)) {
+           cout<<endl<<"Track parameters and covariances at cluster:"<<endl;
+           bestTrackParamAtCluster.GetParameters().Print();
+           bestTrackParamAtCluster.GetCovariances().Print();
+         }
        }
        
        trackParam->SetRemovable(kTRUE);
@@ -1537,7 +1539,7 @@ Bool_t AliMUONTrackReconstructorK::RefitTrack(AliMUONTrack &track, Bool_t enable
   /// re-fit the given track
   
   // check validity of the track
-  if (!track.IsValid(GetRecoParam()->RequestedStationMask())) {
+  if (track.GetNClusters() < 3) {
     AliWarning("the track does not contain enough clusters --> unable to refit");
     return kFALSE;
   }

diff --git a/MUON/AliMUONTracker.cxx b/MUON/AliMUONTracker.cxx
index 0ec3dc39017c698599006ab7572e29b65e57fbe1..7a6fab25573bfdd055ffda19a8f8332e8c3d22dc 100644 (file)
--- a/MUON/AliMUONTracker.cxx
+++ b/MUON/AliMUONTracker.cxx
@@ -22,11 +22,9 @@
 /// reconstruct tracks from recpoints
 ///
 /// Actual tracking is performed by some AliMUONVTrackReconstructor children
-/// Tracking modes (ORIGINAL, KALMAN) and associated options and parameters
-/// can be changed by using:
-/// AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLow(High)FluxParam();
-/// muonRecoParam->Set...(); // see methods in AliMUONRecoParam.h for details
-/// AliMUONReconstructor::SetRecoParam(muonRecoParam);
+/// Tracking modes (ORIGINAL, KALMAN) and associated options and parameters can be changed
+/// through the AliMUONRecoParam object set in the reconstruction macro or read from the CDB
+/// (see methods in AliMUONRecoParam.h file for details)
 ///
 /// \author Christian Finck and Laurent Aphecetche, SUBATECH Nantes
 //-----------------------------------------------------------------------------

diff --git a/MUON/AliMUONVTrackReconstructor.cxx b/MUON/AliMUONVTrackReconstructor.cxx
index 79f491d44dd99ea200d52ff330e9c0cbd1cb2506..074c42da54911e6130c905880cac07209c6f44f0 100644 (file)
--- a/MUON/AliMUONVTrackReconstructor.cxx
+++ b/MUON/AliMUONVTrackReconstructor.cxx
@@ -27,10 +27,9 @@
 /// * ValidateTracksWithTrigger to match tracker/trigger tracks
 ///
 /// Several options and adjustable parameters are available for both KALMAN and ORIGINAL
-/// tracking algorithms. They can be changed by using:
-/// AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLow(High)FluxParam();
-/// muonRecoParam->Set...(); // see methods in AliMUONRecoParam.h for details
-/// AliMUONReconstructor::SetRecoParam(muonRecoParam);
+/// tracking algorithms. They can be changed through the AliMUONRecoParam object
+/// set in the reconstruction macro or read from the CDB
+/// (see methods in AliMUONRecoParam.h file for details)
 ///
 /// Main parameters and options are:
 /// - *fgkSigmaToCutForTracking* : quality cut used to select new clusters to be

diff --git a/MUON/AliMUONVTrackReconstructor.h b/MUON/AliMUONVTrackReconstructor.h
index c814be8d62c3b4e7846cfde5f7a4c61617159619..961a90af3c9a949a55ad7c08dba56b21a2cbe9cc 100644 (file)
--- a/MUON/AliMUONVTrackReconstructor.h
+++ b/MUON/AliMUONVTrackReconstructor.h
@@ -12,7 +12,6 @@
 //  Author: Philippe Pillot
 
 #include "AliMUONReconstructor.h"
-#include "AliMUONRecoParam.h"
 
 #include <TObject.h>
 
@@ -57,29 +56,6 @@ class AliMUONVTrackReconstructor : public TObject {
   virtual Bool_t RefitTrack(AliMUONTrack &track, Bool_t enableImprovement = kTRUE) = 0;
   
   
-  // methods previously got from the static muonrecoparam:
-  //
-  // MakeMoreTrackCandidates()
-  //    
-  // ComplementTracks()
-  //    
-  // ImproveTracks()
-  //
-  // GetMaxNonBendingSlope()
-  // GetMaxBendingSlope()
-  //
-  // GetMinBendingMomentum()
-  // GetMaxBendingMomentum()
-  //
-  // UseChamber(Int_t chamberId)
-  //
-  // GetMaxNonBendingDistanceToTrack()
-  // GetSigmaCutForTracking()
-  // GetMaxBendingDistanceToTrack()
-  // GetSigmaCutForTracking()
-  // TrackAllTracks()
-  // RequestStation(Int_t stationId)
-  
  protected:
 
   TClonesArray *fRecTracksPtr; ///< pointer to array of reconstructed tracks

diff --git a/MUON/MUONAlignment.C b/MUON/MUONAlignment.C
index 77876c70e32d6fead6d1c072346522f314d71fa0..a418eaf1de4f4334702b8414066cae5d1c096360 100644 (file)
--- a/MUON/MUONAlignment.C
+++ b/MUON/MUONAlignment.C
@@ -44,7 +44,6 @@
 #include "AliMUONTrackParam.h"
 #include "AliMUONGeometryTransformer.h"
 #include "AliMUONESDInterface.h"
-#include "AliMUONRecoParam.h"
 
 #include "AliESDEvent.h"
 #include "AliESDMuonTrack.h"
@@ -208,7 +207,7 @@ void MUONAlignment(Int_t nEvents = 100000, char* geoFilename = "geometry.root",
        fBenMom->Fill(1./invBenMom);
        if (TMath::Abs(invBenMom)<=1.04) {
          AliMUONTrack track;
-         AliMUONESDInterface::ESDToMUON(AliMUONRecoParam::GetLowFluxParam(),*esdTrack, track);
+         AliMUONESDInterface::ESDToMUON(*esdTrack, track);
          alig->ProcessTrack(&track);
          alig->LocalFit(iTrackOk++,trackParams,0);
        }

diff --git a/MUON/MUONClusterInfo.C b/MUON/MUONClusterInfo.C
index e340712ad433a082b2d04d1fc11cc899352fb587..02f8e796407d66f837f2414c5cc4bd7c518693c8 100644 (file)
--- a/MUON/MUONClusterInfo.C
+++ b/MUON/MUONClusterInfo.C
@@ -68,6 +68,8 @@ TTree* GetESDTree(TFile *esdFile);
 void MUONClusterInfo(Int_t nevents = -1, const char* esdFileName = "AliESDs.root", const char* outFileName = "clusterInfo.root")
 {
   /// load ESD event in the ESDInterface to recover MUON objects;
+  /// track parameters at each cluster are recomputed by the interface using Kalman filter + Smoother
+  /// (It can be changed by resetting the tracker in the interface with a new recoParam object);
   /// fill AliMUONESDClusterInfo object with ESD cluster + corresponding track parameters;
   /// write results in a new root file.
   
@@ -248,11 +250,11 @@ void Prepare()
     exit(-1);
   }
   
-  // eventually set reconstruction parameters for refit (otherwise read from OCDB)
-/*  AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
-  muonRecoParam->Print("FULL");
-  AliRecoParam::Instance()->RegisterRecoParam(muonRecoParam);
-*/  
+  // Reset the reconstruction parameters for track refitting if needed
+  // (by default will use Kalman filter + Smoother)
+//  AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
+//  AliMUONESDInterface::ResetTracker(muonRecoParam);
+  
 }
 
 //-----------------------------------------------------------------------

diff --git a/MUON/MUONRefit.C b/MUON/MUONRefit.C
index e7bed8ae6d561fa18a9bd0cc5eea1057850d9072..3278c52f3324e284deccd758c6afea5d49fa0e86 100644 (file)
--- a/MUON/MUONRefit.C
+++ b/MUON/MUONRefit.C
@@ -70,16 +70,22 @@ void MUONRefit(Int_t nevents = -1, const char* esdFileNameIn = "AliESDs.root", c
   // prepare the refitting
   gRandom->SetSeed(1);
   Prepare();
+  
+  // set reconstruction parameters used for refitting
+  AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
+  muonRecoParam->Print("FULL");
+  
   AliMUONESDInterface esdInterface;
-  AliMUONRefitter refitter;
+  AliMUONRefitter refitter(muonRecoParam);
   refitter.Connect(&esdInterface);
   
   // open the ESD file and tree
   TFile* esdFile = TFile::Open(esdFileNameIn);
   TTree* esdTree = GetESDTree(esdFile);
   
-  // create the ESD output tree
-  gROOT->cd();
+  // create the ESD output file and tree
+  TFile* newESDFile = TFile::Open(esdFileNameOut, "RECREATE");
+  newESDFile->SetCompressionLevel(2);
   TTree* newESDTree = esdTree->CloneTree(0);
   
   // connect ESD event to the ESD tree
@@ -179,14 +185,13 @@ void MUONRefit(Int_t nevents = -1, const char* esdFileNameIn = "AliESDs.root", c
   timer.Stop();
   
   // write output ESD tree
-  TFile* newESDFile = TFile::Open(esdFileNameOut, "RECREATE");
-  newESDFile->SetCompressionLevel(2);
+  newESDFile->cd();
   newESDTree->Write();
+  delete newESDTree;
   newESDFile->Close();
   
   // free memory
   esdFile->Close();
-  delete newESDTree;
   delete esd;
   
   cout<<endl<<"time to refit: R:"<<timer.RealTime()<<" C:"<<timer.CpuTime()<<endl<<endl;
@@ -221,12 +226,6 @@ void Prepare()
     exit(-1);
   }
   
-  // set reconstruction parameters
-  AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
-  muonRecoParam->CombineClusterTrackReco(kFALSE);
-  muonRecoParam->Print("FULL");
-  AliRecoParam::Instance()->RegisterRecoParam(muonRecoParam);
-  
 }
 
 //-----------------------------------------------------------------------