Candidate.h

Go to the documentation of this file.

#ifndef Candidate_Candidate_h
#define Candidate_Candidate_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"

#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "Rtypes.h"

#include "DataFormats/Candidate/interface/Particle.h"

#include "FWCore/Utilities/interface/GCC11Compatibility.h"


class OverlapChecker;

namespace reco {
  
  class Candidate {
  public:
    typedef size_t size_type;
    typedef candidate::const_iterator const_iterator;
    typedef candidate::iterator iterator;
 
    typedef int Charge;
    typedef math::XYZTLorentzVector LorentzVector;
    typedef math::PtEtaPhiMLorentzVector PolarLorentzVector;
    typedef math::XYZPoint Point;
    typedef math::XYZVector Vector;

    enum { dimension = 3 };
    typedef math::Error<dimension>::type CovarianceMatrix;
    enum { size = dimension * (dimension + 1)/2 };
    typedef unsigned int index;

    Candidate() {};
    virtual ~Candidate();
    virtual int charge() const = 0;
    virtual void setCharge( Charge q ) = 0;
    virtual int threeCharge() const = 0;
    virtual void setThreeCharge( Charge qx3 ) = 0;
    virtual const LorentzVector & p4() const = 0;
    virtual const PolarLorentzVector & polarP4() const = 0;
    virtual Vector momentum() const = 0;
    virtual Vector boostToCM() const = 0;
    virtual double p() const = 0;
    virtual double energy() const = 0;
    virtual double et() const = 0;
    virtual float mass() const = 0;
    virtual float massSqr() const = 0;
    virtual double mt() const = 0;
    virtual double mtSqr() const = 0;
    virtual double px() const = 0;
    virtual double py() const = 0;
    virtual double pz() const = 0;
    virtual float pt() const = 0;
    virtual float phi() const = 0;
    virtual double theta() const = 0;
    virtual float eta() const = 0;
    virtual double rapidity() const = 0;
    virtual double y() const = 0;
    virtual void setP4( const LorentzVector & p4 ) = 0;
    virtual void setP4( const PolarLorentzVector & p4 )  = 0;
    virtual void setMass( double m )  = 0;
    virtual void setPz( double pz )  = 0;
    virtual const Point & vertex() const  = 0;
    virtual double vx() const  = 0;
    virtual double vy() const  = 0;
    virtual double vz() const  = 0;
    virtual void setVertex( const Point & vertex )  = 0;
    virtual int pdgId() const  = 0;
    // set PDG identifier
    virtual void setPdgId( int pdgId )  = 0;
    virtual int status() const  = 0;
    virtual void setStatus( int status )  = 0;
    virtual void setLongLived()  = 0;
    virtual bool longLived() const  = 0;
    virtual void setMassConstraint() = 0;
    virtual bool massConstraint() const = 0;
    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 ) = 0;
    virtual const Candidate * daughter(const std::string& s ) const = 0;
    virtual size_type numberOfMothers() const = 0;
    virtual const Candidate * mother( size_type i = 0 ) const = 0;
    virtual size_t numberOfSourceCandidatePtrs() const  = 0;
    virtual CandidatePtr sourceCandidatePtr( size_type i ) const {
      return CandidatePtr();
    }
    virtual void setSourceCandidatePtr( const CandidatePtr& ptr ) {};

    virtual double vertexChi2() const = 0;
    virtual double vertexNdof() const = 0;
    virtual double vertexNormalizedChi2() const = 0;
    virtual double vertexCovariance(int i, int j) const = 0;
    virtual CovarianceMatrix vertexCovariance() const { CovarianceMatrix m; fillVertexCovariance(m); return m; }  //TODO
    virtual void fillVertexCovariance(CovarianceMatrix & v) const = 0;
    virtual bool hasMasterClone() const = 0;
    virtual const CandidateBaseRef & masterClone() const = 0;
    virtual bool hasMasterClonePtr() const = 0;
    virtual const CandidatePtr & masterClonePtr() const = 0;
    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 = 0;
    virtual bool isMuon() const = 0;
    virtual bool isStandAloneMuon() const = 0;
    virtual bool isGlobalMuon() const = 0;
    virtual bool isTrackerMuon() const = 0;
    virtual bool isCaloMuon() const = 0;
    virtual bool isPhoton() const = 0;
    virtual bool isConvertedPhoton() const = 0;
    virtual bool isJet() const = 0;

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

  };

}

#endif