Track.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file 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