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

#ifndef ALIMUONRECOCHECK_H
#define ALIMUONRECOCHECK_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

/// \ingroup evaluation
/// \class AliMUONRecoCheck
/// \brief Utility class to check reconstruction

#include <TObject.h>

class TClonesArray;
class TFile;
class TTree;
class AliESDEvent;
class AliMCEventHandler;
class AliMUONVTrackStore;
class AliMUONVTriggerTrackStore;
class AliMUONTrack;
class AliMUONTrackParam;
class AliMUONTriggerTrack;
class AliMUONGeometryTransformer;
class AliMUONTriggerCircuit;
class AliMUONLocalTrigger;
class AliMUONCalibrationData;
class AliMUONTriggerElectronics;

class AliMUONRecoCheck : public TObject 
{
public:
  AliMUONRecoCheck(const Char_t *chLoader, const Char_t *pathSim = "./");
  AliMUONRecoCheck(AliESDEvent *esdEvent, AliMCEventHandler *mcEventHandler);
  virtual ~AliMUONRecoCheck();

  /// Return the list of reconstructed tracks
  AliMUONVTrackStore* ReconstructedTracks(Int_t event, Bool_t refit = kTRUE);

  /// Return the list of reconstructed trigger tracks
  AliMUONVTriggerTrackStore* TriggeredTracks(Int_t event);

  Bool_t TriggerToTrack(const AliMUONLocalTrigger& locTrg, AliMUONTriggerTrack& triggerTrack);
	
  /// Return reference muon tracks
  AliMUONVTrackStore* TrackRefs(Int_t event);

  /// Return triggerable reference tracks
  AliMUONVTriggerTrackStore* TriggerableTracks(Int_t event);
	
  /// Return reconstructible reference tracks
  AliMUONVTrackStore* ReconstructibleTracks(Int_t event, UInt_t requestedStationMask = 0x1F,
					    Bool_t request2ChInSameSt45 = kTRUE,
					    Bool_t hitInFrontOfPad = kFALSE);

	
  /// 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() const { return fESDEvent; }
  
  /// Return the interface to the Monte Carlo data of current event
  const AliMCEventHandler* GetMCEventHandler() const { 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.);
  
  /// Return the trigger track from the store matched with the given track (or 0x0)
  static AliMUONTriggerTrack* FindCompatibleTrack(AliMUONTriggerTrack &track,
                                                  const AliMUONVTriggerTrackStore &triggerTrackStore,
                                                  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 MakeTriggeredTracks();
  
  void MakeTrackRefs();
  
  void CleanMuonTrackRef(const AliMUONVTrackStore *tmpTrackRefStore);
  
  void MakeReconstructibleTracks(UInt_t requestedStationMask, Bool_t request2ChInSameSt45 = kTRUE,
				 Bool_t hitInFrontOfPad = kFALSE);
	
  void MakeTriggerableTracks();
	
  Bool_t InitCircuit();
  Bool_t InitTriggerResponse();
  Bool_t InitCalibrationData();
  Bool_t InitGeometryTransformer();

  Bool_t IsHitInFrontOfPad(AliMUONTrackParam *param) const;
  
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
  
  Int_t fCurrentEvent; ///< current event number
  
  AliMUONVTrackStore* fTrackRefStore;     ///< current simulated tracks (owner)
  AliMUONVTrackStore* fRecoTrackRefStore; ///< current reconstructible tracks (owner)
  AliMUONVTriggerTrackStore* fRecoTriggerRefStore; ///< current triggerable tracks (owner)
  AliMUONVTrackStore* fRecoTrackStore;    ///< current reconstructed tracks (owner)
  AliMUONVTriggerTrackStore* fRecoTriggerTrackStore;    ///< current reconstructed trigger tracks (owner)
	
  AliMUONGeometryTransformer* fGeometryTransformer; ///< geometry transformer
  AliMUONTriggerCircuit* fTriggerCircuit; ///< trigger circuit
  AliMUONCalibrationData* fCalibrationData; //!< Used to load Local, Regional and Global masks
  AliMUONTriggerElectronics* fTriggerElectronics; ///< object to re-compute the trigger info
  
  Bool_t fESDEventOwner;         ///< using constructor from the analysis task

  ClassDef(AliMUONRecoCheck, 0)   //Utility class to check reconstruction
};

#endif
Commit	Line	Data
	1	#ifndef ALIMUONRECOCHECK_H
	2	#define ALIMUONRECOCHECK_H
	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	/* $Id$ */
	8
	9	/// \ingroup evaluation
	10	/// \class AliMUONRecoCheck
	11	/// \brief Utility class to check reconstruction
	12
	13	#include <TObject.h>
	14
	15	class TClonesArray;
	16	class TFile;
	17	class TTree;
	18	class AliESDEvent;
	19	class AliMCEventHandler;
	20	class AliMUONVTrackStore;
	21	class AliMUONVTriggerTrackStore;
	22	class AliMUONTrack;
	23	class AliMUONTrackParam;
	24	class AliMUONTriggerTrack;
	25	class AliMUONGeometryTransformer;
	26	class AliMUONTriggerCircuit;
	27	class AliMUONLocalTrigger;
	28	class AliMUONCalibrationData;
	29	class AliMUONTriggerElectronics;
	30
	31	class AliMUONRecoCheck : public TObject
	32	{
	33	public:
	34	AliMUONRecoCheck(const Char_t chLoader, const Char_t pathSim = "./");
	35	AliMUONRecoCheck(AliESDEvent esdEvent, AliMCEventHandler mcEventHandler);
	36	virtual ~AliMUONRecoCheck();
	37
	38	/// Return the list of reconstructed tracks
	39	AliMUONVTrackStore* ReconstructedTracks(Int_t event, Bool_t refit = kTRUE);
	40
	41	/// Return the list of reconstructed trigger tracks
	42	AliMUONVTriggerTrackStore* TriggeredTracks(Int_t event);
	43
	44	Bool_t TriggerToTrack(const AliMUONLocalTrigger& locTrg, AliMUONTriggerTrack& triggerTrack);
	45
	46	/// Return reference muon tracks
	47	AliMUONVTrackStore* TrackRefs(Int_t event);
	48
	49	/// Return triggerable reference tracks
	50	AliMUONVTriggerTrackStore* TriggerableTracks(Int_t event);
	51
	52	/// Return reconstructible reference tracks
	53	AliMUONVTrackStore* ReconstructibleTracks(Int_t event, UInt_t requestedStationMask = 0x1F,
	54	Bool_t request2ChInSameSt45 = kTRUE,
	55	Bool_t hitInFrontOfPad = kFALSE);
	56
	57
	58	/// Return the run number of the current ESD event
	59	Int_t GetRunNumber();
	60
	61	/// Return the total number of events.
	62	Int_t NumberOfEvents() const;
	63
	64	/// Return the reconstructed data of current event
	65	const AliESDEvent* GetESDEvent() const { return fESDEvent; }
	66
	67	/// Return the interface to the Monte Carlo data of current event
	68	const AliMCEventHandler* GetMCEventHandler() const { return fMCEventHandler; }
	69
	70	/// Return the track from the store matched with the given track (or 0x0) and the fraction of matched clusters
	71	static AliMUONTrack* FindCompatibleTrack(AliMUONTrack &track, AliMUONVTrackStore &trackStore,
	72	Int_t &nMatchClusters, Bool_t useLabel = kFALSE,
	73	Double_t sigmaCut = 10.);
	74
	75	/// Return the trigger track from the store matched with the given track (or 0x0)
	76	static AliMUONTriggerTrack* FindCompatibleTrack(AliMUONTriggerTrack &track,
	77	const AliMUONVTriggerTrackStore &triggerTrackStore,
	78	Double_t sigmaCut = 10.);
	79
	80	private:
	81	/// Not implemented
	82	AliMUONRecoCheck(const AliMUONRecoCheck& rhs);
	83	/// Not implemented
	84	AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
	85
	86	void ResetStores();
	87
	88	void MakeReconstructedTracks(Bool_t refit);
	89
	90	void MakeTriggeredTracks();
	91
	92	void MakeTrackRefs();
	93
	94	void CleanMuonTrackRef(const AliMUONVTrackStore *tmpTrackRefStore);
	95
	96	void MakeReconstructibleTracks(UInt_t requestedStationMask, Bool_t request2ChInSameSt45 = kTRUE,
	97	Bool_t hitInFrontOfPad = kFALSE);
	98
	99	void MakeTriggerableTracks();
	100
	101	Bool_t InitCircuit();
	102	Bool_t InitTriggerResponse();
	103	Bool_t InitCalibrationData();
	104	Bool_t InitGeometryTransformer();
	105
	106	Bool_t IsHitInFrontOfPad(AliMUONTrackParam *param) const;
	107
	108	private:
	109	AliMCEventHandler* fMCEventHandler; ///< to access MC truth information
	110	AliESDEvent* fESDEvent; ///< ESD event to access MUON data
	111	TTree* fESDTree; ///< ESD tree to access MUON data
	112	TFile* fESDFile; ///< ESD file to access MUON data
	113
	114	Int_t fCurrentEvent; ///< current event number
	115
	116	AliMUONVTrackStore* fTrackRefStore; ///< current simulated tracks (owner)
	117	AliMUONVTrackStore* fRecoTrackRefStore; ///< current reconstructible tracks (owner)
	118	AliMUONVTriggerTrackStore* fRecoTriggerRefStore; ///< current triggerable tracks (owner)
	119	AliMUONVTrackStore* fRecoTrackStore; ///< current reconstructed tracks (owner)
	120	AliMUONVTriggerTrackStore* fRecoTriggerTrackStore; ///< current reconstructed trigger tracks (owner)
	121
	122	AliMUONGeometryTransformer* fGeometryTransformer; ///< geometry transformer
	123	AliMUONTriggerCircuit* fTriggerCircuit; ///< trigger circuit
	124	AliMUONCalibrationData* fCalibrationData; //!< Used to load Local, Regional and Global masks
	125	AliMUONTriggerElectronics* fTriggerElectronics; ///< object to re-compute the trigger info
	126
	127	Bool_t fESDEventOwner; ///< using constructor from the analysis task
	128
	129	ClassDef(AliMUONRecoCheck, 0) //Utility class to check reconstruction
	130	};
	131
	132	#endif
	133