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;

  };

}

#endif