MUON/AliMUONTrackReconstructor.h

   1 #ifndef ALIMUONTRACKRECONSTRUCTOR_H
   2 #define ALIMUONTRACKRECONSTRUCTOR_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 /* $Id$ */
   7
   8 /// \ingroup rec
   9 /// \class AliMUONTrackReconstructor
  10 /// \brief Class for the MUON track reconstruction
  11 ///
  12 /////////////////////////////////////
  13 /// MUON track reconstructor in ALICE
  14 /////////////////////////////////////
  15
  16 #include <TObject.h>
  17 #include "AliMUONConstants.h"
  18
  19 class AliMUONHitForRec;
  20 class AliMUONSegment;
  21 class TClonesArray;
  22 class TFile;
  23 class TTree;
  24 class AliMUONData;
  25 class AliRunLoader;
  26 class AliMUONTriggerTrack;
  27 class AliMUONTrack;
  28 class TVirtualFitter;
  29
  30 class AliMUONTrackReconstructor : public TObject {
  31
  32  public:
  33   AliMUONTrackReconstructor(AliMUONData* data); // default Constructor
  34   virtual ~AliMUONTrackReconstructor(); // Destructor
  35
  36   // Parameters for track reconstruction: public methods
  37   // Get and Set, Set to defaults
  38
  39            /// Return minimum value (GeV/c) of momentum in bending plane
  40   Double_t GetMinBendingMomentum(void) const {return fMinBendingMomentum;}
  41            /// Set minimum value (GeV/c) of momentum in bending plane
  42   void SetMinBendingMomentum(Double_t MinBendingMomentum) {fMinBendingMomentum = MinBendingMomentum;}
  43
  44            /// Return maximum value (GeV/c) of momentum in bending plane
  45   Double_t GetMaxBendingMomentum(void) const {return fMaxBendingMomentum;}
  46            /// Set maximum value (GeV/c) of momentum in bending plane
  47   void SetMaxBendingMomentum(Double_t MaxBendingMomentum) {fMaxBendingMomentum = MaxBendingMomentum;}
  48
  49            /// Return maximum Chi2 per degree of Freedom
  50   Double_t GetMaxChi2(void) const {return fMaxChi2;}
  51            /// Set maximum Chi2 per degree of Freedom
  52   void SetMaxChi2(Double_t MaxChi2) {fMaxChi2 = MaxChi2;}
  53
  54            /// Return maximum square distance in units of the variance (maximum chi2)
  55   Double_t GetMaxSigma2Distance(void) const {return fMaxSigma2Distance;}
  56            /// Set maximum square distance in units of the variance (maximum chi2)
  57   void SetMaxSigma2Distance(Double_t MaxSigma2Distance) {fMaxSigma2Distance = MaxSigma2Distance;}
  58
  59            /// Return chamber resolution (cm) in bending plane
  60   Double_t GetBendingResolution(void) const {return fBendingResolution;}
  61            /// Set chamber resolution (cm) in bending plane
  62   void SetBendingResolution(Double_t BendingResolution) {fBendingResolution = BendingResolution;}
  63
  64            /// Return chamber resolution (cm) in non-bending plane
  65   Double_t GetNonBendingResolution(void) const {return fNonBendingResolution;}
  66            /// set chamber resolution (cm) in non-bending plane
  67   void SetNonBendingResolution(Double_t NonBendingResolution) {fNonBendingResolution = NonBendingResolution;}
  68
  69            /// Return chamber thickness in number of radiation lengths
  70   Double_t GetChamberThicknessInX0(void) const {return fChamberThicknessInX0;}
  71            /// Set chamber thickness in number of radiation lengths
  72   void SetChamberThicknessInX0(Double_t ChamberThicknessInX0) {fChamberThicknessInX0 = ChamberThicknessInX0;}
  73
  74            /// Return simple magnetic field: value (kG)
  75   Double_t GetSimpleBValue(void) const {return fSimpleBValue;}
  76            /// Set simple magnetic field: value (kG)
  77   void SetSimpleBValue(Double_t SimpleBValue) {fSimpleBValue = SimpleBValue;}
  78
  79            /// Return simple magnetic field: length (cm)
  80   Double_t GetSimpleBLength(void) const {return fSimpleBLength;}
  81            /// Set simple magnetic field: length (cm)
  82   void SetSimpleBLength(Double_t SimpleBLength) {fSimpleBLength = SimpleBLength;}
  83
  84            /// Return simple magnetic field: Z central position (cm)
  85   Double_t GetSimpleBPosition(void) const {return fSimpleBPosition;}
  86            /// Set simple magnetic field: Z central position (cm)
  87   void SetSimpleBPosition(Double_t SimpleBPosition) {fSimpleBPosition = SimpleBPosition;}
  88
  89            /// Return chamber efficiency (used for track ref. hits only
  90   Double_t GetEfficiency(void) const {return fEfficiency;}
  91            /// Set chamber efficiency (used for track ref. hits only
  92   void SetEfficiency(Double_t Efficiency) {fEfficiency = Efficiency;}
  93
  94   void SetReconstructionParametersToDefaults(void);
  95
  96            /// Return track fitter
  97   static TVirtualFitter* Fitter(void) {return fgFitter;}
  98
  99            /// Return number of hits for reconstruction
 100   Int_t GetNHitsForRec(void) const {return fNHitsForRec;} // Number
 101
 102            /// Return number of reconstructed tracks
 103   Int_t GetNRecTracks() const {return fNRecTracks;} // Number
 104            /// Set number of reconstructed tracks
 105   void SetNRecTracks(Int_t NRecTracks) {fNRecTracks = NRecTracks;}
 106
 107            /// Return array of reconstructed tracks
 108   TClonesArray* GetRecTracksPtr(void) const {return fRecTracksPtr;} // Array
 109
 110   // Functions
 111   Double_t GetImpactParamFromBendingMomentum(Double_t BendingMomentum) const;
 112   Double_t GetBendingMomentumFromImpactParam(Double_t ImpactParam) const;
 113   void EventReconstruct(void);
 114   void EventReconstructTrigger(void);
 115   void EventDump(void);  // dump reconstructed event
 116   void EventDumpTrigger(void);  // dump reconstructed trigger event
 117   //PH  void FillEvent();      // fill and write tree of reconstructed events
 118   void SetTrackMethod(Int_t iTrackMethod); //AZ
 119           /// Return track method
 120   Int_t GetTrackMethod(void) const {return fTrackMethod;}
 121   void FillMUONTrack(void); // set track parameters at hits for Kalman track
 122   //Int_t fMuons; // AZ - number of muons within acceptance - just for tests
 123
 124           /// Return MUON data
 125   AliMUONData*  GetMUONData() {return fMUONData;}
 126
 127           /// Set trigger circuit
 128   void SetTriggerCircuit(TClonesArray* circuit) {fTriggerCircuit = circuit;}
 129
 130
 131  private:
 132
 133   // Defaults parameters for reconstruction
 134   static const Double_t fgkDefaultMinBendingMomentum; ///< default min. bending momentum for reconstruction
 135   static const Double_t fgkDefaultMaxBendingMomentum; ///< default max. bending momentum for reconstruction
 136   static const Double_t fgkDefaultMaxChi2; ///< default max. track chi2 for reconstruction
 137   static const Double_t fgkDefaultMaxSigma2Distance; ///< default square of max. distance for window size
 138   static const Double_t fgkDefaultBendingResolution; ///< default bending coordinate resolution for reconstruction
 139   static const Double_t fgkDefaultNonBendingResolution; ///< default non bending coordinate resolution for reconstruction
 140   // Simple magnetic field:
 141   // Value taken from macro MUONtracking.C: 0.7 T, hence 7 kG
 142   // Length and Position from reco_muon.F, with opposite sign:
 143   // Length = ZMAGEND-ZCOIL
 144   // Position = (ZMAGEND+ZCOIL)/2
 145   // to be ajusted differently from real magnetic field ????
 146   static const Double_t fgkDefaultSimpleBValue; ///< default value of magnetic field (dipole)
 147   static const Double_t fgkDefaultSimpleBLength; ///< default length of magnetic field (dipole)
 148   static const Double_t fgkDefaultSimpleBPosition; ///< default position of magnetic field (dipole)
 149   static const Double_t fgkDefaultEfficiency; ///< default chamber efficiency for track ref. hits recontruction
 150
 151   static TVirtualFitter* fgFitter; //!< Pointer to track fitter
 152
 153   Int_t fTrackMethod; ///< AZ - tracking method
 154
 155   // Parameters for track reconstruction
 156   Double_t fMinBendingMomentum; ///< minimum value (GeV/c) of momentum in bending plane
 157   // Parameters for track reconstruction
 158   Double_t fMaxBendingMomentum; ///< maximum value (GeV/c) of momentum in bending plane
 159   Double_t fMaxChi2; ///< maximum Chi2 per degree of Freedom
 160   Double_t fMaxSigma2Distance; ///< maximum square distance in units of the variance (maximum chi2)
 161   Double_t* fRMin; ///< minimum radius (cm)
 162   Double_t* fRMax; ///< maximum radius (cm)
 163   Double_t* fSegmentMaxDistBending; ///< maximum distance (cm) for segments in bending plane
 164   Double_t* fSegmentMaxDistNonBending; ///< maximum distance (cm) for segments in non bending plane
 165   Double_t fBendingResolution; ///< chamber resolution (cm) in bending plane
 166   Double_t fNonBendingResolution; ///< chamber resolution (cm) in non bending plane
 167   Double_t fChamberThicknessInX0; ///< chamber thickness in number of radiation lengths
 168                                   // how to take it from simulation ????
 169   Double_t fSimpleBValue; ///< simple magnetic field: value (kG)
 170   Double_t fSimpleBLength; ///< simple magnetic field: length (cm)
 171   Double_t fSimpleBPosition; ///< simple magnetic field: Z central position (cm)
 172   Double_t fEfficiency; ///< chamber efficiency (used for track ref. hits only)
 173
 174   // Hits for reconstruction (should be in AliMUON ????)
 175   TClonesArray* fHitsForRecPtr; ///< pointer to the array of hits for reconstruction
 176   Int_t fNHitsForRec; ///< number of hits for reconstruction
 177   // Information per chamber (should be in AliMUONChamber ????)
 178   Int_t* fNHitsForRecPerChamber; ///< number of HitsForRec
 179   Int_t* fIndexOfFirstHitForRecPerChamber; ///< index (0...) of first HitForRec
 180
 181   // Segments inside a station
 182   TClonesArray** fSegmentsPtr; ///< array of pointers to the segments for each station
 183   Int_t* fNSegments; ///< number of segments for each station
 184
 185   // Reconstructed tracks
 186   TClonesArray *fRecTracksPtr; ///< pointer to array of reconstructed tracks
 187   Int_t fNRecTracks; ///< number of reconstructed tracks
 188
 189   // data container
 190   AliMUONData* fMUONData; ///< Data container for MUON subsystem
 191
 192   Int_t fMuons; ///< AZ - number of muons within acceptance - just for tests
 193
 194   AliMUONTriggerTrack* fTriggerTrack; ///< Trigger track structure
 195
 196   TClonesArray* fTriggerCircuit;      //!< trigger circuit array
 197
 198   // Functions
 199   AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); // copy constructor
 200   AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs); // assignment operator
 201   void ResetHitsForRec(void);
 202   void MakeEventToBeReconstructed(void);
 203   void AddHitsForRecFromRawClusters(TTree* TR);
 204   void SortHitsForRecWithIncreasingChamber();
 205   void MakeSegments(void);
 206   void ResetSegments(void);
 207   void MakeSegmentsPerStation(Int_t Station);
 208   void MakeTracks(void);
 209   Bool_t MakeTriggerTracks(void);
 210   void ResetTracks(void);
 211   void MakeTrackCandidates(void);
 212   Int_t MakeTrackCandidatesWithTwoSegments(AliMUONSegment *BegSegment);
 213   Int_t MakeTrackCandidatesWithOneSegmentAndOnePoint(AliMUONSegment *BegSegment);
 214   void CalcTrackParamAtVertex(AliMUONTrack *Track);
 215   void FollowTracks(void);
 216   void Fit(AliMUONTrack *Track, Int_t FitStart, Int_t FitMCS);
 217   void RemoveDoubleTracks(void);
 218   void UpdateHitForRecAtHit(void);
 219   void ValidateTracksWithTrigger(void);
 220
 221
 222   //AZ - for Kalman Filter
 223   void MakeTrackCandidatesK(void);
 224   void FollowTracksK(void);
 225   void RemoveDoubleTracksK(void);
 226   void GoToVertex(void);
 227   Bool_t CheckCandidateK(Int_t icand, Int_t nSeeds) const;
 228
 229
 230   ClassDef(AliMUONTrackReconstructor, 0) // MUON track reconstructor in ALICE
 231     };
 232
 233 #endif