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