TrackCand.h

/* Copyright 2008-2010, Technische Universitaet Muenchen,
   Authors: Christian Hoeppner & Sebastian Neubert & Johannes Rauch
 
   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_TrackCand_h
#define genfit_TrackCand_h
 
#include "TrackCandHit.h"
 
#include <vector>
#include <set>
#include <assert.h>
 
#include <TObject.h>
#include <TVector3.h>
#include <TVectorD.h>
#include <TMatrixD.h>
#include <TMatrixDSym.h>
#include <TDatabasePDG.h>
 
#include <cmath>
 
 
namespace genfit {
 
class TrackCand : public TObject {
 
 
 public:
 
 
  // Constructors/Destructors ---------
  TrackCand();
  ~TrackCand();
 
  TrackCand( const TrackCand& other );
  TrackCand& operator=(TrackCand other);
  void swap(TrackCand& other); // nothrow
 
  friend bool operator== (const TrackCand& lhs, const TrackCand& rhs);
  friend bool operator!= (const TrackCand& lhs, const TrackCand& rhs) {return !(lhs == rhs);}
 
  static bool compareTrackCandHits(const TrackCandHit* lhs, const TrackCandHit* rhs) {return (*lhs < *rhs);} // operator< defined in TrackCandHit.h
 
  // Accessors -----------------------
  TrackCandHit* getHit(int i) const;
 
  void getHit(int i, int& detId, int& hitId) const;
 
  void getHit(int i, int& detId, int& hitId, double& sortingParameter) const;
 
  void getHitWithPlane(int i, int& detId, int& hitId, int& planeId) const;
 
  unsigned int getNHits() const {return hits_.size();}
 
  std::vector<int>    getHitIDs(int detId = -2) const;
 
  std::vector<int>    getDetIDs() const;
  std::vector<double> getSortingParameters() const;
  std::set<int>       getUniqueDetIDs() const;
 
  int getMcTrackId() const {return mcTrackId_;}
 
  double getTimeSeed() const { return time_; }
 
  TVector3 getPosSeed() const {return TVector3(state6D_(0), state6D_(1), state6D_(2));}
 
  TVector3 getMomSeed() const {return TVector3(state6D_(3), state6D_(4), state6D_(5));}
 
  const TMatrixDSym& getCovSeed() const {return cov6D_;}
 
  const TVectorD& getStateSeed() const {return state6D_;}
 
  double getChargeSeed() const {return q_;}
 
  int getPdgCode() const {return pdg_;}
 
  bool hitInTrack(int detId, int hitId) const;
 
  // Modifiers -----------------------
 
  void addHit(int detId, int hitId, int planeId = -1, double sortingParameter = 0);
 
  void addHit(TrackCandHit* hit) {hits_.push_back(hit);}
 
  void setMcTrackId(int i) {mcTrackId_ = i;}
 
  void setPdgCode(int pdgCode);
 
  void append(const TrackCand&);
 
  void sortHits();
 
  void sortHits(const std::vector<unsigned int>& indices);
 
  // Operations ----------------------
  void reset();
 
  void Print(const Option_t* = "") const ;
 
  void setTimeSeed(double time) { time_ = time; }
 
  void setCovSeed(const TMatrixDSym& cov6D) {cov6D_ = cov6D; /* always 6D, no need to resize */}
 
  void set6DSeed(const TVectorD& state6D, const double charge);
 
  void set6DSeedAndPdgCode(const TVectorD& state6D, const int pdgCode);
 
  void setPosMomSeed(const TVector3& pos, const TVector3& mom, const double charge);
 
  void setPosMomSeedAndPdgCode(const TVector3& pos, const TVector3& mom, const int pdgCode);
 
  void setTime6DSeed(double time, const TVectorD& state6D, const double charge);
 
  void setTime6DSeedAndPdgCode(double time, const TVectorD& state6D, const int pdgCode);
 
  void setTimePosMomSeed(double time, const TVector3& pos, const TVector3& mom,
       const double charge);
 
  void setTimePosMomSeedAndPdgCode(double time, const TVector3& pos,
           const TVector3& mom, const int pdgCode);
 
 
 private:
 
  // Private Data Members ------------
  std::vector<TrackCandHit*> hits_; //->
 
  int mcTrackId_; 
  int pdg_; 
  double time_; 
  TVectorD state6D_; 
  TMatrixDSym cov6D_; 
  double q_; 
 public:
 
  ClassDef(TrackCand,2)
  // Version history:
  // ver 2: keep track of time in state (schema evolution rule added).
};
 
} /* End of namespace genfit */
#endif // genfit_TrackCand_h