LeafRefCandidateT.h

Go to the documentation of this file.

#ifndef Candidate_LeafRefCandidateT_h
#define Candidate_LeafRefCandidateT_h

#include "DataFormats/Candidate/interface/LeafCandidate.h"
#include "DataFormats/Common/interface/RefCoreWithIndex.h"

namespace reco {

  class LeafRefCandidateT : public LeafCandidate {
  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;

    LeafRefCandidateT() {}
    // constructor from T
    template <class REF>
    LeafRefCandidateT(const REF& c, float m)
        : LeafCandidate(c->charge(), PolarLorentzVector(c->pt(), c->eta(), c->phi(), m), c->vertex()),
          ref_(c.refCore(), c.key()) {}
    ~LeafRefCandidateT() override {}

  protected:
    // get the ref (better be the correct ref!)
    template <typename REF>
    REF getRef() const {
      return REF(ref_.toRefCore(), ref_.index());
    }

  public:
    size_t numberOfDaughters() const final { return 0; }
    const Candidate* daughter(size_type) const final { return nullptr; }
    size_t numberOfMothers() const final { return 0; }
    const Candidate* mother(size_type) const final { return nullptr; }
    Candidate* daughter(size_type) final { return nullptr; }
    Candidate* daughter(const std::string& s) final { return nullptr; }
    const Candidate* daughter(const std::string& s) const final { return nullptr; }
    size_t numberOfSourceCandidatePtrs() const final { return 0; }
    CandidatePtr sourceCandidatePtr(size_type i) const final {
      static const CandidatePtr dummyPtr;
      return dummyPtr;
    }

    bool hasMasterClone() const final { return false; }
    const CandidateBaseRef& masterClone() const final {
      static const CandidateBaseRef dummyRef;
      return dummyRef;
    }
    bool hasMasterClonePtr() const final { return false; }
    const CandidatePtr& masterClonePtr() const final {
      static const CandidatePtr dummyPtr;
      return dummyPtr;
    }

    template <typename Ref>
    Ref masterRef() const {
      Ref dummyRef;
      return dummyRef;
    }

    template <typename C>
    C get() const {
      if (hasMasterClone())
        return masterClone()->template get<C>();
      else
        return reco::get<C>(*this);
    }
    template <typename C, typename Tag>
    C get() const {
      if (hasMasterClone())
        return masterClone()->template get<C, Tag>();
      else
        return reco::get<C, Tag>(*this);
    }
    template <typename C>
    C get(size_type i) const {
      if (hasMasterClone())
        return masterClone()->template get<C>(i);
      else
        return reco::get<C>(*this, i);
    }
    template <typename C, typename Tag>
    C get(size_type i) const {
      if (hasMasterClone())
        return masterClone()->template get<C, Tag>(i);
      else
        return reco::get<C, Tag>(*this, i);
    }
    template <typename C>
    size_type numberOf() const {
      if (hasMasterClone())
        return masterClone()->template numberOf<C>();
      else
        return reco::numberOf<C>(*this);
    }
    template <typename C, typename Tag>
    size_type numberOf() const {
      if (hasMasterClone())
        return masterClone()->template numberOf<C, Tag>();
      else
        return reco::numberOf<C, Tag>(*this);
    }

    bool isElectron() const final { return false; }
    bool isMuon() const final { return false; }
    bool isStandAloneMuon() const final { return false; }
    bool isGlobalMuon() const final { return false; }
    bool isTrackerMuon() const final { return false; }
    bool isCaloMuon() const final { return false; }
    bool isPhoton() const final { return false; }
    bool isConvertedPhoton() const final { return false; }
    bool isJet() const final { return false; }

    CMS_CLASS_VERSION(13)

  protected:
    bool overlap(const Candidate&) const override;
    virtual bool overlap(const LeafRefCandidateT&) const;
    template <typename, typename, typename>
    friend struct component;
    friend class ::OverlapChecker;
    friend class ShallowCloneCandidate;
    friend class ShallowClonePtrCandidate;

  protected:
    edm::RefCoreWithIndex ref_;

  private:
    /*                                    
    virtual void setCharge( Charge q ) final  {}                                         
    virtual void setThreeCharge( Charge qx3 ) final  {}
    virtual void setP4( const LorentzVector & p4 ) final  {}
    virtual void setP4( const PolarLorentzVector & p4 ) final  {}
    virtual void setPz( double pz ) final  {}                            
    virtual void setVertex( const Point & vertex ) final  {}
    virtual void setPdgId( int pdgId ) final  {}                                              
    virtual void setStatus( int status ) final  {}
    virtual void setLongLived() final  {}                                      
    virtual void setMassConstraint() final  {}

    virtual double vertexChi2() const final  { return 0.; }
    virtual double vertexNdof() const final  { return 0.; }
    virtual double vertexNormalizedChi2() const final  { return 0.; }
    virtual double vertexCovariance(int i, int j) const final  { return 0.; }
    virtual void fillVertexCovariance(CovarianceMatrix & v) const final  {}
    */
  };

  inline bool LeafRefCandidateT::overlap(const Candidate& o) const {
    return (p4() == o.p4()) && (vertex() == o.vertex()) && (charge() == o.charge());
  }

  inline bool LeafRefCandidateT::overlap(const LeafRefCandidateT& o) const {
    return (ref_.id() == o.ref_.id()) && (ref_.index() == o.ref_.index());
  }

}  // namespace reco

#endif