ParticleState.h

Go to the documentation of this file.

#ifndef Candidate_ParticleState_h
#define Candidate_ParticleState_h

#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include "DataFormats/Math/interface/PtEtaPhiMass.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "Rtypes.h"

namespace reco {
  
  class ParticleState {
  public:
    typedef int Charge;
    typedef math::XYZTLorentzVector LorentzVector;
    typedef math::PtEtaPhiMLorentzVector PolarLorentzVector;
    typedef math::XYZPoint Point;
    typedef math::XYZVector Vector;
    ParticleState() : vertex_(0, 0, 0),
         qx3_(0), pdgId_(0), status_(0){}
    
    ParticleState( Charge q, const PtEtaPhiMass  & p4, const Point & vertex= Point( 0, 0, 0 ),
          int pdgId=0, int status=0, bool integerCharge=true)
      : vertex_( vertex ),  p4Polar_( p4.pt(), p4.eta(), p4.phi(), p4.mass() ),
    p4Cartesian_(p4Polar_),
    qx3_( integerCharge ? q*3 : q ),pdgId_( pdgId ), status_( status ){}
    
    ParticleState( Charge q, const LorentzVector & p4, const Point & vertex = Point( 0, 0, 0 ),
          int pdgId = 0, int status = 0, bool integerCharge = true ) :
      vertex_( vertex ), 
      p4Polar_(p4), p4Cartesian_(p4),
      qx3_( integerCharge ? q*3 : q ),pdgId_( pdgId ), status_( status ){}

    
    ParticleState( Charge q, const PolarLorentzVector & p4, const Point & vertex = Point( 0, 0, 0 ),
          int pdgId = 0, int status = 0, bool integerCharge = true ):
      vertex_( vertex ), 
      p4Polar_(p4), p4Cartesian_(p4),
      qx3_( integerCharge ? q*3 : q ),pdgId_( pdgId ), status_( status ){}
    
    ParticleState( Charge q, const GlobalVector & p3, float iEnergy, float imass, const Point & vertex = Point( 0, 0, 0 ),
                   int pdgId = 0, int status = 0, bool integerCharge = true ) :
      vertex_( vertex ), 
      p4Polar_(p3.perp(),p3.eta(),p3.phi(),imass),  p4Cartesian_(p3.x(),p3.y(),p3.z(), iEnergy),
      qx3_( integerCharge ? q*3 : q ), pdgId_( pdgId ), status_( status ){}

    inline void setCartesian()  { 
      p4Cartesian_ = p4Polar_;
    }
 
    int charge() const { return qx3_ / 3; }
    void setCharge( Charge q ) { qx3_ = q * 3; }
    int threeCharge() const { return qx3_; }
    void setThreeCharge( Charge qx3 ) { qx3_ = qx3; }
    const LorentzVector & p4() const {  return p4Cartesian_; }
    const PolarLorentzVector & polarP4() const { return p4Polar_; }
    Vector momentum() const {  return p4Cartesian_.Vect(); }
    Vector boostToCM() const {  return p4Cartesian_.BoostToCM(); }
    double p() const {  return p4Cartesian_.P(); }
    double energy() const {  return p4Cartesian_.E(); }  
    double et() const { return (pt()<=0) ? 0 : p4Cartesian_.Et(); }  
    double et2() const { return (pt()<=0) ? 0 : p4Cartesian_.Et2(); }  
    double mass() const { return  p4Polar_.mass(); }
    double massSqr() const { return mass()*mass(); }
    double mt() const { return p4Polar_.Mt(); }
    double mtSqr() const { return p4Polar_.Mt2(); }
    double px() const {  return p4Cartesian_.Px(); }
    double py() const {  return p4Cartesian_.Py(); }
    double pz() const {  return p4Cartesian_.Pz(); }
    double pt() const { return p4Polar_.pt(); }
    double phi() const { return p4Polar_.phi(); }
    double theta() const {  return p4Cartesian_.Theta(); }
    double eta() const { return p4Polar_.eta(); }
    double rapidity() const {  return p4Polar_.Rapidity(); }
    double y() const { return rapidity(); }
    void setP4( const LorentzVector & p4 ) { 
      p4Cartesian_ = p4;
      p4Polar_ = p4;

    }
    void setP4( const PolarLorentzVector & p4 ) { 
      p4Polar_ = p4;
      p4Cartesian_ = p4;
    }
    void setMass( double m ) { 
      p4Polar_.SetM(m);
      setCartesian();
      
    }
    void setPz( double pz ) {
      p4Cartesian_.SetPz(pz);
      p4Polar_ = p4Cartesian_;

    }
    const Point & vertex() const { return vertex_; }
    double vx() const { return vertex_.X(); }
    double vy() const { return vertex_.Y(); }
    double vz() const { return vertex_.Z(); }
    void setVertex( const Point & vertex ) { vertex_ = vertex; }
    int pdgId() const { return pdgId_; }
    // set PDG identifier
    void setPdgId( int pdgId ) { pdgId_ = pdgId; }
    int status() const { return status_; }
    void setStatus( int status ) { status_ = status; }
    void setLongLived() { status_ |= longLivedTag; }
    bool longLived() const { return status_ & longLivedTag; }
    void setMassConstraint() { status_ |= massConstraintTag;}
    bool massConstraint() const  { return status_ & massConstraintTag; }


  private:
    static const unsigned int longLivedTag = 65536;
    static const unsigned int massConstraintTag = 131072;
    
  private:
    Point vertex_;
    
    PolarLorentzVector p4Polar_;
    LorentzVector p4Cartesian_;

    Charge qx3_;   

    int pdgId_;
    int status_;
    
  };

}

#endif