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());
  }



}

#endif