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

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

    virtual int charge() const GCC11_FINAL { return m_state.charge(); }
    virtual void setCharge( Charge q ) GCC11_FINAL { m_state.setCharge(q); }
    virtual int threeCharge() const GCC11_FINAL { return m_state.threeCharge(); }
    virtual void setThreeCharge( Charge qx3 ) GCC11_FINAL {m_state.setThreeCharge(qx3); }
    virtual const LorentzVector & p4() const GCC11_FINAL { return m_state.p4(); }
    virtual const PolarLorentzVector & polarP4() const GCC11_FINAL { return m_state.polarP4(); }
    virtual Vector momentum() const GCC11_FINAL { return m_state.momentum(); }
    virtual Vector boostToCM() const GCC11_FINAL { return m_state.boostToCM(); }
    virtual double p() const GCC11_FINAL { return m_state.p(); }
    virtual double energy() const GCC11_FINAL { return m_state.energy(); }
    virtual double et() const GCC11_FINAL { return m_state.et(); }
    virtual double et2() const GCC11_FINAL { return m_state.et2(); }
    virtual double mass() const GCC11_FINAL { return m_state.mass(); }
    virtual double massSqr() const GCC11_FINAL { return mass() * mass(); }

    virtual double mt() const GCC11_FINAL  { return m_state.mt(); }
    virtual double mtSqr() const GCC11_FINAL  { return m_state.mtSqr(); }
    virtual double px() const GCC11_FINAL  {  return m_state.px(); }
    virtual double py() const GCC11_FINAL  { return m_state.py(); }
    virtual double pz() const GCC11_FINAL  {  return m_state.pz(); }
    virtual double pt() const GCC11_FINAL  { return m_state.pt();}
    virtual double phi() const GCC11_FINAL  { return m_state.phi(); }
    virtual double theta() const GCC11_FINAL  {  return m_state.theta(); }
    virtual  double eta() const GCC11_FINAL  { return m_state.eta(); }
    virtual double rapidity() const GCC11_FINAL  {  return m_state.rapidity(); }
    virtual double y() const GCC11_FINAL  { return rapidity(); }
    virtual void setP4( const LorentzVector & p4 ) GCC11_FINAL  { m_state.setP4(p4);}
    virtual void setP4( const PolarLorentzVector & p4 ) GCC11_FINAL  {m_state.setP4(p4); }
    virtual void setMass( double m ) GCC11_FINAL  {m_state.setMass(m);}
    virtual void setPz( double pz ) GCC11_FINAL  { m_state.setPz(pz);}
    virtual const Point & vertex() const { return m_state.vertex(); }
    virtual double vx() const  { return m_state.vx(); }
    virtual double vy() const  { return m_state.vy(); }
    virtual double vz() const  { return m_state.vz(); }
    virtual void setVertex( const Point & vertex )   { m_state.setVertex(vertex); }

    virtual int pdgId() const GCC11_FINAL  { return m_state.pdgId(); }
    // set PDG identifier                                                                 
    virtual void setPdgId( int pdgId ) GCC11_FINAL  { m_state.setPdgId(pdgId); }
    virtual int status() const GCC11_FINAL  { return m_state.status(); }
    virtual void setStatus( int status ) GCC11_FINAL  { m_state.setStatus(status); }
    virtual void setLongLived() GCC11_FINAL  { m_state.setLongLived(); }
    virtual bool longLived() const GCC11_FINAL  { return m_state.longLived(); }
    virtual void setMassConstraint() GCC11_FINAL  { m_state.setMassConstraint();}
    virtual bool massConstraint() const GCC11_FINAL  { return m_state.massConstraint(); }

    virtual LeafCandidate * clone() const  {
      return new LeafCandidate( *this );
    }

    virtual double vertexChi2() const;
    virtual double vertexNdof() const;
    virtual double vertexNormalizedChi2() const;
    virtual double vertexCovariance(int i, int j) const;
    CovarianceMatrix vertexCovariance() const GCC11_FINAL  { CovarianceMatrix m; fillVertexCovariance(m); return m; }
    virtual void fillVertexCovariance(CovarianceMatrix & v) const;
    virtual bool hasMasterClone() const;
    virtual const CandidateBaseRef & masterClone() const;
    virtual bool hasMasterClonePtr() const;
    virtual const CandidatePtr & masterClonePtr() const;

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



    virtual bool isElectron() const;
    virtual bool isMuon() const;
    virtual bool isStandAloneMuon() const;
    virtual bool isGlobalMuon() const;
    virtual bool isTrackerMuon() const;
    virtual bool isCaloMuon() const;
    virtual bool isPhoton() const;
    virtual bool isConvertedPhoton() const;
    virtual bool isJet() const;

  private:
    ParticleState m_state;

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

  };

}

#endif