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()){}
    virtual ~LeafRefCandidateT() {}

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

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


                     
    virtual bool hasMasterClone() const GCC11_FINAL  { return false; }
    virtual const CandidateBaseRef & masterClone() const GCC11_FINAL  { 
      static const CandidateBaseRef dummyRef; return dummyRef; 
    }
    virtual bool hasMasterClonePtr() const GCC11_FINAL  { return false; }
    virtual const CandidatePtr & masterClonePtr() const GCC11_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 );
    }


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

    CMS_CLASS_VERSION(13)

  protected:
 
    virtual bool overlap( const Candidate & ) const;
    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 ) GCC11_FINAL  {}                                         
    virtual void setThreeCharge( Charge qx3 ) GCC11_FINAL  {}
    virtual void setP4( const LorentzVector & p4 ) GCC11_FINAL  {}
    virtual void setP4( const PolarLorentzVector & p4 ) GCC11_FINAL  {}
    virtual void setPz( double pz ) GCC11_FINAL  {}                            
    virtual void setVertex( const Point & vertex ) GCC11_FINAL  {}
    virtual void setPdgId( int pdgId ) GCC11_FINAL  {}                                              
    virtual void setStatus( int status ) GCC11_FINAL  {}
    virtual void setLongLived() GCC11_FINAL  {}                                      
    virtual void setMassConstraint() GCC11_FINAL  {}

    virtual double vertexChi2() const GCC11_FINAL  { return 0.; }
    virtual double vertexNdof() const GCC11_FINAL  { return 0.; }
    virtual double vertexNormalizedChi2() const GCC11_FINAL  { return 0.; }
    virtual double vertexCovariance(int i, int j) const GCC11_FINAL  { return 0.; }
    virtual void fillVertexCovariance(CovarianceMatrix & v) const GCC11_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