Track.h

/* Copyright 2008-2010, Technische Universitaet Muenchen,
   Authors: Christian Hoeppner & Sebastian Neubert & Johannes Rauch & Tobias Schlüter
 
   This file is part of GENFIT.
 
   GENFIT is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
   by the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   GENFIT is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public License
   along with GENFIT.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef genfit_Track_h
#define genfit_Track_h
 
#include "AbsTrackRep.h"
#include "FitStatus.h"
#include "MeasurementFactory.h"
#include "TrackCand.h"
#include "TrackPoint.h"
 
#include <vector>
#include <TObject.h>
#include <TVectorD.h>
 
 
namespace genfit {
 
class KalmanFitStatus;
 
class TrackPointComparator {
 public:
  bool operator() (const TrackPoint* lhs, const TrackPoint* rhs) const {
    return lhs->getSortingParameter() < rhs->getSortingParameter();
  }
};
 
 
class Track : public TObject {
 
 public:
 
  Track();
 
  Track(const TrackCand& trackCand, const MeasurementFactory<genfit::AbsMeasurement>& factory, AbsTrackRep* rep = nullptr);
 
  Track(AbsTrackRep* trackRep, const TVectorD& stateSeed);
  Track(AbsTrackRep* trackRep, const TVector3& posSeed, const TVector3& momSeed);
  Track(AbsTrackRep* trackRep, const TVectorD& stateSeed, const TMatrixDSym& covSeed);
 
  Track(const Track&); // copy constructor
  Track& operator=(Track); // assignment operator
  void swap(Track& other); // nothrow
 
  virtual ~Track();
  virtual void Clear(Option_t* = "");
 
  void createMeasurements(const TrackCand& trackCand, const MeasurementFactory<genfit::AbsMeasurement>& factory);
 
  TrackPoint* getPoint(int id) const;
  const std::vector< genfit::TrackPoint* > & getPoints() const {return trackPoints_;}
  unsigned int getNumPoints() const {return trackPoints_.size();}
 
  TrackPoint* getPointWithMeasurement(int id) const;
  const std::vector< genfit::TrackPoint* > & getPointsWithMeasurement() const  {return trackPointsWithMeasurement_;}
  unsigned int getNumPointsWithMeasurement() const {return trackPointsWithMeasurement_.size();}
 
  TrackPoint* getPointWithMeasurementAndFitterInfo(int id, const AbsTrackRep* rep = nullptr) const;
  TrackPoint* getPointWithFitterInfo(int id, const AbsTrackRep* rep = nullptr) const;
 
  const MeasuredStateOnPlane& getFittedState(int id = 0, const AbsTrackRep* rep = nullptr, bool biased = true) const;
 
  AbsTrackRep* getTrackRep(int id) const {return trackReps_.at(id);}
  const std::vector<genfit::AbsTrackRep*>& getTrackReps() const {return trackReps_;}
  unsigned int getNumReps() const {return trackReps_.size();}
 
  int getIdForRep(const AbsTrackRep* rep) const;
 
  AbsTrackRep* getCardinalRep() const {return trackReps_.at(cardinalRep_);}
  unsigned int getCardinalRepId() const {return cardinalRep_;}
 
  int getMcTrackId() const {return mcTrackId_;}
 
  bool hasFitStatus(const AbsTrackRep* rep = nullptr) const;
  FitStatus* getFitStatus(const AbsTrackRep* rep = nullptr) const {if (rep == nullptr) rep = getCardinalRep(); return fitStatuses_.at(rep);}
 
  bool hasKalmanFitStatus(const AbsTrackRep* rep = nullptr) const;
  KalmanFitStatus* getKalmanFitStatus(const AbsTrackRep* rep = nullptr) const;
 
  void setFitStatus(FitStatus* fitStatus, const AbsTrackRep* rep);
 
  double getTimeSeed() const {return timeSeed_;}
  void setTimeSeed(double time) {timeSeed_ = time;}
 
  const TVectorD& getStateSeed() const {return stateSeed_;}
  void setStateSeed(const TVectorD& s) {stateSeed_.ResizeTo(s); stateSeed_ = s;}
  void setStateSeed(const TVector3& pos, const TVector3& mom);
 
  const TMatrixDSym& getCovSeed() const {return covSeed_;}
  void setCovSeed(const TMatrixDSym& c) {covSeed_.ResizeTo(c); covSeed_ = c;}
 
  void setMcTrackId(int i) {mcTrackId_ = i;}
 
  void insertPoint(TrackPoint* point, int id = -1);
 
  void insertPoints(std::vector<genfit::TrackPoint*> points, int id = -1);
 
  void deletePoint(int id);
 
  void insertMeasurement(AbsMeasurement* measurement, int id = -1);
 
  void deleteTrackPointsAndFitStatus();
  void mergeTrack(const Track* other, int id = -1);
 
  void addTrackRep(AbsTrackRep* trackRep);
 
  void deleteTrackRep(int id);
 
  void setCardinalRep(int id);
  void determineCardinalRep();
 
  bool sort();
 
  bool udpateSeed(int id = 0, AbsTrackRep* rep = nullptr, bool biased = true);
 
  void reverseTrackPoints();
 
  void reverseMomSeed() {
    stateSeed_(3) *= -1; stateSeed_(4) *= -1; stateSeed_(5) *= -1;
  }
 
  void switchPDGSigns(AbsTrackRep* rep = nullptr);
 
 
  void reverseTrack();
 
 
  void deleteForwardInfo(int startId = 0, int endId = -1, const AbsTrackRep* rep = nullptr); // delete in range [startId, endId]. If rep == nullptr, delete for ALL reps, otherwise only for rep.
  void deleteBackwardInfo(int startId = 0, int endId = -1, const AbsTrackRep* rep = nullptr); // delete in range [startId, endId]. If rep == nullptr, delete for ALL reps, otherwise only for rep.
  void deleteReferenceInfo(int startId = 0, int endId = -1, const AbsTrackRep* rep = nullptr); // delete in range [startId, endId]. If rep == nullptr, delete for ALL reps, otherwise only for rep.
  void deleteMeasurementInfo(int startId = 0, int endId = -1, const AbsTrackRep* rep = nullptr); // delete in range [startId, endId]. If rep == nullptr, delete for ALL reps, otherwise only for rep.
  void deleteFitterInfo(int startId = 0, int endId = -1, const AbsTrackRep* rep = nullptr); // delete in range [startId, endId]. If rep == nullptr, delete for ALL reps, otherwise only for rep.
 
  double getTrackLen(AbsTrackRep* rep = nullptr, int startId = 0, int endId = -1) const;
  double getTOF(AbsTrackRep* rep = nullptr, int startId = 0, int endId = -1) const;
 
  void deleteFittedState(const genfit::AbsTrackRep* rep); 
 
 
  TrackCand* constructTrackCand() const;
 
  void fixWeights(AbsTrackRep* rep = nullptr, int startId = 0, int endId = -1);
 
  void prune(const Option_t* = "CFLWRMIU");
 
  void Print(const Option_t* = "") const;
 
  void checkConsistency() const;
 
 private:
 
  void trackHasChanged();
 
  void fillPointsWithMeasurement();
 
  std::vector<AbsTrackRep*> trackReps_; // Ownership
  unsigned int cardinalRep_; // THE selected rep, default = 0;
 
  std::vector<TrackPoint*> trackPoints_; // Ownership
  std::vector<TrackPoint*> trackPointsWithMeasurement_; 
 
  std::map< const AbsTrackRep*, FitStatus* > fitStatuses_; // Ownership over FitStatus*
 
  int mcTrackId_; 
  double timeSeed_;
  TVectorD stateSeed_; // 6D: position, momentum
  TMatrixDSym covSeed_; // 6D
 
 
 public:
  ClassDef(Track,3)
  // Class version history:
  //  ver 3: introduces timeSeed_
};
 
} /* End of namespace genfit */
#endif // genfit_Track_h