PndRiemannTrackFinder.h

Go to the documentation of this file.

#ifndef PNDRIEMANNTRACKFINDER_H_
#define PNDRIEMANNTRACKFINDER_H_

#include "PndRiemannTrack.h"
#include "PndRiemannHit.h"
#include "FairHit.h"
#include "PndSdsHit.h"
#include "TClonesArray.h"
#include "PndTrackCand.h"
#include "TH2F.h"

#include <vector>
#include <map>

class PndRiemannTrackFinder {
 public:
  PndRiemannTrackFinder();
  virtual ~PndRiemannTrackFinder();

  void FindTracks(); 
  void MergeTracks();
  void SetHits(std::vector<FairHit *> hits) { fHits = hits; }; 
  void AddHits(std::vector<FairHit *> hits, Int_t branchId);   
  void AddHits(TClonesArray *hits, Int_t branchId);            
  void AddHit(FairHit *hit) { fHits.push_back(hit); };         
  void SetVerbose(int val) { fVerbose = val; }
  int NTracks() { return fTrackCand.size(); };            
  PndRiemannTrack GetTrack(int i) { return fTracks[i]; }; 
  PndTrack GetPndTrack(int i, double B) { return fTracks[i].getPndTrack(B); };
  std::set<Int_t> GetTrackCandidates(int i) { return fHitsInTracks[i]; }; 
  std::vector<PndTrackCand> GetTrackCand() { return fTrackCand; }
  std::vector<PndTrackCand> GetMergedTrackCands() { return fMergedTrackCand; }
  PndTrackCand GetTrackCand(int i) { return fTrackCand[i]; }
  double HitDistance(FairHit *h1, FairHit *h2);                                  
  int HitTooClose(std::set<Int_t> hitsInUse, FairHit *newHit, double threshold); 

  void SetMaxPlaneDistance(double val) { fMaxPlaneDist = val; }
  void SetMaxSZDist(double val) { fMaxSZDist = val; }
  void SetMaxSZChi2(double val) { fMaxSZChi2 = val; }
  void SetMinPointDist(double val) { fMinPointDist = val; }
  void SetUseZeroPos(bool val) { fUseZeroPos = val; }
  void SetMinNumberOfHits(int val) { fMinNumberOfHits = val; }
  void SetCurvDiff(double val) { fCurvDiff = val; }
  void SetDipDiff(double val) { fDipDiff = val; }

 protected:
  std::vector<FairHit *> fHits;                             
  std::vector<PndRiemannTrack> fTracks;                     
  std::vector<std::set<Int_t>> fHitsInTracks;               
  std::vector<PndTrackCand> fTrackCand;                     
  std::vector<std::pair<double, double>> fCurvAndDipOfCand; 
  std::vector<PndTrackCand> fMergedTrackCand;
  std::vector<std::set<int>> fHitsTooClose; 
  std::map<int, FairLink> fMapHitToID;      
  std::map<FairLink, int> fMapIDtoHit;      
  double fMaxPlaneDist;                     
  double fMaxSZDist;                        
  double fMinPointDist;                     
  double fMaxSZChi2;                        
  int fMinNumberOfHits;                     
  double fCurvDiff;                         
  double fDipDiff;                          
  double fMagField;                         

  int fVerbose;
  bool fUseZeroPos;

  std::vector<std::set<Int_t>> GetStartTracks();
  bool CheckHitDistance(int hit1, int hit2); 
  bool CheckSZ(PndRiemannTrack aTrack);      
  bool CheckRiemannHit(PndRiemannTrack *track, PndRiemannHit *hit);
  bool CheckHitInSameSensor(int hit1, int hit2);             
  bool CheckHitInTrack(std::set<int> hitIds, int hit);       
  bool CheckZeroPassing(std::set<int> hitIds, int hit);      
  PndRiemannTrack CreateRiemannTrack(std::set<Int_t> aHits); 

  bool TrackExists(std::set<Int_t> hitsInTrack);
  std::vector<int> FindTracksWithSimilarParameters(int TrackInd, std::vector<int> &TracksToTest, double curvDiff, double dipDiff);
  std::vector<int> FindTracksWithSimilarHits(std::vector<int> &TracksToTest, std::vector<PndTrackCand> tempTrCnd, std::vector<int> &tempKillAfter); 
  void RemoveTrack(int TrackInd, std::vector<int> &TrackList);
  //    void PrintTrackCand(PndTrackCand* cand);
  PndTrackCand CreateOneTrackCand(std::vector<int> tracks, std::vector<PndTrackCand> tempTrCnd); 
                                                                                                 // Fast method to figure out if a combination of hits is already used as a track
                                                                                                 // Problem: It does not work for more than 32 hits
  //    std::vector<Int_t> fHitsInTracks; ///< one int stands for the hits used in one track. The hits are encoded as bits in an int32

  // Solution: use a vector<vector <Int_t> > fHitsInTracks instead. This is not so fast but works for more than 32 hits

  //    void SetHitInTrack(Int_t position, Int_t& value);
  //    std::vector<int> GetHitsInTrack(Int_t value);
  //    bool TrackExists(Int_t hitsInTrack);

  //    std::vector<int> GetHitsInTrack(Int_t value);

 public:
  ClassDef(PndRiemannTrackFinder, 2)
};

#endif /*PNDRIEMANNTRACKFINDER_H_*/