Particle.h

Go to the documentation of this file.

#ifndef Candidate_Particle_h
#define Candidate_Particle_h

#include "ParticleState.h"
namespace reco {
  
  class Particle {
  public:
    typedef int Charge;
    typedef math::XYZTLorentzVector LorentzVector;
    typedef math::PtEtaPhiMLorentzVector PolarLorentzVector;
    typedef math::XYZPoint Point;
    typedef math::XYZVector Vector;

    typedef unsigned int index;

#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
    template<typename... Args>
    explicit   Particle(Args && ...args) : 
    m_state(std::forward<Args>(args)...) {}

    Particle(Particle& rh): m_state(rh.m_state){}

    Particle(Particle&&)=default;
    Particle(Particle const&)=default;
    Particle& operator=(Particle&&)=default;
    Particle& operator=(Particle const&)=default;
#else
    // for Reflex to parse...  (compilation will use the above)
    Particle();
    Particle( Charge q, const PtEtaPhiMass & p4, const Point & vtx = Point( 0, 0, 0 ),
           int pdgId = 0, int status = 0, bool integerCharge = true );
    Particle( Charge q, const LorentzVector & p4, const Point & vtx = Point( 0, 0, 0 ),
           int pdgId = 0, int status = 0, bool integerCharge = true );
    Particle( Charge q, const PolarLorentzVector & p4, const Point & vtx = Point( 0, 0, 0 ),
           int pdgId = 0, int status = 0, bool integerCharge = true );
    Particle( Charge q, const GlobalVector & p3, float iEnergy, float imass, const Point & vtx = Point( 0, 0, 0 ),
           int pdgId = 0, int status = 0, bool integerCharge = true );
#endif

    void construct(int qx3,  float pt, float eta, float phi, float mass, const Point & vtx, int pdgId, int status) {
      m_state = ParticleState(qx3, PolarLorentzVector(pt,eta,phi,mass), vtx, pdgId, status, false);
    }

    virtual ~Particle(){}


    int charge() const { return m_state.charge(); }
    void setCharge( Charge q ) { m_state.setCharge(q); }
    int threeCharge() const { return m_state.threeCharge(); }
    void setThreeCharge( Charge qx3 ) {m_state.setThreeCharge(qx3); }
    const LorentzVector & p4() const { return m_state.p4(); }
    const PolarLorentzVector & polarP4() const { return m_state.polarP4(); }
    Vector momentum() const { return m_state.momentum(); }
    Vector boostToCM() const { return m_state.boostToCM(); }
    double p() const { return m_state.p(); }
    double energy() const { return m_state.energy(); }
    double et() const { return m_state.et(); }
    double et2() const { return m_state.et2(); }
    double mass() const { return m_state.mass(); }
    double massSqr() const { return mass() * mass(); }

    double mt() const  { return m_state.mt(); }
    double mtSqr() const  { return m_state.mtSqr(); }
    double px() const  {  return m_state.px(); }
    double py() const  { return m_state.py(); }
    double pz() const  {  return m_state.pz(); }
    double pt() const  { return m_state.pt();}
    double phi() const  { return m_state.phi(); }
    double theta() const  {  return m_state.theta(); }
     double eta() const  { return m_state.eta(); }
    double rapidity() const  {  return m_state.rapidity(); }
    double y() const  { return rapidity(); }
    void setP4( const LorentzVector & p4 )  { m_state.setP4(p4);}
    void setP4( const PolarLorentzVector & p4 )  {m_state.setP4(p4); }
    void setMass( double m )  {m_state.setMass(m);}
    void setPz( double pz )  { m_state.setPz(pz);}
    const Point & vertex() const { return m_state.vertex(); }
    double vx() const  { return m_state.vx(); }
    double vy() const  { return m_state.vy(); }
    double vz() const  { return m_state.vz(); }
    void setVertex( const Point & vertex )   { m_state.setVertex(vertex); }

    int pdgId() const  { return m_state.pdgId(); }
    // set PDG identifier                                                                 
    void setPdgId( int pdgId )  { m_state.setPdgId(pdgId); }
    int status() const  { return m_state.status(); }
    void setStatus( int status )  { m_state.setStatus(status); }
    void setLongLived()  { m_state.setLongLived(); }
    bool longLived() const  { return m_state.longLived(); }
    void setMassConstraint()  { m_state.setMassConstraint();}
    bool massConstraint() const  { return m_state.massConstraint(); }

  private:
    ParticleState m_state;


  };

}

#endif