LitScalTrack.h

Go to the documentation of this file.

 
#ifndef LITSCALTRACK_H_
#define LITSCALTRACK_H_
 
#include "LitScalPixelHit.h"
#include "LitTrackParam.h"
#include <sstream>
#include <string>
#include <vector>
 
using std::string;
using std::stringstream;
using std::vector;
 
namespace lit {
  namespace parallel {
 
    class LitScalTrack {
    public:
      LitScalTrack()
        : fHits()
        , fParamFirst()
        , fParamLast()
        , fChiSq(0.)
        , fNDF(1)
        , fNofMissingHits(0)
        , fPreviousTrackId(0)
        , fLastStationId(0)
        , fIsGood(true) {
        fHits.reserve(30);
      }
 
      virtual ~LitScalTrack() {}
 
      void AddHit(const LitScalPixelHit* hit) { fHits.push_back(hit); }
 
      unsigned short GetNofHits() const { return fHits.size(); }
 
      void SetNofHits(unsigned short nofHits) { return fHits.resize(nofHits); }
 
      const LitScalPixelHit* GetHit(unsigned short index) const {
        return fHits[index];
      }
 
      const LitTrackParamScal& GetParamFirst() const { return fParamFirst; }
 
      void SetParamFirst(const LitTrackParamScal& param) {
        fParamFirst = param;
      }
 
      const LitTrackParamScal& GetParamLast() const { return fParamLast; }
 
      void SetParamLast(const LitTrackParamScal& param) { fParamLast = param; }
 
      fscal GetChiSq() const { return fChiSq; }
 
      void SetChiSq(fscal chiSq) { fChiSq = chiSq; }
 
      void IncChiSq(fscal dChiSq) { fChiSq += dChiSq; }
 
      unsigned short GetNDF() const { return fNDF; }
 
      void SetNDF(unsigned short NDF) { fNDF = NDF; }
 
      unsigned short GetNofMissingHits() const { return fNofMissingHits; }
 
      void SetNofMissingHits(unsigned short nofMissingHits) {
        fNofMissingHits = nofMissingHits;
      }
 
      unsigned short GetLastStationId() const { return fLastStationId; }
 
      void SetLastStationId(unsigned short lastStationId) {
        fLastStationId = lastStationId;
      }
 
      void IncNofMissingHits(unsigned short dNofMissingHits = 1) {
        fNofMissingHits += dNofMissingHits;
      }
 
      unsigned short GetPreviousTrackId() const { return fPreviousTrackId; }
 
      void SetPreviousTrackId(unsigned short previousTrackId) {
        fPreviousTrackId = previousTrackId;
      }
 
      bool IsGood() const { return fIsGood; }
 
      void IsGood(bool isGood) { fIsGood = isGood; }
 
      string ToString() const {
        stringstream ss;
        ss << "LitTrack: nofHits=" << GetNofHits() << " chiSq=" << GetChiSq()
           << " NDF=" << GetNDF() << " nofMissingHits=" << GetNofMissingHits()
           << " previousTrackId=" << GetPreviousTrackId()
           << " paramFirst=" << GetParamFirst()
           << " paramLast=" << GetParamLast() << "\n";
        return ss.str();
      }
 
      friend ostream& operator<<(ostream& strm, const LitScalTrack& track) {
        strm << track.ToString();
        return strm;
      }
 
    private:
      vector<const LitScalPixelHit*> fHits;  // Array of hits
      LitTrackParamScal fParamFirst;         // First track parameter
      LitTrackParamScal fParamLast;          // Last track parameter
      fscal fChiSq;                          // Chi-square of the track
      unsigned short fNDF;                   // Number of degrees of freedom
      unsigned short fNofMissingHits;        // Number of missing hits
      unsigned short fPreviousTrackId;       // Id of the track seed
      unsigned char fLastStationId;          // ID of last station
      bool fIsGood;                          // true id track is "good"
    };
 
 
    class CompareLitScalTrackChiSqOverNdfLess :
      public std::
        binary_function<const LitScalTrack*, const LitScalTrack*, bool> {
    public:
      bool operator()(const LitScalTrack* track1,
                      const LitScalTrack* track2) const {
        return ((track1->GetChiSq() / track1->GetNDF())
                < (track2->GetChiSq() / track2->GetNDF()));
      }
    };
 
 
    class CompareLitScalTrackNofHitsMore :
      public std::
        binary_function<const LitScalTrack*, const LitScalTrack*, bool> {
    public:
      bool operator()(const LitScalTrack* track1,
                      const LitScalTrack* track2) const {
        return track1->GetNofHits() > track2->GetNofHits();
      }
    };
 
 
    class CompareLitScalTrackLastStationIdMore :
      public std::
        binary_function<const LitScalTrack*, const LitScalTrack*, bool> {
    public:
      bool operator()(const LitScalTrack* track1,
                      const LitScalTrack* track2) const {
        return track1->GetLastStationId() > track2->GetLastStationId();
      }
    };
 
  }  // namespace parallel
}  // namespace lit
 
 
#endif /* LITSCALTRACK_H_ */