DataFormats/Candidate/interface/Candidate.h - master - githubmirror/cmssw

DataFormats/Candidate/interface/Candidate.h
315 строк12 KB
Matti Kortelainen
Move stored types in io_v1 namespace, reset class versions to 3
22 май 2026, 18:18
22 май 2026, 18:18909f324
#ifndef Candidate_Candidate_h
#define Candidate_Candidate_h
/** \class reco::Candidate
 *
 * abstract interface for physics objects
 *
 * \author Luca Lista (INFN), Benedikt Hegner (CERN)
 *
 *
 */
#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 "DataFormats/TrackReco/interface/TrackFwd.h"

#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"

class OverlapChecker;

namespace reco {
  class ShallowCloneCandidate;
  class ShallowClonePtrCandidate;
  namespace io_v1 {
    class Candidate {
    public:
      typedef size_t size_type;
      typedef candidate::const_iterator const_iterator;
      typedef candidate::iterator iterator;

      /// electric charge type
      typedef int Charge;
      /// Lorentz vector
      typedef math::XYZTLorentzVector LorentzVector;
      /// Lorentz vector
      typedef math::PtEtaPhiMLorentzVector PolarLorentzVector;
      /// point in the space
      typedef math::XYZPoint Point;
      /// point in the space
      typedef math::XYZVector Vector;

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

      /// default constructor
      Candidate() {}
      /// destructor
      virtual ~Candidate();
      /// electric charge
      virtual int charge() const = 0;
      /// set electric charge
      virtual void setCharge(Charge q) = 0;
      /// electric charge
      virtual int threeCharge() const = 0;
      /// set electric charge
      virtual void setThreeCharge(Charge qx3) = 0;
      /// four-momentum Lorentz vector
      virtual const LorentzVector& p4() const = 0;
      /// four-momentum Lorentz vector
      virtual const PolarLorentzVector& polarP4() const = 0;
      /// spatial momentum vector
      virtual Vector momentum() const = 0;
      /// boost vector to boost a Lorentz vector
      /// to the particle center of mass system
      virtual Vector boostToCM() const = 0;
      /// magnitude of momentum vector
      virtual double p() const = 0;
      /// energy
      virtual double energy() const = 0;
      /// transverse energy
      virtual double et() const = 0;
      /// transverse energy squared (use this for cut!)
      virtual double et2() const = 0;
      /// mass
      virtual double mass() const = 0;
      /// mass squared
      virtual double massSqr() const = 0;
      /// transverse mass
      virtual double mt() const = 0;
      /// transverse mass squared
      virtual double mtSqr() const = 0;
      /// x coordinate of momentum vector
      virtual double px() const = 0;
      /// y coordinate of momentum vector
      virtual double py() const = 0;
      /// z coordinate of momentum vector
      virtual double pz() const = 0;
      /// transverse momentum
      virtual double pt() const = 0;
      /// momentum azimuthal angle
      virtual double phi() const = 0;
      /// momentum polar angle
      virtual double theta() const = 0;
      /// momentum pseudorapidity
      virtual double eta() const = 0;
      /// rapidity
      virtual double rapidity() const = 0;
      /// rapidity
      virtual double y() const = 0;
      /// set 4-momentum
      virtual void setP4(const LorentzVector& p4) = 0;
      /// set 4-momentum
      virtual void setP4(const PolarLorentzVector& p4) = 0;
      /// set particle mass
      virtual void setMass(double m) = 0;
      virtual void setPz(double pz) = 0;
      /// vertex position
      virtual const Point& vertex() const = 0;
      /// x coordinate of vertex position
      virtual double vx() const = 0;
      /// y coordinate of vertex position
      virtual double vy() const = 0;
      /// z coordinate of vertex position
      virtual double vz() const = 0;
      /// set vertex
      virtual void setVertex(const Point& vertex) = 0;
      /// PDG identifier
      virtual int pdgId() const = 0;
      // set PDG identifier
      virtual void setPdgId(int pdgId) = 0;
      /// status word
      virtual int status() const = 0;
      /// set status word
      virtual void setStatus(int status) = 0;
      /// set long lived flag
      virtual void setLongLived() = 0;
      /// is long lived?
      virtual bool longLived() const = 0;
      /// set mass constraint flag
      virtual void setMassConstraint() = 0;
      /// do mass constraint?
      virtual bool massConstraint() const = 0;
      /// returns a clone of the Candidate object
      virtual Candidate* clone() const = 0;
      /// first daughter const_iterator
      const_iterator begin() const { return const_iterator(this, 0); }
      /// last daughter const_iterator
      const_iterator end() const { return const_iterator(this, numberOfDaughters()); }
      /// first daughter iterator
      iterator begin() { return iterator(this, 0); }
      /// last daughter iterator
      iterator end() { return iterator(this, numberOfDaughters()); }
      /// number of daughters
      virtual size_type numberOfDaughters() const = 0;
      /// return daughter at a given position, i = 0, ... numberOfDaughters() - 1 (read only mode)
      virtual const Candidate* daughter(size_type i) const = 0;
      /// return daughter at a given position, i = 0, ... numberOfDaughters() - 1
      virtual Candidate* daughter(size_type i) = 0;
      /// return daughter with a specified role name
      virtual Candidate* daughter(const std::string& s) = 0;
      /// return daughter with a specified role name
      virtual const Candidate* daughter(const std::string& s) const = 0;
      /// number of mothers (zero or one in most of but not all the cases)
      virtual size_type numberOfMothers() const = 0;
      /// return pointer to mother
      virtual const Candidate* mother(size_type i = 0) const = 0;
      /// return the number of source Candidates
      /// ( the candidates used to construct this Candidate)
      virtual size_t numberOfSourceCandidatePtrs() const = 0;
      /// return a Ptr to one of the source Candidates
      /// ( the candidates used to construct this Candidate)
      virtual CandidatePtr sourceCandidatePtr(size_type i) const { return CandidatePtr(); }
      /// \brief Set the ptr to the source Candidate.
      ///
      /// necessary, to allow a parallel treatment of all candidates
      /// in PF2PAT. Does nothing for most Candidate classes, including
      /// CompositePtrCandidates, where the source information is in fact
      /// the collection of ptrs to daughters. For non-Composite Candidates,
      /// this function can be used to set the ptr to the source of the
      /// Candidate, which will allow to keep track
      /// of the reconstruction history.
      virtual void setSourceCandidatePtr(const CandidatePtr& ptr) {}

      /// chi-squares
      virtual double vertexChi2() const = 0;
      /** Number of degrees of freedom
     *  Meant to be Double32_t for soft-assignment fitters: 
     *  tracks may contribute to the vertex with fractional weights.
     *  The ndof is then = to the sum of the track weights.
     *  see e.g. CMS NOTE-2006/032, CMS NOTE-2004/002
     */
      virtual double vertexNdof() const = 0;
      /// chi-squared divided by n.d.o.f.
      virtual double vertexNormalizedChi2() const = 0;
      /// (i, j)-th element of error matrix, i, j = 0, ... 2
      virtual double vertexCovariance(int i, int j) const = 0;
      /// fill SMatrix
      virtual CovarianceMatrix vertexCovariance() const {
        CovarianceMatrix m;
        fillVertexCovariance(m);
        return m;
      }  //TODO
      virtual void fillVertexCovariance(CovarianceMatrix& v) const = 0;
      /// returns true if this candidate has a reference to a master clone.
      /// This only happens if the concrete Candidate type is ShallowCloneCandidate
      virtual bool hasMasterClone() const = 0;
      /// returns ptr to master clone, if existing.
      /// Throws an exception unless the concrete Candidate type is ShallowCloneCandidate
      virtual const CandidateBaseRef& masterClone() const = 0;
      /// returns true if this candidate has a ptr to a master clone.
      /// This only happens if the concrete Candidate type is ShallowClonePtrCandidate
      virtual bool hasMasterClonePtr() const = 0;
      /// returns ptr to master clone, if existing.
      /// Throws an exception unless the concrete Candidate type is ShallowClonePtrCandidate
      virtual const CandidatePtr& masterClonePtr() const = 0;
      /// cast master clone reference to a concrete type
      template <typename Ref>
      Ref masterRef() const {
        return masterClone().template castTo<Ref>();
      }
      /// get a component

      template <typename T>
      T get() const {
        if (hasMasterClone())
          return masterClone()->get<T>();
        else
          return reco::get<T>(*this);
      }
      /// get a component
      template <typename T, typename Tag>
      T get() const {
        if (hasMasterClone())
          return masterClone()->get<T, Tag>();
        else
          return reco::get<T, Tag>(*this);
      }
      /// get a component
      template <typename T>
      T get(size_type i) const {
        if (hasMasterClone())
          return masterClone()->get<T>(i);
        else
          return reco::get<T>(*this, i);
      }
      /// get a component
      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);
      }
      /// number of components
      template <typename T>
      size_type numberOf() const {
        if (hasMasterClone())
          return masterClone()->numberOf<T>();
        else
          return reco::numberOf<T>(*this);
      }
      /// number of components
      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; }

      /// uncertainty on dz
      virtual float dzError() const {
        return 0;
      }  // { const Track * tr=bestTrack(); if(tr!=nullptr) return tr->dzError(); else return 0; }
      /// uncertainty on dxy
      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:
      /// check overlap with another Candidate
      virtual bool overlap(const Candidate&) const = 0;
      template <typename, typename, typename>
      friend struct component;
      friend class ::OverlapChecker;
      friend class reco::ShallowCloneCandidate;
      friend class reco::ShallowClonePtrCandidate;
    };

  }  // namespace io_v1

  using Candidate = io_v1::Candidate;

  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