LeafCandidate.h

Go to the documentation of this file.

#ifndef Candidate_LeafCandidate_h
#define Candidate_LeafCandidate_h
 
#include "DataFormats/Candidate/interface/Candidate.h"
#include "ParticleState.h"
 
namespace reco {
 
  class LeafCandidate : public Candidate {
  public:
    typedef CandidateCollection daughters;
    typedef int Charge;
    typedef math::XYZTLorentzVector LorentzVector;
    typedef math::PtEtaPhiMLorentzVector PolarLorentzVector;
    typedef math::XYZPoint Point;
    typedef math::XYZVector Vector;
 
    typedef unsigned int index;
 
    LeafCandidate() {}
 
    // constructor from candidate
    explicit LeafCandidate(const Candidate& c) : m_state(c.charge(), c.polarP4(), c.vertex(), c.pdgId(), c.status()) {}
 
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
    template <typename... Args>
    explicit LeafCandidate(Args&&... args) : m_state(std::forward<Args>(args)...) {}
 
    LeafCandidate(LeafCandidate& rh) : m_state(rh.m_state) {}
 
    LeafCandidate(LeafCandidate&&) = default;
    LeafCandidate(LeafCandidate const&) = default;
    LeafCandidate& operator=(LeafCandidate&&) = default;
    LeafCandidate& operator=(LeafCandidate const&) = default;
#else
    // for Reflex to parse...  (compilation will use the above)
    LeafCandidate(Charge q,
                  const PtEtaPhiMass& p4,
                  const Point& vtx = Point(0, 0, 0),
                  int pdgId = 0,
                  int status = 0,
                  bool integerCharge = true);
    LeafCandidate(Charge q,
                  const LorentzVector& p4,
                  const Point& vtx = Point(0, 0, 0),
                  int pdgId = 0,
                  int status = 0,
                  bool integerCharge = true);
    LeafCandidate(Charge q,
                  const PolarLorentzVector& p4,
                  const Point& vtx = Point(0, 0, 0),
                  int pdgId = 0,
                  int status = 0,
                  bool integerCharge = true);
    LeafCandidate(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);
    }
 
    ~LeafCandidate() override;
    size_t numberOfDaughters() const override;
    const Candidate* daughter(size_type) const override;
    size_t numberOfMothers() const override;
    const Candidate* mother(size_type) const override;
    Candidate* daughter(size_type) override;
    Candidate* daughter(const std::string& s) override;
    const Candidate* daughter(const std::string& s) const override;
    size_t numberOfSourceCandidatePtrs() const override { return 0; }
    CandidatePtr sourceCandidatePtr(size_type i) const override { return CandidatePtr(); }
 
    int charge() const final { return m_state.charge(); }
    void setCharge(Charge q) final { m_state.setCharge(q); }
    int threeCharge() const final { return m_state.threeCharge(); }
    void setThreeCharge(Charge qx3) final { m_state.setThreeCharge(qx3); }
    const LorentzVector& p4() const final { return m_state.p4(); }
    const PolarLorentzVector& polarP4() const final { return m_state.polarP4(); }
    Vector momentum() const final { return m_state.momentum(); }
    Vector boostToCM() const final { return m_state.boostToCM(); }
    double p() const final { return m_state.p(); }
    double energy() const final { return m_state.energy(); }
    double et() const final { return m_state.et(); }
    double et2() const final { return m_state.et2(); }
    double mass() const final { return m_state.mass(); }
    double massSqr() const final { return mass() * mass(); }
 
    double mt() const final { return m_state.mt(); }
    double mtSqr() const final { return m_state.mtSqr(); }
    double px() const final { return m_state.px(); }
    double py() const final { return m_state.py(); }
    double pz() const final { return m_state.pz(); }
    double pt() const final { return m_state.pt(); }
    double phi() const final { return m_state.phi(); }
    double theta() const final { return m_state.theta(); }
    double eta() const final { return m_state.eta(); }
    double rapidity() const final { return m_state.rapidity(); }
    double y() const final { return rapidity(); }
    void setP4(const LorentzVector& p4) final { m_state.setP4(p4); }
    void setP4(const PolarLorentzVector& p4) final { m_state.setP4(p4); }
    void setMass(double m) final { m_state.setMass(m); }
    void setPz(double pz) final { m_state.setPz(pz); }
    const Point& vertex() const override { return m_state.vertex(); }
    double vx() const override { return m_state.vx(); }
    double vy() const override { return m_state.vy(); }
    double vz() const override { return m_state.vz(); }
    void setVertex(const Point& vertex) override { m_state.setVertex(vertex); }
 
    int pdgId() const final { return m_state.pdgId(); }
    // set PDG identifier
    void setPdgId(int pdgId) final { m_state.setPdgId(pdgId); }
    int status() const final { return m_state.status(); }
    void setStatus(int status) final { m_state.setStatus(status); }
    void setLongLived() final { m_state.setLongLived(); }
    bool longLived() const final { return m_state.longLived(); }
    void setMassConstraint() final { m_state.setMassConstraint(); }
    bool massConstraint() const final { return m_state.massConstraint(); }
 
    LeafCandidate* clone() const override { return new LeafCandidate(*this); }
 
    double vertexChi2() const override;
    double vertexNdof() const override;
    double vertexNormalizedChi2() const override;
    double vertexCovariance(int i, int j) const override;
    CovarianceMatrix vertexCovariance() const final {
      CovarianceMatrix m;
      fillVertexCovariance(m);
      return m;
    }
    void fillVertexCovariance(CovarianceMatrix& v) const override;
    bool hasMasterClone() const override;
    const CandidateBaseRef& masterClone() const override;
    bool hasMasterClonePtr() const override;
    const CandidatePtr& masterClonePtr() const override;
 
    template <typename Ref>
    Ref masterRef() const {
      return masterClone().template castTo<Ref>();
    }
 
    template <typename T>
    T get() const {
      if (hasMasterClone())
        return masterClone()->get<T>();
      else
        return reco::get<T>(*this);
    }
    template <typename T, typename Tag>
    T get() const {
      if (hasMasterClone())
        return masterClone()->get<T, Tag>();
      else
        return reco::get<T, Tag>(*this);
    }
    template <typename T>
    T get(size_type i) const {
      if (hasMasterClone())
        return masterClone()->get<T>(i);
      else
        return reco::get<T>(*this, i);
    }
    template <typename T, typename Tag>
    T get(size_type i) const {
      if (hasMasterClone())
        return masterClone()->get<T, Tag>(i);
      else
        return reco::get<T, Tag>(*this, i);
    }
    template <typename T>
    size_type numberOf() const {
      if (hasMasterClone())
        return masterClone()->numberOf<T>();
      else
        return reco::numberOf<T>(*this);
    }
    template <typename T, typename Tag>
    size_type numberOf() const {
      if (hasMasterClone())
        return masterClone()->numberOf<T, Tag>();
      else
        return reco::numberOf<T, Tag>(*this);
    }
 
    bool isElectron() const override;
    bool isMuon() const override;
    bool isStandAloneMuon() const override;
    bool isGlobalMuon() const override;
    bool isTrackerMuon() const override;
    bool isCaloMuon() const override;
    bool isPhoton() const override;
    bool isConvertedPhoton() const override;
    bool isJet() const override;
 
  private:
    ParticleState m_state;
 
  private:
    bool overlap(const Candidate&) const override;
    template <typename, typename, typename>
    friend struct component;
    friend class ::OverlapChecker;
    friend class ShallowCloneCandidate;
    friend class ShallowClonePtrCandidate;
  };
 
}  // namespace reco
 
#endif