updated vertex selection

[u/mrichter/AliRoot.git] / MUON / AliMUONRecoCheck.h

diff --git a/MUON/AliMUONRecoCheck.h b/MUON/AliMUONRecoCheck.h
index 38be7743c61226129e2eff7a2a97fc8880cfaef8..1d0aa412fde66a60091dc9b6039b4ea7d7ac17ba 100644 (file)
--- a/MUON/AliMUONRecoCheck.h
+++ b/MUON/AliMUONRecoCheck.h
@@ -6,67 +6,84 @@
 
 /* $Id$ */
 
-/// \ingroup base
+/// \ingroup evaluation
 /// \class AliMUONRecoCheck
 /// \brief Utility class to check reconstruction
 
 #include <TObject.h>
-#include "AliMUONTrack.h"
 
 class TClonesArray;
-class AliMUONData;
-class AliRunLoader;
-
+class TFile;
+class TTree;
+class AliESDEvent;
+class AliMCEventHandler;
+class AliMUONVTrackStore;
+class AliMUONTrack;
 
 class AliMUONRecoCheck : public TObject 
 {
 public:
-  AliMUONRecoCheck(Char_t *chLoader);
-  virtual          ~AliMUONRecoCheck();
-
-                /// Return MUON data 
-  AliMUONData*  GetMUONData() {return fMUONData;}
-  void MakeTrackRef();
-                /// Add track reference
-  void AddMuonTrackReference(const AliMUONTrack *muonTrack) 
-    {new ((*fMuonTrackRef)[fMuonTrackRef->GetEntriesFast()]) AliMUONTrack(*muonTrack);}
+  AliMUONRecoCheck(const Char_t *chLoader, const Char_t *pathSim = "./");
+  AliMUONRecoCheck(AliESDEvent *esdEvent, AliMCEventHandler *mcEventHandler);
+  virtual ~AliMUONRecoCheck();
 
-  void PrintEvent() const;
-  void ResetTracks() const;
-                /// Return run loader
-  AliRunLoader* GetRunLoader() {return fRunLoader;}
-  void CleanMuonTrackRef();
-  void ReconstructibleTracks();
-                /// Return number of reconstructible tracks
-  Int_t GetNumberOfReconstuctibleTracks() {return fReconstructibleTracks;}
-                /// Return number of reconstructed tracks
-  Int_t GetNumberOfRecoTracks() {return fRecoTracks;}
-  TClonesArray *GetTrackReco();
-                /// Return reference muon tracks
-  TClonesArray *GetMuonTrackRef() {return fMuonTrackRef;}
+  /// Return the list of reconstructed tracks
+  AliMUONVTrackStore* ReconstructedTracks(Int_t event, Bool_t refit = kTRUE);
+  
+  /// Return reference muon tracks
+  AliMUONVTrackStore* TrackRefs(Int_t event);
 
-protected:
+  /// Return reconstructible reference tracks
+  AliMUONVTrackStore* ReconstructibleTracks(Int_t event, UInt_t requestedStationMask = 0x1F, Bool_t request2ChInSameSt45 = kTRUE);
+  
+  /// Return the run number of the current ESD event
+  Int_t GetRunNumber();
+  
+  /// Return the total number of events.
+  Int_t NumberOfEvents() const;
+  
+  /// Return the reconstructed data of current event
+  const AliESDEvent* GetESDEvent() { return fESDEvent; }
+  
+  /// Return the interface to the Monte Carlo data of current event
+  const AliMCEventHandler* GetMCEventHandler() { return fMCEventHandler; }
+  
+  /// Return the track from the store matched with the given track (or 0x0) and the fraction of matched clusters.
+  static AliMUONTrack* FindCompatibleTrack(AliMUONTrack &track, AliMUONVTrackStore &trackStore,
+                                          Int_t &nMatchClusters, Bool_t useLabel = kFALSE, Double_t sigmaCut = 10.);
+  
+private:
+  /// Not implemented
   AliMUONRecoCheck(const AliMUONRecoCheck& rhs);
+  /// Not implemented
   AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
 
+  void ResetStores();
+  
+  void MakeReconstructedTracks(Bool_t refit);
+  
+  void MakeTrackRefs();
+  
+  void CleanMuonTrackRef(const AliMUONVTrackStore *tmpTrackRefStore);
+  
+  void MakeReconstructibleTracks(UInt_t requestedStationMask, Bool_t request2ChInSameSt45 = kTRUE);
+
 private:
+  AliMCEventHandler* fMCEventHandler; ///< to access MC truth information
+  AliESDEvent* fESDEvent; ///< ESD event to access MUON data
+  TTree* fESDTree;        ///< ESD tree to access MUON data
+  TFile* fESDFile;        ///< ESD file to access MUON data
   
-  AliRunLoader* fRunLoader;     ///< alice run loader 
-  AliMUONData*  fMUONData;      ///< Data container for MUON subsystem 
-  TClonesArray* fMuonTrackRef;  ///< reference muon tracks
-  TClonesArray* fTrackReco;     ///< reconstructed muon tracks
-  Int_t fReconstructibleTracks; ///< number of reconstructible tracks 
-  Int_t fRecoTracks;            ///< number of reconstructed tracks 
+  Int_t fCurrentEvent; ///< current event number
+  
+  AliMUONVTrackStore* fTrackRefStore;     ///< current simulated tracks (owner)
+  AliMUONVTrackStore* fRecoTrackRefStore; ///< current reconstructible tracks (owner)
+  AliMUONVTrackStore* fRecoTrackStore;    ///< current reconstructed tracks (owner)
+  
+  Bool_t fESDEventOwner;         ///< using constructor from the analysis task
 
-  ClassDef(AliMUONRecoCheck, 0) //Utility class to check reconstruction
+  ClassDef(AliMUONRecoCheck, 0)   //Utility class to check reconstruction
 };
 
 #endif
 
-
-
-
-
-
-
-