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/Math/interface/Error.h"

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

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

#include "FWCore/Utilities/interface/GCC11Compatibility.h"
#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"

class OverlapChecker;

namespace reco {
  class Track;
  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 double et2() const = 0;
    virtual double mass() const = 0;
    virtual double 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 double pt() const = 0;
    virtual double phi() const = 0;
    virtual double theta() const = 0;
    virtual double 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;
    const_iterator begin() const { return const_iterator(this, 0); }
    const_iterator end() const { return const_iterator(this, numberOfDaughters()); }
    iterator begin() { return iterator(this, 0); }
    iterator end() { return iterator(this, numberOfDaughters()); }
    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);
    }

    virtual const Track* bestTrack() const { return nullptr; }

    virtual float dzError() const {
      return 0;
    }  // { const Track * tr=bestTrack(); if(tr!=nullptr) return tr->dzError(); else return 0; }
    virtual float dxyError() const {
      return 0;
    }  // { const Track * tr=bestTrack(); if(tr!=nullptr) return tr->dxyError(); else return 0; }

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

  namespace candidate {

    const_iterator::reference const_iterator::operator*() const { return *(me->daughter(i)); }
    iterator::reference iterator::operator*() const { return *(me->daughter(i)); }

  }  // namespace candidate

}  // namespace reco

#endif