TrackCand.h

Go to the documentation of this file.

/* 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