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_;
  };

}  // namespace reco

#endif