Track.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/* 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 * = "");

  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) 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); }
  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 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;


  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;

  bool 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