TrackingParticle.h

Go to the documentation of this file.

#ifndef SimDataFormats_TrackingParticle_h
#define SimDataFormats_TrackingParticle_h
 
#include <vector>
#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingVertexContainer.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
 
//
// Forward declarations
//
class TrackingVertex;
class SimTrack;
class EncodedEventId;
 
class TrackingParticle {
  friend std::ostream& operator<<(std::ostream& s, TrackingParticle const& tp);
 
public:
  typedef int Charge;                                       
  typedef math::XYZTLorentzVectorD LorentzVector;           
  typedef math::PtEtaPhiMLorentzVector PolarLorentzVector;  
  typedef math::XYZPointD Point;                            
  typedef math::XYZVectorD Vector;                          
 
  typedef reco::GenParticleRefVector::iterator genp_iterator;
  typedef std::vector<SimTrack>::const_iterator g4t_iterator;
 
  TrackingParticle();
 
  TrackingParticle(const SimTrack& simtrk, const TrackingVertexRef& parentVertex);
 
  // destructor
  ~TrackingParticle();
 
  int pdgId() const {
    if (genParticles_.empty())
      return g4Tracks_[0].type();
    else
      return (*genParticles_.begin())->pdgId();
  }
 
  EncodedEventId eventId() const { return g4Tracks_[0].eventId(); }
 
  // Setters for G4 and reco::GenParticle
  void addGenParticle(const reco::GenParticleRef& ref);
  void addG4Track(const SimTrack& t);
  genp_iterator genParticle_begin() const;
  genp_iterator genParticle_end() const;
  g4t_iterator g4Track_begin() const;
  g4t_iterator g4Track_end() const;
  void setParentVertex(const TrackingVertexRef& ref);
  void addDecayVertex(const TrackingVertexRef& ref);
  void clearParentVertex();
  void clearDecayVertices();
 
  // Getters for Embd and Sim Tracks
  const reco::GenParticleRefVector& genParticles() const { return genParticles_; }
  const std::vector<SimTrack>& g4Tracks() const { return g4Tracks_; }
  const TrackingVertexRef& parentVertex() const { return parentVertex_; }
 
  // Accessors for vector of decay vertices
  const TrackingVertexRefVector& decayVertices() const { return decayVertices_; }
  tv_iterator decayVertices_begin() const { return decayVertices_.begin(); }
  tv_iterator decayVertices_end() const { return decayVertices_.end(); }
 
  float charge() const { return g4Tracks_[0].charge(); }
  int threeCharge() const { return lrintf(3.f * charge()); }
 
  const LorentzVector& p4() const { return g4Tracks_[0].momentum(); }
 
  Vector momentum() const { return p4().Vect(); }
 
  Vector boostToCM() const { return p4().BoostToCM(); }
 
  double p() const { return p4().P(); }
 
  double qoverp() const { return charge() / p(); }
 
  double energy() const { return p4().E(); }
 
  double et() const { return p4().Et(); }
 
  double mass() const { return p4().M(); }
 
  double massSqr() const { return pow(mass(), 2); }
 
  double mt() const { return p4().Mt(); }
 
  double mtSqr() const { return p4().Mt2(); }
 
  double px() const { return p4().Px(); }
 
  double py() const { return p4().Py(); }
 
  double pz() const { return p4().Pz(); }
 
  double pt() const { return p4().Pt(); }
 
  double phi() const { return p4().Phi(); }
 
  double theta() const { return p4().Theta(); }
 
  double eta() const { return p4().Eta(); }
 
  double lambda() const { return M_PI_2 - theta(); }
 
  double tanl() const { return tan(lambda()); }
 
  double rapidity() const { return p4().Rapidity(); }
 
  double y() const { return rapidity(); }
 
  Point vertex() const {
    const TrackingVertex::LorentzVector& p = (*parentVertex_).position();
    return Point(p.x(), p.y(), p.z());
  }
 
  double vx() const {
    const TrackingVertex& r = (*parentVertex_);
    return r.position().X();
  }
 
  double vy() const {
    const TrackingVertex& r = (*parentVertex_);
    return r.position().Y();
  }
 
  double vz() const {
    const TrackingVertex& r = (*parentVertex_);
    return r.position().Z();
  }
 
  double dxy() const { return (-vx() * py() + vy() * px()) / pt(); }
 
  double d0() const { return -dxy(); }
 
  double dz() const { return vz() - (vx() * px() + vy() * py()) * pz() / p4().Perp2(); }
 
  double z0() const { return dz(); }
 
  int status() const { return genParticles_.empty() ? -99 : (*genParticles_[0]).status(); }
 
  static const unsigned int longLivedTag;  
 
  bool longLived() const { return status() & longLivedTag; }
 
  int numberOfHits() const { return numberOfHits_; }
 
  int numberOfTrackerHits() const { return numberOfTrackerHits_; }
 
  int matchedHit() const;
 
  int numberOfTrackerLayers() const { return numberOfTrackerLayers_; }
 
  void setNumberOfHits(int numberOfHits);
  void setNumberOfTrackerHits(int numberOfTrackerHits);
  void setNumberOfTrackerLayers(const int numberOfTrackerLayers);
 
private:
  int numberOfHits_;           
  int numberOfTrackerHits_;    
  int numberOfTrackerLayers_;  
 
  std::vector<SimTrack> g4Tracks_;
  reco::GenParticleRefVector genParticles_;
 
  // Source and decay vertices
  TrackingVertexRef parentVertex_;
  TrackingVertexRefVector decayVertices_;
};
 
#endif  // SimDataFormats_TrackingParticle_H