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_*/