---

Candidate.h

Go to the documentation of this file.

#ifndef Candidate_Candidate_h
#define Candidate_Candidate_h

#include "DataFormats/Candidate/interface/Particle.h"
#include "DataFormats/Candidate/interface/component.h"
#include "DataFormats/Candidate/interface/const_iterator.h"
#include "DataFormats/Candidate/interface/iterator.h"
#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "DataFormats/Math/interface/Error.h"
#include "boost/iterator/filter_iterator.hpp"

class OverlapChecker;

namespace reco {
  
  class Candidate : public Particle {
  public:
    typedef size_t size_type;
    typedef candidate::const_iterator const_iterator;
    typedef candidate::iterator iterator;
    enum { dimension = 3 };
    typedef math::Error<dimension>::type CovarianceMatrix;
    enum { size = dimension * (dimension + 1)/2 };
    typedef unsigned int index;
    Candidate() : Particle() { }
    explicit Candidate( const Particle & p ) : Particle( p ) { }
    Candidate( Charge q, const LorentzVector & p4, const Point & vtx = Point( 0, 0, 0 ),
               int pdgId = 0, int status = 0, bool integerCharge = true ) : 
      Particle( q, p4, vtx, pdgId, status, integerCharge ) { }
    Candidate( Charge q, const PolarLorentzVector & p4, const Point & vtx = Point( 0, 0, 0 ),
               int pdgId = 0, int status = 0, bool integerCharge = true ) : 
      Particle( q, p4, vtx, pdgId, status, integerCharge ) { }
    virtual ~Candidate();
    virtual Candidate * clone() const = 0;
    virtual const_iterator begin() const = 0;
    virtual const_iterator end() const = 0;
    virtual iterator begin() = 0;
    virtual iterator end() = 0;
    virtual size_type numberOfDaughters() const = 0;
    virtual const Candidate * daughter( size_type i ) const = 0;
    virtual Candidate * daughter( size_type i ) = 0;
    virtual Candidate * daughter(const std::string& s );
    virtual const Candidate * daughter(const std::string& s ) const;
    virtual size_type numberOfMothers() const = 0;
    virtual const Candidate * mother( size_type i = 0 ) const = 0;
    virtual size_t numberOfSourceCandidatePtrs() const { return 0;}
    virtual CandidatePtr sourceCandidatePtr( size_type i ) const {
      return CandidatePtr();
    }
    virtual double vertexChi2() const;
    virtual double vertexNdof() const;
    virtual double vertexNormalizedChi2() const;
    virtual double vertexCovariance(int i, int j) const;
    CovarianceMatrix vertexCovariance() const { 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 ); 
    }

    template<typename S> 
    struct daughter_iterator {
      typedef boost::filter_iterator<S, const_iterator> type;
    };

    template<typename S>
    typename daughter_iterator<S>::type beginFilter( const S & s ) const {
      return boost::make_filter_iterator(s, begin(), end());
    }
    template<typename S>
    typename daughter_iterator<S>::type endFilter( const S & s ) const {
      return boost::make_filter_iterator(s, end(), end());
    }

    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:
    virtual bool overlap( const Candidate & ) const = 0;
    template<typename, typename, typename> friend struct component; 
    friend class ::OverlapChecker;
    friend class ShallowCloneCandidate;
    friend class ShallowClonePtrCandidate;
  };

}

#endif

---