reco::PFCandidate Class Reference

Particle reconstructed by the particle flow algorithm. More...

#include <PFCandidate.h>

Inheritance diagram for reco::PFCandidate:

Public Types
typedef edm::RefVector< reco::PFBlockCollection >	Blocks
typedef std::pair< reco::PFBlockRef, unsigned >	ElementInBlock
	return indices of elements used in the block More...
typedef std::vector< unsigned >	Elements
typedef std::vector< ElementInBlock >	ElementsInBlocks
enum	Flags {   NORMAL = 0, E_PHI_SMODULES, E_ETA_0, E_ETA_MODULES,   E_BARREL_ENDCAP, E_PRESHOWER_EDGE, E_PRESHOWER, E_ENDCAP_EDGE,   H_ETA_0, H_BARREL_ENDCAP, H_ENDCAP_VFCAL, H_VFCAL_EDGE,   T_TO_DISP, T_FROM_DISP, T_FROM_V0, T_FROM_GAMMACONV,   GAMMA_TO_GAMMACONV }
enum	ParticleType {   X = 0, h, e, mu,   gamma, h0, h_HF, egamma_HF }
	particle types More...
enum	PFVertexType {   kCandVertex = 0, kTrkVertex = 1, kComMuonVertex = 2, kSAMuonVertex = 3,   kTrkMuonVertex = 4, kGSFVertex = 5, kTPFMSMuonVertex = 6, kPickyMuonVertex = 7,   kDYTMuonVertex = 8 }
Public Types inherited from reco::CompositeCandidate
typedef CandidateCollection	daughters
	collection of daughters More...
typedef std::vector< std::string >	role_collection
Public Types inherited from reco::LeafCandidate
typedef int	Charge
	electric charge type More...
typedef CandidateCollection	daughters
	collection of daughter candidates More...
typedef unsigned int	index
typedef math::XYZTLorentzVector	LorentzVector
	Lorentz vector. More...
typedef math::XYZPoint	Point
	point in the space More...
typedef math::PtEtaPhiMLorentzVector	PolarLorentzVector
	Lorentz vector. More...
typedef math::XYZVector	Vector
	point in the space More...
Public Types inherited from reco::Candidate
enum	{ dimension = 3 }
enum	{ size = dimension * (dimension + 1) / 2 }
	matix size More...
typedef int	Charge
	electric charge type More...
typedef candidate::const_iterator	const_iterator
typedef math::Error< dimension >::type	CovarianceMatrix
	covariance error matrix (3x3) More...
typedef unsigned int	index
	index type More...
typedef candidate::iterator	iterator
typedef math::XYZTLorentzVector	LorentzVector
	Lorentz vector. More...
typedef math::XYZPoint	Point
	point in the space More...
typedef math::PtEtaPhiMLorentzVector	PolarLorentzVector
	Lorentz vector. More...
typedef size_t	size_type
typedef math::XYZVector	Vector
	point in the space More...

Public Member Functions
void	addElementInBlock (const reco::PFBlockRef &blockref, unsigned elementIndex)
	add an element to the current PFCandidate More...
const reco::Muon::MuonTrackType	bestMuonTrackType () const
	get the Best Muon Track Ref More...
const reco::Track *	bestTrack () const override
PFCandidate *	clone () const override
	return a clone More...
reco::ConversionRef	conversionRef () const
	return a reference to the original conversion More...
double	deltaP () const
	uncertainty on 3-momentum More...
reco::PFDisplacedVertexRef	displacedVertexRef (Flags type) const
float	dnn_e_bkgNonIsolated () const
float	dnn_e_bkgPhoton () const
float	dnn_e_bkgTau () const
float	dnn_e_sigIsolated () const
float	dnn_e_sigNonIsolated () const
float	dnn_gamma () const
float	dxyError () const override
	uncertainty on dxy More...
float	dzError () const override
	uncertainty on dz More...
double	ecalEnergy () const
	return corrected Ecal energy More...
reco::PFCandidateEGammaExtraRef	egammaExtraRef () const
	return a reference to the EGamma extra More...
reco::PFCandidateElectronExtraRef	electronExtraRef () const
	return a reference to the electron extra More...
const ElementsInBlocks &	elementsInBlocks () const
bool	flag (Flags theFlag) const
	return a given flag More...
reco::GsfElectronRef	gsfElectronRef () const
	return a reference to the corresponding GsfElectron if any More...
reco::GsfTrackRef	gsfTrackRef () const
float	hcalDepthEnergyFraction (unsigned int depth) const
	fraction of hcal energy at a given depth (depth = 1 .. 7) More...
const std::array< float, 7 > &	hcalDepthEnergyFractions () const
	fraction of hcal energy at a given depth (index 0..6 for depth 1..7) More...
double	hcalEnergy () const
	return corrected Hcal energy More...
double	hoEnergy () const
	return corrected Hcal energy More...
bool	isTimeValid () const
	do we have a valid time information More...
reco::MuonRef	muonRef () const
float	mva_e_mu () const
	mva for electron-muon discrimination More...
float	mva_e_pi () const
	mva for electron-pion discrimination More...
float	mva_gamma_nh () const
	mva for neutral hadron - gamma discrimination More...
float	mva_Isolated () const
float	mva_nothing_gamma () const
	mva for gamma detection More...
float	mva_nothing_nh () const
	mva for neutral hadron detection More...
float	mva_pi_mu () const
	mva for pi-muon discrimination More...
size_t	numberOfSourceCandidatePtrs () const override
PFCandidate &	operator= (PFCandidate const &)
virtual ParticleType	particleId () const
	PFCandidate ()
	default constructor More...
	PFCandidate (const PFCandidatePtr &sourcePtr)
	constructor from a reference (keeps track of source relationship) More...
	PFCandidate (Charge q, const LorentzVector &p4, ParticleType particleId)
	PFCandidate (const PFCandidate &)
	copy constructor More...
reco::PFCandidatePhotonExtraRef	photonExtraRef () const
	return a reference to the photon extra More...
reco::PhotonRef	photonRef () const
	return a reference to the corresponding Photon if any More...
const math::XYZPointF &	positionAtECALEntrance () const
double	pS1Energy () const
	return corrected PS1 energy More...
double	pS2Energy () const
	return corrected PS2 energy More...
double	rawEcalEnergy () const
	return corrected Ecal energy More...
double	rawHcalEnergy () const
	return raw Hcal energy More...
double	rawHoEnergy () const
	return raw Hcal energy More...
void	rescaleMomentum (double rescaleFactor)
	particle momentum *= rescaleFactor More...
void	set_dnn_e_bkgNonIsolated (float mva)
void	set_dnn_e_bkgPhoton (float mva)
void	set_dnn_e_bkgTau (float mva)
void	set_dnn_e_sigIsolated (float mva)
void	set_dnn_e_sigNonIsolated (float mva)
void	set_dnn_gamma (float mva)
void	set_mva_e_mu (float mva)
	set mva for electron-muon discrimination More...
void	set_mva_e_pi (float mvaNI)
void	set_mva_gamma_nh (float mva)
	set mva for neutral hadron - gamma discrimination More...
void	set_mva_Isolated (float mvaI)
void	set_mva_nothing_gamma (float mva)
	set mva for gamma detection More...
void	set_mva_nothing_nh (float mva)
	set mva for neutral hadron detection More...
void	set_mva_pi_mu (float mva)
	set mva for pi-muon discrimination More...
void	setConversionRef (const reco::ConversionRef &ref)
	set ref to original reco conversion More...
void	setDeltaP (double dp)
	set uncertainty on momentum More...
void	setDisplacedVertexRef (const reco::PFDisplacedVertexRef &ref, Flags flag)
	set displaced vertex reference More...
void	setEcalEnergy (float eeRaw, float eeCorr)
	set corrected Ecal energy More...
void	setFlag (Flags theFlag, bool value)
	set a given flag More...
void	setGsfElectronRef (const reco::GsfElectronRef &ref)
	set GsfElectronRef More...
void	setGsfTrackRef (const reco::GsfTrackRef &ref)
	set gsftrack reference More...
void	setHcalDepthEnergyFractions (const std::array< float, 7 > &fracs)
	set the fraction of hcal energy as function of depth (index 0..6 for depth 1..7) More...
void	setHcalEnergy (float ehRaw, float ehCorr)
	set corrected Hcal energy More...
void	setHoEnergy (float eoRaw, float eoCorr)
	set corrected Hcal energy More...
void	setMuonRef (const reco::MuonRef &ref)
	set muon reference More...
void	setMuonTrackType (const reco::Muon::MuonTrackType &type)
	set the Best Muon Track Ref More...
void	setParticleType (ParticleType type)
	set Particle Type More...
void	setPFEGammaExtraRef (const reco::PFCandidateEGammaExtraRef &ref)
	set the PF EGamma Extra Ref More...
void	setPFElectronExtraRef (const reco::PFCandidateElectronExtraRef &ref)
	set the PF Electron Extra Ref More...
void	setPFPhotonExtraRef (const reco::PFCandidatePhotonExtraRef &ref)
	set the PF Photon Extra Ref More...
void	setPhotonRef (const reco::PhotonRef &phRef)
	set ref to the corresponding reco::Photon if any More...
void	setPositionAtECALEntrance (const math::XYZPointF &pos)
	set position at ECAL entrance More...
void	setPs1Energy (float e1)
	set corrected PS1 energy More...
void	setPs2Energy (float e2)
	set corrected PS2 energy More...
void	setSourceCandidatePtr (const PFCandidatePtr &ptr)
void	setSuperClusterRef (const reco::SuperClusterRef &scRef)
void	setTime (float time, float timeError=0.f)
	the timing information More...
void	setTrackRef (const reco::TrackRef &ref)
	set track reference More...
void	setV0Ref (const reco::VertexCompositeCandidateRef &ref)
	set ref to original reco conversion More...
CandidatePtr	sourceCandidatePtr (size_type i) const override
reco::SuperClusterRef	superClusterRef () const
	return a reference to the corresponding SuperCluster if any More...
float	time () const
float	timeError () const
reco::TrackRef	trackRef () const
ParticleType	translatePdgIdToType (int pdgid) const
int	translateTypeToPdgId (ParticleType type) const
reco::VertexCompositeCandidateRef	v0Ref () const
	return a reference to the original conversion More...
const Point &	vertex () const override
	vertex position (overwritten by PF...) More...
double	vx () const override
	x coordinate of vertex position More...
double	vy () const override
	y coordinate of vertex position More...
double	vz () const override
	z coordinate of vertex position More...
	~PFCandidate () override
	destructor More...
Public Member Functions inherited from reco::CompositeCandidate
void	addDaughter (const Candidate &, const std::string &s="")
	add a clone of the passed candidate as daughter More...
void	addDaughter (std::unique_ptr< Candidate >, const std::string &s="")
	add a clone of the passed candidate as daughter More...
void	applyRoles ()
void	clearDaughters ()
	clear daughters More...
void	clearRoles ()
	CompositeCandidate (std::string name="")
	default constructor More...
template<typename P4 >
	CompositeCandidate (Charge q, const P4 &p4, const Point &vtx=Point(0, 0, 0), int pdgId=0, int status=0, bool integerCharge=true, std::string name="")
	constructor from values More...
	CompositeCandidate (const Candidate &p, const std::string &name="")
	constructor from values More...
	CompositeCandidate (const Candidate &p, const std::string &name, role_collection const &roles)
	constructor from values More...
const Candidate *	daughter (size_type) const override
	return daughter at a given position, i = 0, ... numberOfDaughters() - 1 (read only mode) More...
Candidate *	daughter (size_type) override
	return daughter at a given position, i = 0, ... numberOfDaughters() - 1 More...
Candidate *	daughter (const std::string &s) override
	return daughter with a specified role name More...
const Candidate *	daughter (const std::string &s) const override
	return daughter with a specified role name More...
const Candidate *	mother (size_type i=0) const override
	return pointer to mother More...
std::string	name () const
	get the name of the candidate More...
size_type	numberOfDaughters () const override
	number of daughters More...
size_type	numberOfMothers () const override
	number of mothers (zero or one in most of but not all the cases) More...
role_collection const &	roles () const
	get the roles More...
void	setName (std::string name)
	set the name of the candidate More...
void	setRoles (const role_collection &roles)
	set the roles More...
	~CompositeCandidate () override
	destructor More...
Public Member Functions inherited from reco::LeafCandidate
Vector	boostToCM () const final
int	charge () const final
	electric charge More...
void	construct (int qx3, float pt, float eta, float phi, float mass, const Point &vtx, int pdgId, int status)
const Candidate *	daughter (size_type) const override
	return daughter at a given position (throws an exception) More...
Candidate *	daughter (size_type) override
	return daughter at a given position (throws an exception) More...
Candidate *	daughter (const std::string &s) override
	return daughter with a specified role name More...
const Candidate *	daughter (const std::string &s) const override
	return daughter with a specified role name More...
double	energy () const final
	energy More...
double	et () const final
	transverse energy More...
double	et2 () const final
	transverse energy squared (use this for cut!) More...
double	eta () const final
	momentum pseudorapidity More...
void	fillVertexCovariance (CovarianceMatrix &v) const override
	fill SMatrix More...
template<typename T >
T	get () const
	get a component More...
template<typename T , typename Tag >
T	get () const
	get a component More...
template<typename T >
T	get (size_type i) const
	get a component More...
template<typename T , typename Tag >
T	get (size_type i) const
	get a component More...
bool	hasMasterClone () const override
bool	hasMasterClonePtr () const override
bool	isCaloMuon () const override
bool	isConvertedPhoton () const override
bool	isElectron () const override
bool	isGlobalMuon () const override
bool	isJet () const override
bool	isMuon () const override
bool	isPhoton () const override
bool	isStandAloneMuon () const override
bool	isTrackerMuon () const override
	LeafCandidate ()
	LeafCandidate (const Candidate &c)
template<typename... Args>
	LeafCandidate (Args &&... args)
	LeafCandidate (LeafCandidate &rh)
	LeafCandidate (LeafCandidate &&)=default
	LeafCandidate (LeafCandidate const &)=default
bool	longLived () const final
	is long lived? More...
double	mass () const final
	mass More...
bool	massConstraint () const final
	do mass constraint? More...
double	massSqr () const final
	mass squared More...
const CandidateBaseRef &	masterClone () const override
const CandidatePtr &	masterClonePtr () const override
template<typename Ref >
Ref	masterRef () const
	cast master clone reference to a concrete type More...
Vector	momentum () const final
	spatial momentum vector More...
const Candidate *	mother (size_type) const override
	return mother at a given position (throws an exception) More...
double	mt () const final
	transverse mass More...
double	mtSqr () const final
	transverse mass squared More...
template<typename T >
size_type	numberOf () const
	number of components More...
template<typename T , typename Tag >
size_type	numberOf () const
	number of components More...
size_t	numberOfDaughters () const override
	number of daughters More...
size_t	numberOfMothers () const override
	number of mothers More...
LeafCandidate &	operator= (LeafCandidate &&)=default
LeafCandidate &	operator= (LeafCandidate const &)=default
double	p () const final
	magnitude of momentum vector More...
const LorentzVector &	p4 () const final
	four-momentum Lorentz vector More...
int	pdgId () const final
	PDG identifier. More...
double	phi () const final
	momentum azimuthal angle More...
const PolarLorentzVector &	polarP4 () const final
	four-momentum Lorentz vector More...
double	pt () const final
	transverse momentum More...
double	px () const final
	x coordinate of momentum vector More...
double	py () const final
	y coordinate of momentum vector More...
double	pz () const final
	z coordinate of momentum vector More...
double	rapidity () const final
	rapidity More...
void	setCharge (Charge q) final
	set electric charge More...
void	setLongLived () final
void	setMass (double m) final
	set particle mass More...
void	setMassConstraint () final
void	setP4 (const LorentzVector &p4) final
	set 4-momentum More...
void	setP4 (const PolarLorentzVector &p4) final
	set 4-momentum More...
void	setPdgId (int pdgId) final
void	setPz (double pz) final
void	setStatus (int status) final
	set status word More...
void	setThreeCharge (Charge qx3) final
	set electric charge More...
void	setVertex (const Point &vertex) override
	set vertex More...
int	status () const final
	status word More...
double	theta () const final
	momentum polar angle More...
int	threeCharge () const final
	electric charge More...
double	vertexChi2 () const override
	chi-squares More...
double	vertexCovariance (int i, int j) const override
	(i, j)-th element of error matrix, i, j = 0, ... 2 More...
CovarianceMatrix	vertexCovariance () const final
	return SMatrix More...
double	vertexNdof () const override
double	vertexNormalizedChi2 () const override
	chi-squared divided by n.d.o.f. More...
double	y () const final
	rapidity More...
	~LeafCandidate () override
	destructor More...
Public Member Functions inherited from reco::Candidate
const_iterator	begin () const
	first daughter const_iterator More...
iterator	begin ()
	first daughter iterator More...
	Candidate ()
	default constructor More...
const_iterator	end () const
	last daughter const_iterator More...
iterator	end ()
	last daughter iterator More...
template<typename T >
T	get () const
	get a component More...
template<typename T , typename Tag >
T	get () const
	get a component More...
template<typename T >
T	get (size_type i) const
	get a component More...
template<typename T , typename Tag >
T	get (size_type i) const
	get a component More...
template<typename Ref >
Ref	masterRef () const
	cast master clone reference to a concrete type More...
template<typename T >
size_type	numberOf () const
	number of components More...
template<typename T , typename Tag >
size_type	numberOf () const
	number of components More...
virtual void	setSourceCandidatePtr (const CandidatePtr &ptr)
	Set the ptr to the source Candidate. More...
virtual	~Candidate ()
	destructor More...

Static Public Attributes
static constexpr float	bigMva_ = -999.

Private Member Functions
bool	flag (unsigned shift, unsigned flag) const
bool	getRefInfo (unsigned int iMask, unsigned int iBit, edm::ProductID &oProdID, size_t &oIndex, size_t &aIndex) const
bool	overlap (const Candidate &) const override
	Polymorphic overlap. More...
void	setFlag (unsigned shift, unsigned flag, bool value)
void	storeRefInfo (unsigned int iMask, unsigned int iBit, bool iIsValid, const edm::RefCore &iCore, size_t iKey, const edm::EDProductGetter *)
const math::XYZPoint &	vertexLegacy (PFCandidate::PFVertexType vertexType) const

Private Attributes
Blocks	blocksStorage_
float	deltaP_
	uncertainty on 3-momentum More...
float	dnn_e_bkgNonIsolated_
	DNN for electron PFid: non-isolated bkg. More...
float	dnn_e_bkgPhoton_
	DNN for electron PFid: photon bkg. More...
float	dnn_e_bkgTau_
	DNN for electron PFid: tau bkg. More...
float	dnn_e_sigIsolated_
	DNN for electron PFid: isolated signal. More...
float	dnn_e_sigNonIsolated_
	DNN for electron PFid: non-isolated signal. More...
float	dnn_gamma_
float	ecalERatio_
	corrected ECAL energy ratio (corrected/raw) More...
std::atomic< ElementsInBlocks * >	elementsInBlocks_
Elements	elementsStorage_
unsigned	flags_
	all flags, packed (ecal regional, hcal regional, tracking) More...
const edm::EDProductGetter *	getter_
std::array< float, 7 >	hcalDepthEnergyFractions_
float	hcalERatio_
	corrected HCAL energy ratio (corrected/raw) More...
float	hoERatio_
	corrected HO energy ratio (corrected/raw) More...
reco::Muon::MuonTrackType	muonTrackType_
float	mva_e_mu_
	mva for electron-muon discrimination More...
float	mva_e_pi_
	mva for electron-pion discrimination More...
float	mva_gamma_nh_
	mva for neutral hadron - gamma discrimination More...
float	mva_Isolated_
float	mva_nothing_gamma_
	mva for gamma detection More...
float	mva_nothing_nh_
	mva for neutral hadron detection More...
float	mva_pi_mu_
	mva for pi-muon discrimination More...
math::XYZPointF	positionAtECALEntrance_
	position at ECAL entrance, from the PFRecTrack More...
float	ps1Energy_
	corrected PS1 energy More...
float	ps2Energy_
	corrected PS2 energy More...
float	rawEcalEnergy_
	raw ECAL energy More...
float	rawHcalEnergy_
	raw HCAL energy More...
float	rawHoEnergy_
	raw HO energy More...
std::vector< const void * >	refsCollectionCache_
std::vector< unsigned long long >	refsInfo_
PFCandidatePtr	sourcePtr_
	reference to the source PFCandidate, if any More...
unsigned short	storedRefsBitPattern_
float	time_
	timing information (valid if timeError_ >= 0) More...
float	timeError_
	timing information uncertainty (<0 if timing not available) More...
PFVertexType	vertexType_

Friends
std::ostream &	operator<< (std::ostream &out, const PFCandidate &c)

Additional Inherited Members

Detailed Description

Particle reconstructed by the particle flow algorithm.

particle candidate from particle flow

Author

Colin Bernet

Date

February 2007

Definition at line 41 of file PFCandidate.h.

Member Typedef Documentation

Blocks

typedef edm::RefVector<reco::PFBlockCollection> reco::PFCandidate::Blocks

Definition at line 406 of file PFCandidate.h.

ElementInBlock

typedef std::pair<reco::PFBlockRef, unsigned> reco::PFCandidate::ElementInBlock

return indices of elements used in the block

return elements return elements in blocks

Definition at line 403 of file PFCandidate.h.

Elements

typedef std::vector<unsigned> reco::PFCandidate::Elements

Definition at line 407 of file PFCandidate.h.

ElementsInBlocks

typedef std::vector<ElementInBlock> reco::PFCandidate::ElementsInBlocks

Definition at line 404 of file PFCandidate.h.

Member Enumeration Documentation

Flags

enum reco::PFCandidate::Flags

Enumerator
NORMAL
E_PHI_SMODULES
E_ETA_0
E_ETA_MODULES
E_BARREL_ENDCAP
E_PRESHOWER_EDGE
E_PRESHOWER
E_ENDCAP_EDGE
H_ETA_0
H_BARREL_ENDCAP
H_ENDCAP_VFCAL
H_VFCAL_EDGE
T_TO_DISP
T_FROM_DISP
T_FROM_V0
T_FROM_GAMMACONV
GAMMA_TO_GAMMACONV

Definition at line 55 of file PFCandidate.h.

               {
      NORMAL = 0,
      E_PHI_SMODULES,
      E_ETA_0,
      E_ETA_MODULES,
      E_BARREL_ENDCAP,
      E_PRESHOWER_EDGE,
      E_PRESHOWER,
      E_ENDCAP_EDGE,
      H_ETA_0,
      H_BARREL_ENDCAP,
      H_ENDCAP_VFCAL,
      H_VFCAL_EDGE,
      T_TO_DISP,
      T_FROM_DISP,
      T_FROM_V0,
      T_FROM_GAMMACONV,
      GAMMA_TO_GAMMACONV
    };

ParticleType

enum reco::PFCandidate::ParticleType

particle types

Enumerator
X
h
e
mu
gamma
h0
h_HF
egamma_HF

Definition at line 44 of file PFCandidate.h.

                      {
      X = 0,     // undefined
      h,         // charged hadron
      e,         // electron
      mu,        // muon
      gamma,     // photon
      h0,        // neutral hadron
      h_HF,      // HF tower identified as a hadron
      egamma_HF  // HF tower identified as an EM particle
    };

PFVertexType

enum reco::PFCandidate::PFVertexType

Enumerator
kCandVertex
kTrkVertex
kComMuonVertex
kSAMuonVertex
kTrkMuonVertex
kGSFVertex
kTPFMSMuonVertex
kPickyMuonVertex
kDYTMuonVertex

Definition at line 75 of file PFCandidate.h.

                      {
      kCandVertex = 0,
      kTrkVertex = 1,
      kComMuonVertex = 2,
      kSAMuonVertex = 3,
      kTrkMuonVertex = 4,
      kGSFVertex = 5,
      kTPFMSMuonVertex = 6,
      kPickyMuonVertex = 7,
      kDYTMuonVertex = 8
    };

Constructor & Destructor Documentation

PFCandidate() [1/4]

PFCandidate::PFCandidate

(

)

default constructor

Definition at line 23 of file PFCandidate.cc.

References ntuplemaker::fill, hcalDepthEnergyFractions_, muonTrackType_, reco::Muon::None, refsInfo_, reco::LeafCandidate::setPdgId(), translateTypeToPdgId(), and X.

Referenced by clone().

    : elementsInBlocks_(nullptr),
      ecalERatio_(1.),
      hcalERatio_(1.),
      hoERatio_(1.),
      rawEcalEnergy_(0.),
      rawHcalEnergy_(0.),
      rawHoEnergy_(0.),
      ps1Energy_(0.),
      ps2Energy_(0.),
      flags_(0),
      deltaP_(0.),
      vertexType_(kCandVertex),
      mva_Isolated_(PFCandidate::bigMva_),
      mva_e_pi_(PFCandidate::bigMva_),
      mva_e_mu_(PFCandidate::bigMva_),
      mva_pi_mu_(PFCandidate::bigMva_),
      mva_nothing_gamma_(PFCandidate::bigMva_),
      mva_nothing_nh_(PFCandidate::bigMva_),
      mva_gamma_nh_(PFCandidate::bigMva_),
      dnn_e_sigIsolated_(PFCandidate::bigMva_),
      dnn_e_sigNonIsolated_(PFCandidate::bigMva_),
      dnn_e_bkgNonIsolated_(PFCandidate::bigMva_),
      dnn_e_bkgTau_(PFCandidate::bigMva_),
      dnn_e_bkgPhoton_(PFCandidate::bigMva_),
      dnn_gamma_(PFCandidate::bigMva_),
      getter_(nullptr),
      storedRefsBitPattern_(0),
      time_(0.f),
      timeError_(-1.f) {
  muonTrackType_ = reco::Muon::None;

  setPdgId(translateTypeToPdgId(X));
  refsInfo_.reserve(3);
  std::fill(hcalDepthEnergyFractions_.begin(), hcalDepthEnergyFractions_.end(), 0.f);
}

PFCandidate() [2/4]

PFCandidate::PFCandidate

(

const PFCandidatePtr &

sourcePtr

)

constructor from a reference (keeps track of source relationship)

Definition at line 62 of file PFCandidate.cc.

References hcalDepthEnergyFractions_, and sourcePtr_.

                                                        : PFCandidate(*sourcePtr) {
  sourcePtr_ = sourcePtr;
  hcalDepthEnergyFractions_ = sourcePtr->hcalDepthEnergyFractions_;  // GP not sure it's needed
}

PFCandidate() [3/4]

PFCandidate::PFCandidate	(	Charge	q,
		const LorentzVector &	p4,
		ParticleType	particleId
	)

Definition at line 67 of file PFCandidate.cc.

References blocksStorage_, reco::LeafCandidate::charge(), e, elementsStorage_, submitPVResolutionJobs::err, Exception, ntuplemaker::fill, h, hcalDepthEnergyFractions_, mu, muonTrackType_, reco::Muon::None, refsInfo_, edm::RefVector< C, T, F >::reserve(), reco::LeafCandidate::setPdgId(), and translateTypeToPdgId().

    : CompositeCandidate(charge, p4),
      elementsInBlocks_(nullptr),
      ecalERatio_(1.),
      hcalERatio_(1.),
      hoERatio_(1.),
      rawEcalEnergy_(0.),
      rawHcalEnergy_(0.),
      rawHoEnergy_(0.),
      ps1Energy_(0.),
      ps2Energy_(0.),
      flags_(0),
      deltaP_(0.),
      vertexType_(kCandVertex),
      mva_Isolated_(PFCandidate::bigMva_),
      mva_e_pi_(PFCandidate::bigMva_),
      mva_e_mu_(PFCandidate::bigMva_),
      mva_pi_mu_(PFCandidate::bigMva_),
      mva_nothing_gamma_(PFCandidate::bigMva_),
      mva_nothing_nh_(PFCandidate::bigMva_),
      mva_gamma_nh_(PFCandidate::bigMva_),
      dnn_e_sigIsolated_(PFCandidate::bigMva_),
      dnn_e_sigNonIsolated_(PFCandidate::bigMva_),
      dnn_e_bkgNonIsolated_(PFCandidate::bigMva_),
      dnn_e_bkgTau_(PFCandidate::bigMva_),
      dnn_e_bkgPhoton_(PFCandidate::bigMva_),
      dnn_gamma_(PFCandidate::bigMva_),
      getter_(nullptr),
      storedRefsBitPattern_(0),
      time_(0.f),
      timeError_(-1.f) {
  refsInfo_.reserve(3);
  blocksStorage_.reserve(10);
  elementsStorage_.reserve(10);
  std::fill(hcalDepthEnergyFractions_.begin(), hcalDepthEnergyFractions_.end(), 0.f);

  muonTrackType_ = reco::Muon::None;

  // proceed with various consistency checks

  // charged candidate: track ref and charge must be non null
  if (partId == h || partId == e || partId == mu) {
    if (charge == 0) {
      string err;
      err += "Attempt to construct a charged PFCandidate with a zero charge";
      throw cms::Exception("InconsistentValue", err.c_str());
    }
  } else {
    if (charge) {
      string err;
      err += "Attempt to construct a neutral PFCandidate ";
      err += "with a non-zero charge";
      throw cms::Exception("InconsistentValue", err.c_str());
    }
  }
  setPdgId(translateTypeToPdgId(partId));
}

PFCandidate() [4/4]

PFCandidate::PFCandidate

(

const PFCandidate &

iOther

)

copy constructor

Definition at line 125 of file PFCandidate.cc.

References elementsInBlocks_, and createJobs::tmp.

    : CompositeCandidate(iOther),
      elementsInBlocks_(nullptr),
      blocksStorage_(iOther.blocksStorage_),
      elementsStorage_(iOther.elementsStorage_),
      sourcePtr_(iOther.sourcePtr_),
      muonTrackType_(iOther.muonTrackType_),
      ecalERatio_(iOther.ecalERatio_),
      hcalERatio_(iOther.hcalERatio_),
      hoERatio_(iOther.hoERatio_),
      rawEcalEnergy_(iOther.rawEcalEnergy_),
      rawHcalEnergy_(iOther.rawHcalEnergy_),
      rawHoEnergy_(iOther.rawHoEnergy_),
      ps1Energy_(iOther.ps1Energy_),
      ps2Energy_(iOther.ps2Energy_),
      flags_(iOther.flags_),
      deltaP_(iOther.deltaP_),
      vertexType_(iOther.vertexType_),
      mva_Isolated_(iOther.mva_Isolated_),
      mva_e_pi_(iOther.mva_e_pi_),
      mva_e_mu_(iOther.mva_e_mu_),
      mva_pi_mu_(iOther.mva_pi_mu_),
      mva_nothing_gamma_(iOther.mva_nothing_gamma_),
      mva_nothing_nh_(iOther.mva_nothing_nh_),
      mva_gamma_nh_(iOther.mva_gamma_nh_),
      dnn_e_sigIsolated_(iOther.dnn_e_sigIsolated_),
      dnn_e_sigNonIsolated_(iOther.dnn_e_sigNonIsolated_),
      dnn_e_bkgNonIsolated_(iOther.dnn_e_bkgNonIsolated_),
      dnn_e_bkgTau_(iOther.dnn_e_bkgTau_),
      dnn_e_bkgPhoton_(iOther.dnn_e_bkgPhoton_),
      dnn_gamma_(iOther.dnn_gamma_),
      positionAtECALEntrance_(iOther.positionAtECALEntrance_),
      getter_(iOther.getter_),
      storedRefsBitPattern_(iOther.storedRefsBitPattern_),
      refsInfo_(iOther.refsInfo_),
      refsCollectionCache_(iOther.refsCollectionCache_),
      time_(iOther.time_),
      timeError_(iOther.timeError_),
      hcalDepthEnergyFractions_(iOther.hcalDepthEnergyFractions_) {
  auto tmp = iOther.elementsInBlocks_.load(std::memory_order_acquire);
  if (nullptr != tmp) {
    elementsInBlocks_.store(new ElementsInBlocks{*tmp}, std::memory_order_release);
  }
}

~PFCandidate()

PFCandidate::~PFCandidate ( )

override

destructor

Definition at line 217 of file PFCandidate.cc.

References elementsInBlocks_.

{ delete elementsInBlocks_.load(std::memory_order_acquire); }

Member Function Documentation

addElementInBlock()

void PFCandidate::addElementInBlock	(	const reco::PFBlockRef &	blockref,
		unsigned	elementIndex
	)

add an element to the current PFCandidate

add element in block

Definition at line 221 of file PFCandidate.cc.

References blocksStorage_, elementsInBlocks_, elementsStorage_, edm::RefVector< C, T, F >::empty(), edm::Ref< C, T, F >::id(), and edm::RefVector< C, T, F >::push_back().

                                                                                         {
  //elementsInBlocks_.push_back( make_pair(blockref.key(), elementIndex) );
  if (blocksStorage_.empty())
    blocksStorage_ = Blocks(blockref.id());
  blocksStorage_.push_back(blockref);
  elementsStorage_.push_back(elementIndex);
  auto ptr = elementsInBlocks_.exchange(nullptr);
  delete ptr;
}

bestMuonTrackType()

const reco::Muon::MuonTrackType reco::PFCandidate::bestMuonTrackType ( ) const

inline

get the Best Muon Track Ref

Definition at line 385 of file PFCandidate.h.

References muonTrackType_.

{ return muonTrackType_; }

bestTrack()

const reco::Track* reco::PFCandidate::bestTrack ( ) const

inlineoverridevirtual

return a pointer to the best track, if available. otherwise, return a null pointer

Reimplemented from reco::Candidate.

Definition at line 150 of file PFCandidate.h.

References funct::abs(), gsfTrackRef(), edm::Ref< C, T, F >::isAvailable(), edm::Ref< C, T, F >::isNonnull(), reco::LeafCandidate::pdgId(), and trackRef().

Referenced by btagbtvdeep::TrackInfoBuilder::buildTrackInfo(), dxyError(), dzError(), Muon.Muon::ptErr(), btagbtvdeep::recoCandidateToFeatures(), and DeepBoostedJetTagInfoProducer::useTrackProperties().

                                                {
      if ((abs(pdgId()) == 11 || pdgId() == 22) && gsfTrackRef().isNonnull() && gsfTrackRef().isAvailable())
        return &(*gsfTrackRef());
      else if (trackRef().isNonnull() && trackRef().isAvailable())
        return &(*trackRef());
      else
        return nullptr;
    }

clone()

PFCandidate * PFCandidate::clone ( void  ) const

overridevirtual

return a clone

Reimplemented from reco::CompositeCandidate.

Reimplemented in pat::PFParticle, and reco::PileUpPFCandidate.

Definition at line 219 of file PFCandidate.cc.

References PFCandidate().

{ return new PFCandidate(*this); }

conversionRef()

reco::ConversionRef PFCandidate::conversionRef

(

)

const

return a reference to the original conversion

Definition at line 540 of file PFCandidate.cc.

References GETREF, kRefConversionBit, and kRefConversionMask.

                                                   {
  GETREF(reco::Conversion, kRefConversionMask, kRefConversionBit);
}

deltaP()

double reco::PFCandidate::deltaP ( ) const

inline

uncertainty on 3-momentum

Definition at line 301 of file PFCandidate.h.

References deltaP_.

Referenced by PFElectronTranslator::createGsfElectrons().

{ return deltaP_; }

displacedVertexRef()

reco::PFDisplacedVertexRef PFCandidate::displacedVertexRef

(

Flags

type

)

const

return a reference to the corresponding displaced vertex, otherwise, return a null reference

Definition at line 510 of file PFCandidate.cc.

References GETREF, kRefDisplacedVertexDauBit, kRefDisplacedVertexDauMask, kRefDisplacedVertexMotBit, kRefDisplacedVertexMotMask, T_FROM_DISP, and T_TO_DISP.

Referenced by PFCandConnector::analyseNuclearWPrim().

                                                                         {
  if (type == T_TO_DISP) {
    GETREF(reco::PFDisplacedVertex, kRefDisplacedVertexDauMask, kRefDisplacedVertexDauBit);
  } else if (type == T_FROM_DISP) {
    GETREF(reco::PFDisplacedVertex, kRefDisplacedVertexMotMask, kRefDisplacedVertexMotBit);
  }
  return reco::PFDisplacedVertexRef();
}

dnn_e_bkgNonIsolated()

float reco::PFCandidate::dnn_e_bkgNonIsolated ( ) const

inline

Definition at line 356 of file PFCandidate.h.

References dnn_e_bkgNonIsolated_.

{ return dnn_e_bkgNonIsolated_; }

dnn_e_bkgPhoton()

float reco::PFCandidate::dnn_e_bkgPhoton ( ) const

inline

Definition at line 364 of file PFCandidate.h.

References dnn_e_bkgPhoton_.

{ return dnn_e_bkgPhoton_; }

dnn_e_bkgTau()

float reco::PFCandidate::dnn_e_bkgTau ( ) const

inline

Definition at line 360 of file PFCandidate.h.

References dnn_e_bkgTau_.

{ return dnn_e_bkgTau_; }

dnn_e_sigIsolated()

float reco::PFCandidate::dnn_e_sigIsolated ( ) const

inline

Definition at line 348 of file PFCandidate.h.

References dnn_e_sigIsolated_.

{ return dnn_e_sigIsolated_; }

dnn_e_sigNonIsolated()

float reco::PFCandidate::dnn_e_sigNonIsolated ( ) const

inline

Definition at line 352 of file PFCandidate.h.

References dnn_e_sigNonIsolated_.

{ return dnn_e_sigNonIsolated_; }

dnn_gamma()

float reco::PFCandidate::dnn_gamma ( ) const

inline

Definition at line 368 of file PFCandidate.h.

References dnn_gamma_.

{ return dnn_gamma_; }

dxyError()

float reco::PFCandidate::dxyError ( ) const

inlineoverridevirtual

uncertainty on dxy

Reimplemented from reco::Candidate.

Definition at line 167 of file PFCandidate.h.

References bestTrack(), and reco::TrackBase::dxyError().

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

dzError()

float reco::PFCandidate::dzError ( ) const

inlineoverridevirtual

uncertainty on dz

Reimplemented from reco::Candidate.

Definition at line 159 of file PFCandidate.h.

References bestTrack(), and reco::TrackBase::dzError().

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

ecalEnergy()

double reco::PFCandidate::ecalEnergy ( ) const

inline

return corrected Ecal energy

Definition at line 221 of file PFCandidate.h.

References ecalERatio_, and rawEcalEnergy_.

Referenced by PFCandConnector::analyseNuclearWPrim(), reco::tau::eratio(), PFCandidateBenchmark::fillOne(), FWECalPFCandidateProxyBuilder::getEt(), AntiElectronIDMVA6< TauType, ElectronType >::getTauVarsTypeSpecific(), reco::tau::PFRecoTauEnergyAlgorithmPlugin::operator()(), PFTauElecRejectionBenchmark::process(), HiBadParticleCleaner::produce(), pat::PATTauProducer::produce(), pat::PATMuonProducer::produce(), and btagbtvdeep::recoCandidateToFeatures().

{ return ecalERatio_ * rawEcalEnergy_; }

egammaExtraRef()

reco::PFCandidateEGammaExtraRef PFCandidate::egammaExtraRef

(

)

const

return a reference to the EGamma extra

Definition at line 583 of file PFCandidate.cc.

References GETREF, kRefPFEGammaExtraBit, and kRefPFEGammaExtraMask.

Referenced by PFAlgo::egammaFilters().

                                                                {
  GETREF(reco::PFCandidateEGammaExtra, kRefPFEGammaExtraMask, kRefPFEGammaExtraBit);
}

electronExtraRef()

reco::PFCandidateElectronExtraRef PFCandidate::electronExtraRef

(

)

const

return a reference to the electron extra

Definition at line 573 of file PFCandidate.cc.

References GETREF, kRefPFElectronExtraBit, and kRefPFElectronExtraMask.

Referenced by PFElectronTranslator::createGsfElectrons().

                                                                    {
  GETREF(reco::PFCandidateElectronExtra, kRefPFElectronExtraMask, kRefPFElectronExtraBit);
}

elementsInBlocks()

const PFCandidate::ElementsInBlocks & PFCandidate::elementsInBlocks

(

)

const

Definition at line 665 of file PFCandidate.cc.

References blocksStorage_, elementsInBlocks_, elementsStorage_, edm::RefVector< C, T, F >::size(), and groupFilesInBlocks::temp.

Referenced by PFMuonAlgo::cleanPunchThroughAndFakes(), PFElectronTranslator::correspondingDaughterCandidate(), PFCandidateBenchmark::fillOne(), PFBlockBasedIsolation::getHighestEtECALCluster(), reco::modules::HICaloCompatibleTrackSelector::matchPFCandToTrack(), and PFAlgo::recoTracksNotHCAL().

                                                                       {
  if (nullptr == elementsInBlocks_.load(std::memory_order_acquire)) {
    std::unique_ptr<ElementsInBlocks> temp(new ElementsInBlocks(blocksStorage_.size()));
    for (unsigned int icopy = 0; icopy != blocksStorage_.size(); ++icopy)
      (*temp)[icopy] = std::make_pair(blocksStorage_[icopy], elementsStorage_[icopy]);
    ElementsInBlocks* expected = nullptr;
    if (elementsInBlocks_.compare_exchange_strong(expected, temp.get(), std::memory_order_acq_rel)) {
      temp.release();
    }
  }
  return *(elementsInBlocks_.load(std::memory_order_acquire));
}

flag() [1/2]

bool PFCandidate::flag

(

Flags

theFlag

)

const

return a given flag

Definition at line 313 of file PFCandidate.cc.

References flags_.

Referenced by setConversionRef(), and setDisplacedVertexRef().

{ return (flags_ >> theFlag) & 1; }

flag() [2/2]

bool reco::PFCandidate::flag ( unsigned  shift, unsigned  flag  ) const

private

getRefInfo()

bool PFCandidate::getRefInfo ( unsigned int  iMask, unsigned int  iBit, edm::ProductID &  oProdID, size_t &  oIndex, size_t &  aIndex  ) const

private

Definition at line 408 of file PFCandidate.cc.

References refsInfo_, s_refsBefore, and storedRefsBitPattern_.

                                                                                                           {
  if (0 == (iBit & storedRefsBitPattern_)) {
    return false;
  }
  aIndex = s_refsBefore[storedRefsBitPattern_ & iMask];
  unsigned long long bitPacked = refsInfo_[aIndex];
  oIndex = bitPacked & 0xFFFFFFFFULL;  //low 32 bits are the index
  unsigned short productIndex = (bitPacked & 0x0000FFFF00000000ULL) >> 32;
  unsigned short processIndex = (bitPacked & 0xFFFF000000000000ULL) >> 48;
  oProductID = edm::ProductID(processIndex, productIndex);
  return true;
}

gsfElectronRef()

reco::GsfElectronRef PFCandidate::gsfElectronRef

(

)

const

return a reference to the corresponding GsfElectron if any

Definition at line 559 of file PFCandidate.cc.

References GETREF, kRefGsfElectronBit, and kRefGsfElectronMask.

Referenced by SelectionStep< Object >::select().

                                                     {
  GETREF(reco::GsfElectron, kRefGsfElectronMask, kRefGsfElectronBit);
}

gsfTrackRef()

reco::GsfTrackRef PFCandidate::gsfTrackRef

(

)

const

return a reference to the corresponding GSF track, if an electron. otherwise, return a null reference

Definition at line 469 of file PFCandidate.cc.

References GETREF, kRefGsfTrackBit, and kRefGsfTrackMask.

Referenced by bestTrack(), reco::PFMETProducerMVA::chargedFracInCone(), PileupJetIdAlgo::computeIdVariables(), reco::PFMETProducerMVA::computePFCandidateInfo(), TauDiscriminationAgainstElectronMVA6< TauType, TauDiscriminator, ElectronType >::discriminate(), LeptonRecoSkim::filter(), TauDiscriminationAgainstElectronMVA6< TauType, TauDiscriminator, ElectronType >::getTauEtaAtECalEntrance(), AntiElectronIDMVA6< TauType, ElectronType >::getTauVars(), PuppiProducer::produce(), pat::PATTauProducer::produce(), and vertexLegacy().

{ GETREF(reco::GsfTrack, kRefGsfTrackMask, kRefGsfTrackBit); }

hcalDepthEnergyFraction()

float reco::PFCandidate::hcalDepthEnergyFraction ( unsigned int  depth ) const

inline

fraction of hcal energy at a given depth (depth = 1 .. 7)

Definition at line 433 of file PFCandidate.h.

References hcalRecHitTable_cff::depth, and hcalDepthEnergyFractions_.

{ return hcalDepthEnergyFractions_[depth - 1]; }

hcalDepthEnergyFractions()

const std::array<float, 7>& reco::PFCandidate::hcalDepthEnergyFractions ( ) const

inline

fraction of hcal energy at a given depth (index 0..6 for depth 1..7)

Definition at line 435 of file PFCandidate.h.

References hcalDepthEnergyFractions_.

{ return hcalDepthEnergyFractions_; }

hcalEnergy()

double reco::PFCandidate::hcalEnergy ( ) const

inline

return corrected Hcal energy

Definition at line 233 of file PFCandidate.h.

References hcalERatio_, and rawHcalEnergy_.

Referenced by PFCandConnector::analyseNuclearWPrim(), reco::tau::eratio(), PFCandidateBenchmark::fillOne(), FWHCalPFCandidateProxyBuilder::getEt(), AntiElectronIDMVA6< TauType, ElectronType >::getTauVarsTypeSpecific(), reco::tau::PFRecoTauEnergyAlgorithmPlugin::operator()(), HiBadParticleCleaner::produce(), pat::PATTauProducer::produce(), and btagbtvdeep::recoCandidateToFeatures().

{ return hcalERatio_ * rawHcalEnergy_; }

hoEnergy()

double reco::PFCandidate::hoEnergy ( ) const

inline

return corrected Hcal energy

Definition at line 245 of file PFCandidate.h.

References hoERatio_, and rawHoEnergy_.

Referenced by Jet.Jet::hoEnergyFraction(), reco::makeSpecific(), and reco::tau::PFRecoTauEnergyAlgorithmPlugin::operator()().

{ return hoERatio_ * rawHoEnergy_; }

isTimeValid()

bool reco::PFCandidate::isTimeValid ( ) const

inline

do we have a valid time information

Definition at line 421 of file PFCandidate.h.

References timeError_.

Referenced by TransientTrackBuilder::build().

{ return timeError_ >= 0.f; }

muonRef()

reco::MuonRef PFCandidate::muonRef

(

)

const

return a reference to the corresponding muon, if a muon. otherwise, return a null reference

Definition at line 450 of file PFCandidate.cc.

References GETREF, kRefMuonBit, and kRefMuonMask.

Referenced by PFMuonAlgo::addMissingMuons(), PFMuonAlgo::cleanMismeasured(), PFMuonAlgo::cleanPunchThroughAndFakes(), PileupJetIdAlgo::computeIdVariables(), PFMuonAlgo::getMinMaxMET2(), TauDiscriminationAgainstElectronMVA6< TauType, TauDiscriminator, ElectronType >::getTauEtaAtECalEntrance(), reco::PFTau::hasMuonReference(), PFMuonAlgo::postClean(), HiBadParticleCleaner::produce(), pat::PATTauProducer::produce(), pat::PATMuonProducer::produce(), SelectionStep< Object >::select(), and vertexLegacy().

{ GETREF(reco::Muon, kRefMuonMask, kRefMuonBit); }

mva_e_mu()

float reco::PFCandidate::mva_e_mu ( ) const

inline

mva for electron-muon discrimination

Definition at line 323 of file PFCandidate.h.

References mva_e_mu_.

{ return mva_e_mu_; }

mva_e_pi()

float reco::PFCandidate::mva_e_pi ( ) const

inline

mva for electron-pion discrimination

Definition at line 317 of file PFCandidate.h.

References mva_e_pi_.

Referenced by PFElectronTranslator::createGsfElectrons(), PFAlgo::egammaFilters(), and PFCandidateBenchmark::fillOne().

{ return mva_e_pi_; }

mva_gamma_nh()

float reco::PFCandidate::mva_gamma_nh ( ) const

inline

mva for neutral hadron - gamma discrimination

Definition at line 372 of file PFCandidate.h.

References mva_gamma_nh_.

{ return mva_gamma_nh_; }

mva_Isolated()

float reco::PFCandidate::mva_Isolated ( ) const

inline

Definition at line 313 of file PFCandidate.h.

References mva_Isolated_.

{ return mva_Isolated_; }

mva_nothing_gamma()

float reco::PFCandidate::mva_nothing_gamma ( ) const

inline

mva for gamma detection

Definition at line 335 of file PFCandidate.h.

References mva_nothing_gamma_.

Referenced by PFIsolationEstimator::isPhotonParticleVetoed().

{ return mva_nothing_gamma_; }

mva_nothing_nh()

float reco::PFCandidate::mva_nothing_nh ( ) const

inline

mva for neutral hadron detection

Definition at line 341 of file PFCandidate.h.

References mva_nothing_nh_.

{ return mva_nothing_nh_; }

mva_pi_mu()

float reco::PFCandidate::mva_pi_mu ( ) const

inline

mva for pi-muon discrimination

Definition at line 329 of file PFCandidate.h.

References mva_pi_mu_.

{ return mva_pi_mu_; }

numberOfSourceCandidatePtrs()

size_t reco::PFCandidate::numberOfSourceCandidatePtrs ( ) const

inlineoverridevirtual

return the number of source Candidates ( the candidates used to construct this Candidate)

Reimplemented from reco::LeafCandidate.

Definition at line 122 of file PFCandidate.h.

Referenced by reco::PFCandidateFwdPtrFactory::operator()().

{ return 1; }

operator=()

PFCandidate & PFCandidate::operator=

(

PFCandidate const &

iOther

)

Definition at line 170 of file PFCandidate.cc.

References blocksStorage_, deltaP_, dnn_e_bkgNonIsolated_, dnn_e_bkgPhoton_, dnn_e_bkgTau_, dnn_e_sigIsolated_, dnn_e_sigNonIsolated_, dnn_gamma_, ecalERatio_, elementsInBlocks_, elementsStorage_, flags_, getter_, hcalDepthEnergyFractions_, hcalERatio_, hoERatio_, muonTrackType_, mva_e_mu_, mva_e_pi_, mva_gamma_nh_, mva_Isolated_, mva_nothing_gamma_, mva_nothing_nh_, mva_pi_mu_, reco::LeafCandidate::operator=(), positionAtECALEntrance_, ps1Energy_, ps2Energy_, rawEcalEnergy_, rawHcalEnergy_, rawHoEnergy_, refsCollectionCache_, refsInfo_, sourcePtr_, storedRefsBitPattern_, time_, timeError_, createJobs::tmp, and vertexType_.

                                                             {
  CompositeCandidate::operator=(iOther);
  auto tmp = iOther.elementsInBlocks_.load(std::memory_order_acquire);
  if (nullptr != tmp) {
    delete elementsInBlocks_.exchange(new ElementsInBlocks{*tmp}, std::memory_order_acq_rel);
  } else {
    delete elementsInBlocks_.exchange(nullptr, std::memory_order_acq_rel);
  }
  blocksStorage_ = iOther.blocksStorage_;
  elementsStorage_ = iOther.elementsStorage_;
  sourcePtr_ = iOther.sourcePtr_;
  muonTrackType_ = iOther.muonTrackType_;
  ecalERatio_ = iOther.ecalERatio_;
  hcalERatio_ = iOther.hcalERatio_;
  hoERatio_ = iOther.hoERatio_;
  rawEcalEnergy_ = iOther.rawEcalEnergy_;
  rawHcalEnergy_ = iOther.rawHcalEnergy_;
  rawHoEnergy_ = iOther.rawHoEnergy_;
  ps1Energy_ = iOther.ps1Energy_;
  ps2Energy_ = iOther.ps2Energy_;
  flags_ = iOther.flags_;
  deltaP_ = iOther.deltaP_;
  vertexType_ = iOther.vertexType_;
  mva_Isolated_ = iOther.mva_Isolated_;
  mva_e_pi_ = iOther.mva_e_pi_;
  mva_e_mu_ = iOther.mva_e_mu_;
  mva_pi_mu_ = iOther.mva_pi_mu_;
  mva_nothing_gamma_ = iOther.mva_nothing_gamma_;
  mva_nothing_nh_ = iOther.mva_nothing_nh_;
  mva_gamma_nh_ = iOther.mva_gamma_nh_;
  dnn_e_sigIsolated_ = iOther.dnn_e_sigIsolated_;
  dnn_e_sigNonIsolated_ = iOther.dnn_e_sigNonIsolated_;
  dnn_e_bkgNonIsolated_ = iOther.dnn_e_bkgNonIsolated_;
  dnn_e_bkgTau_ = iOther.dnn_e_bkgTau_;
  dnn_e_bkgPhoton_ = iOther.dnn_e_bkgPhoton_;
  dnn_gamma_ = iOther.dnn_gamma_;
  positionAtECALEntrance_ = iOther.positionAtECALEntrance_;
  getter_ = iOther.getter_;
  storedRefsBitPattern_ = iOther.storedRefsBitPattern_;
  refsInfo_ = iOther.refsInfo_;
  refsCollectionCache_ = iOther.refsCollectionCache_;
  time_ = iOther.time_;
  timeError_ = iOther.timeError_;
  hcalDepthEnergyFractions_ = iOther.hcalDepthEnergyFractions_;
  return *this;
}

overlap()

bool PFCandidate::overlap ( const Candidate &  other ) const

overrideprivatevirtual

Polymorphic overlap.

Reimplemented from reco::CompositeCandidate.

Definition at line 280 of file PFCandidate.cc.

References mps_fire::i, edm::Ptr< T >::isNonnull(), edm::Ptr< T >::isNull(), dqmiodumpmetadata::n, trackingPlots::other, overlap(), sourceCandidatePtr(), and sourcePtr_.

Referenced by overlap().

                                                          {
  CandidatePtr myPtr = sourceCandidatePtr(0);
  if (myPtr.isNull())
    return false;
  for (size_t i = 0, n = other.numberOfSourceCandidatePtrs(); i < n; ++i) {
    CandidatePtr otherPtr = other.sourceCandidatePtr(i);
    if ((otherPtr == myPtr) || (sourcePtr_.isNonnull() && otherPtr.isNonnull() && sourcePtr_->overlap(*otherPtr))) {
      return true;
    }
  }
  return false;
}

particleId()

virtual ParticleType reco::PFCandidate::particleId ( ) const

inlinevirtual

particle identification code

Definition at line 392 of file PFCandidate.h.

References reco::LeafCandidate::pdgId(), and translatePdgIdToType().

Referenced by PFTester::analyze(), JetTester_HeavyIons::analyze(), JetAnalyzer_HeavyIons::analyze(), PFMuonAlgo::cleanPunchThroughAndFakes(), metsig::SignAlgoResolutions::evalPF(), PFCandidateBenchmark::fillOne(), LeptonRecoSkim::filter(), PFAlgo::postCleaning(), HiBadParticleCleaner::produce(), Type0PFMETcorrInputProducer::produce(), pf2pat::PFIsoDepositAlgo::sameParticle(), setConversionRef(), setDisplacedVertexRef(), setPhotonRef(), setSuperClusterRef(), and setTrackRef().

{ return translatePdgIdToType(pdgId()); }

photonExtraRef()

reco::PFCandidatePhotonExtraRef PFCandidate::photonExtraRef

(

)

const

return a reference to the photon extra

Definition at line 579 of file PFCandidate.cc.

References GETREF, kRefPFPhotonExtraBit, and kRefPFPhotonExtraMask.

                                                                {
  GETREF(reco::PFCandidatePhotonExtra, kRefPFPhotonExtraMask, kRefPFPhotonExtraBit);
}

photonRef()

reco::PhotonRef PFCandidate::photonRef

(

)

const

return a reference to the corresponding Photon if any

Definition at line 577 of file PFCandidate.cc.

References GETREF, kRefPhotonBit, and kRefPhotonMask.

{ GETREF(reco::Photon, kRefPhotonMask, kRefPhotonBit); }

positionAtECALEntrance()

const math::XYZPointF& reco::PFCandidate::positionAtECALEntrance ( ) const

inline

Returns

position at ECAL entrance

Definition at line 388 of file PFCandidate.h.

References positionAtECALEntrance_.

Referenced by reco::tau::atECALEntrance(), PFCandIsolatorFromDeposits::SingleDeposit::compute(), PFIsolationEstimator::fGetIsolationInRings(), TauDiscriminationAgainstElectronMVA6< TauType, TauDiscriminator, ElectronType >::getTauEtaAtECalEntrance(), AntiElectronIDMVA6< TauType, ElectronType >::getTauVarsTypeSpecific(), PFTauElecRejectionBenchmark::process(), and pat::PATTauProducer::produce().

{ return positionAtECALEntrance_; }

pS1Energy()

double reco::PFCandidate::pS1Energy ( ) const

inline

return corrected PS1 energy

Definition at line 280 of file PFCandidate.h.

References ps1Energy_.

{ return ps1Energy_; }

pS2Energy()

double reco::PFCandidate::pS2Energy ( ) const

inline

return corrected PS2 energy

Definition at line 286 of file PFCandidate.h.

References ps2Energy_.

{ return ps2Energy_; }

rawEcalEnergy()

double reco::PFCandidate::rawEcalEnergy ( ) const

inline

return corrected Ecal energy

Definition at line 224 of file PFCandidate.h.

References rawEcalEnergy_.

Referenced by PFMuonAlgo::cleanPunchThroughAndFakes(), and PFElectronTranslator::createBasicCluster().

{ return rawEcalEnergy_; }

rawHcalEnergy()

double reco::PFCandidate::rawHcalEnergy ( ) const

inline

return raw Hcal energy

Definition at line 236 of file PFCandidate.h.

References rawHcalEnergy_.

Referenced by PFMuonAlgo::cleanPunchThroughAndFakes().

{ return rawHcalEnergy_; }

rawHoEnergy()

double reco::PFCandidate::rawHoEnergy ( ) const

inline

return raw Hcal energy

Definition at line 248 of file PFCandidate.h.

References rawHoEnergy_.

{ return rawHoEnergy_; }

rescaleMomentum()

void PFCandidate::rescaleMomentum

(

double

rescaleFactor

)

particle momentum *= rescaleFactor

Definition at line 294 of file PFCandidate.cc.

References e, Exception, reco::LeafCandidate::mass(), reco::LeafCandidate::p(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), reco::LeafCandidate::pz(), reco::LeafCandidate::setP4(), mathSSE::sqrt(), and to_string().

                                                      {
  if (rescaleFactor < 0)
    throw cms::Exception(
        "NegativeScaling",
        "Scale factor " + std::to_string(rescaleFactor) + " is < 0. Cannot rescale momentum by this value");

  float e = std::sqrt(p() * p() * rescaleFactor * rescaleFactor + mass() * mass());

  LorentzVector rescaledp4(rescaleFactor * px(), rescaleFactor * py(), rescaleFactor * pz(), e);
  setP4(rescaledp4);
}

set_dnn_e_bkgNonIsolated()

void reco::PFCandidate::set_dnn_e_bkgNonIsolated ( float  mva )

inline

Definition at line 357 of file PFCandidate.h.

References dnn_e_bkgNonIsolated_, and beam_dqm_sourceclient-live_cfg::mva.

Referenced by PFAlgo::egammaFilters().

{ dnn_e_bkgNonIsolated_ = mva; }

set_dnn_e_bkgPhoton()

void reco::PFCandidate::set_dnn_e_bkgPhoton ( float  mva )

inline

Definition at line 365 of file PFCandidate.h.

References dnn_e_bkgPhoton_, and beam_dqm_sourceclient-live_cfg::mva.

Referenced by PFAlgo::egammaFilters().

{ dnn_e_bkgPhoton_ = mva; }

set_dnn_e_bkgTau()

void reco::PFCandidate::set_dnn_e_bkgTau ( float  mva )

inline

Definition at line 361 of file PFCandidate.h.

References dnn_e_bkgTau_, and beam_dqm_sourceclient-live_cfg::mva.

Referenced by PFAlgo::egammaFilters().

{ dnn_e_bkgTau_ = mva; }

set_dnn_e_sigIsolated()

void reco::PFCandidate::set_dnn_e_sigIsolated ( float  mva )

inline

Definition at line 349 of file PFCandidate.h.

References dnn_e_sigIsolated_, and beam_dqm_sourceclient-live_cfg::mva.

Referenced by PFAlgo::egammaFilters().

{ dnn_e_sigIsolated_ = mva; }

set_dnn_e_sigNonIsolated()

void reco::PFCandidate::set_dnn_e_sigNonIsolated ( float  mva )

inline

Definition at line 353 of file PFCandidate.h.

References dnn_e_sigNonIsolated_, and beam_dqm_sourceclient-live_cfg::mva.

Referenced by PFAlgo::egammaFilters().

{ dnn_e_sigNonIsolated_ = mva; }

set_dnn_gamma()

void reco::PFCandidate::set_dnn_gamma ( float  mva )

inline

Definition at line 369 of file PFCandidate.h.

References dnn_gamma_, and beam_dqm_sourceclient-live_cfg::mva.

Referenced by PFAlgo::egammaFilters().

{ dnn_gamma_ = mva; }

set_mva_e_mu()

void reco::PFCandidate::set_mva_e_mu ( float  mva )

inline

set mva for electron-muon discrimination

Definition at line 320 of file PFCandidate.h.

References beam_dqm_sourceclient-live_cfg::mva, and mva_e_mu_.

{ mva_e_mu_ = mva; }

set_mva_e_pi()

void reco::PFCandidate::set_mva_e_pi ( float  mvaNI )

inline

Definition at line 315 of file PFCandidate.h.

References mva_e_pi_.

Referenced by PFAlgo::egammaFilters().

{ mva_e_pi_ = mvaNI; }

set_mva_gamma_nh()

void reco::PFCandidate::set_mva_gamma_nh ( float  mva )

inline

set mva for neutral hadron - gamma discrimination

Definition at line 344 of file PFCandidate.h.

References beam_dqm_sourceclient-live_cfg::mva, and mva_gamma_nh_.

{ mva_gamma_nh_ = mva; }

set_mva_Isolated()

void reco::PFCandidate::set_mva_Isolated ( float  mvaI )

inline

set mva for electron-pion discrimination. For charged particles, this variable is set to 0 for particles that are not preided to 1 otherwise For neutral particles, it is set to the default value

Definition at line 311 of file PFCandidate.h.

References mva_Isolated_.

Referenced by PFAlgo::egammaFilters().

{ mva_Isolated_ = mvaI; }

set_mva_nothing_gamma()

void reco::PFCandidate::set_mva_nothing_gamma ( float  mva )

inline

set mva for gamma detection

Definition at line 332 of file PFCandidate.h.

References beam_dqm_sourceclient-live_cfg::mva, and mva_nothing_gamma_.

Referenced by PFAlgo::egammaFilters().

{ mva_nothing_gamma_ = mva; }

set_mva_nothing_nh()

void reco::PFCandidate::set_mva_nothing_nh ( float  mva )

inline

set mva for neutral hadron detection

Definition at line 338 of file PFCandidate.h.

References beam_dqm_sourceclient-live_cfg::mva, and mva_nothing_nh_.

{ mva_nothing_nh_ = mva; }

set_mva_pi_mu()

void reco::PFCandidate::set_mva_pi_mu ( float  mva )

inline

set mva for pi-muon discrimination

Definition at line 326 of file PFCandidate.h.

References beam_dqm_sourceclient-live_cfg::mva, and mva_pi_mu_.

{ mva_pi_mu_ = mva; }

setConversionRef()

void PFCandidate::setConversionRef

(

const reco::ConversionRef &

ref

)

set ref to original reco conversion

Definition at line 520 of file PFCandidate.cc.

References submitPVResolutionJobs::err, Exception, flag(), gamma, GAMMA_TO_GAMMACONV, edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefConversionBit, kRefConversionMask, EgammaValidation_cff::num, particleId(), edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), and storeRefInfo().

                                                                {
  if (particleId() != gamma) {
    string err;
    err += "PFCandidate::setConversionRef: this is not a (converted) photon ! particleId_=";
    char num[4];
    sprintf(num, "%d", particleId());
    err += num;

    throw cms::Exception("InconsistentReference", err.c_str());
  } else if (!flag(GAMMA_TO_GAMMACONV)) {
    string err;
    err += "PFCandidate::setConversionRef: particule flag is not GAMMA_TO_GAMMACONV";

    throw cms::Exception("InconsistentReference", err.c_str());
  }

  storeRefInfo(
      kRefConversionMask, kRefConversionBit, iRef.isNonnull(), iRef.refCore(), iRef.key(), iRef.productGetter());
}

setDeltaP()

void reco::PFCandidate::setDeltaP ( double  dp )

inline

set uncertainty on momentum

Definition at line 298 of file PFCandidate.h.

References deltaP_, and Calorimetry_cff::dp.

{ deltaP_ = dp; }

setDisplacedVertexRef()

void PFCandidate::setDisplacedVertexRef	(	const reco::PFDisplacedVertexRef &	ref,
		Flags	flag
	)

set displaced vertex reference

Definition at line 472 of file PFCandidate.cc.

References submitPVResolutionJobs::err, Exception, flag(), h, edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefDisplacedVertexDauBit, kRefDisplacedVertexDauMask, kRefDisplacedVertexMotBit, kRefDisplacedVertexMotMask, EgammaValidation_cff::num, particleId(), edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), storeRefInfo(), T_FROM_DISP, and T_TO_DISP.

                                                                                        {
  if (particleId() != h) {
    string err;
    err += "PFCandidate::setDisplacedVertexRef: this is not a hadron! particleId_=";
    char num[4];
    sprintf(num, "%d", particleId());
    err += num;

    throw cms::Exception("InconsistentReference", err.c_str());
  } else if (!flag(T_FROM_DISP) && !flag(T_TO_DISP)) {
    string err;
    err += "PFCandidate::setDisplacedVertexRef: particule flag is neither T_FROM_DISP nor T_TO_DISP";

    throw cms::Exception("InconsistentReference", err.c_str());
  }

  if (type == T_TO_DISP && flag(T_TO_DISP))
    storeRefInfo(kRefDisplacedVertexDauMask,
                 kRefDisplacedVertexDauBit,
                 iRef.isNonnull(),
                 iRef.refCore(),
                 iRef.key(),
                 iRef.productGetter());
  else if (type == T_FROM_DISP && flag(T_FROM_DISP))
    storeRefInfo(kRefDisplacedVertexMotMask,
                 kRefDisplacedVertexMotBit,
                 iRef.isNonnull(),
                 iRef.refCore(),
                 iRef.key(),
                 iRef.productGetter());
  else if ((type == T_FROM_DISP && !flag(T_FROM_DISP)) || (type == T_TO_DISP && !flag(T_TO_DISP))) {
    string err;
    err += "PFCandidate::setDisplacedVertexRef: particule flag is not switched on";

    throw cms::Exception("InconsistentReference", err.c_str());
  }
}

setEcalEnergy()

void reco::PFCandidate::setEcalEnergy ( float  eeRaw, float  eeCorr  )

inline

set corrected Ecal energy

Definition at line 215 of file PFCandidate.h.

References funct::abs(), ecalERatio_, and rawEcalEnergy_.

                                                  {
      rawEcalEnergy_ = eeRaw;
      ecalERatio_ = std::abs(eeRaw) < 1.e-6 ? 1.0 : eeCorr / eeRaw;
    }

setFlag() [1/2]

void PFCandidate::setFlag	(	Flags	theFlag,
		bool	value
	)

set a given flag

Definition at line 306 of file PFCandidate.cc.

References flags_.

                                                   {
  if (value)
    flags_ = flags_ | (1 << theFlag);
  else
    flags_ = flags_ ^ (1 << theFlag);
}

setFlag() [2/2]

void reco::PFCandidate::setFlag ( unsigned  shift, unsigned  flag, bool  value  )

private

setGsfElectronRef()

void PFCandidate::setGsfElectronRef

(

const reco::GsfElectronRef &

ref

)

set GsfElectronRef

Definition at line 554 of file PFCandidate.cc.

References edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefGsfElectronBit, kRefGsfElectronMask, edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), and storeRefInfo().

                                                                  {
  storeRefInfo(
      kRefGsfElectronMask, kRefGsfElectronBit, iRef.isNonnull(), iRef.refCore(), iRef.key(), iRef.productGetter());
}

setGsfTrackRef()

void PFCandidate::setGsfTrackRef

(

const reco::GsfTrackRef &

ref

)

set gsftrack reference

Definition at line 453 of file PFCandidate.cc.

References edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefGsfTrackBit, kRefGsfTrackMask, edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), and storeRefInfo().

                                                            {
  //  Removed by F. Beaudette. Would like to be able to save the GsfTrackRef even for charged pions
  //  if( particleId() != e ) {
  //    string err;
  //    err += "PFCandidate::setGsfTrackRef: this is not an electron ! particleId_=";
  //    char num[4];
  //    sprintf( num, "%d", particleId());
  //    err += num;
  //
  //    throw cms::Exception("InconsistentReference",
  //                         err.c_str() );
  //  }

  storeRefInfo(kRefGsfTrackMask, kRefGsfTrackBit, iRef.isNonnull(), iRef.refCore(), iRef.key(), iRef.productGetter());
}

setHcalDepthEnergyFractions()

void reco::PFCandidate::setHcalDepthEnergyFractions ( const std::array< float, 7 > &  fracs )

inline

set the fraction of hcal energy as function of depth (index 0..6 for depth 1..7)

Definition at line 437 of file PFCandidate.h.

References hcalDepthEnergyFractions_.

{ hcalDepthEnergyFractions_ = fracs; }

setHcalEnergy()

void reco::PFCandidate::setHcalEnergy ( float  ehRaw, float  ehCorr  )

inline

set corrected Hcal energy

Definition at line 227 of file PFCandidate.h.

References funct::abs(), hcalERatio_, and rawHcalEnergy_.

                                                  {
      rawHcalEnergy_ = ehRaw;
      hcalERatio_ = std::abs(ehRaw) < 1.e-6 ? 1.0 : ehCorr / ehRaw;
    }

setHoEnergy()

void reco::PFCandidate::setHoEnergy ( float  eoRaw, float  eoCorr  )

inline

set corrected Hcal energy

Definition at line 239 of file PFCandidate.h.

References funct::abs(), hoERatio_, and rawHoEnergy_.

                                                {
      rawHoEnergy_ = eoRaw;
      hoERatio_ = std::abs(eoRaw) < 1.e-6 ? 1.0 : eoCorr / eoRaw;
    }

setMuonRef()

void PFCandidate::setMuonRef

(

const reco::MuonRef &

ref

)

set muon reference

Definition at line 439 of file PFCandidate.cc.

References submitPVResolutionJobs::err, Exception, edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefMuonBit, kRefMuonMask, edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), storeRefInfo(), and trackRef().

Referenced by PFMuonAlgo::reconstructMuon().

                                                    {
  if (trackRef() != iRef->track()) {
    string err;
    err += "PFCandidate::setMuonRef: inconsistent track references!";

    throw cms::Exception("InconsistentReference", err.c_str());
  }

  storeRefInfo(kRefMuonMask, kRefMuonBit, iRef.isNonnull(), iRef.refCore(), iRef.key(), iRef.productGetter());
}

setMuonTrackType()

void reco::PFCandidate::setMuonTrackType ( const reco::Muon::MuonTrackType &  type )

inline

set the Best Muon Track Ref

Definition at line 381 of file PFCandidate.h.

References muonTrackType_.

Referenced by PFMuonAlgo::changeTrack().

{ muonTrackType_ = type; }

setParticleType()

void PFCandidate::setParticleType

(

ParticleType

type

)

set Particle Type

Definition at line 278 of file PFCandidate.cc.

References reco::LeafCandidate::setPdgId(), and translateTypeToPdgId().

Referenced by PFMuonAlgo::changeTrack(), PFAlgo::egammaFilters(), and DeltaBetaWeights::produce().

{ setPdgId(translateTypeToPdgId(type)); }

setPFEGammaExtraRef()

void PFCandidate::setPFEGammaExtraRef

(

const reco::PFCandidateEGammaExtraRef &

ref

)

set the PF EGamma Extra Ref

Definition at line 625 of file PFCandidate.cc.

References edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefPFEGammaExtraBit, kRefPFEGammaExtraMask, edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), and storeRefInfo().

                                                                               {
  storeRefInfo(
      kRefPFEGammaExtraMask, kRefPFEGammaExtraBit, iRef.isNonnull(), iRef.refCore(), iRef.key(), iRef.productGetter());
}

setPFElectronExtraRef()

void PFCandidate::setPFElectronExtraRef

(

const reco::PFCandidateElectronExtraRef &

ref

)

set the PF Electron Extra Ref

Definition at line 564 of file PFCandidate.cc.

References edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefPFElectronExtraBit, kRefPFElectronExtraMask, edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), and storeRefInfo().

                                                                                   {
  storeRefInfo(kRefPFElectronExtraMask,
               kRefPFElectronExtraBit,
               iRef.isNonnull(),
               iRef.refCore(),
               iRef.key(),
               iRef.productGetter());
}

setPFPhotonExtraRef()

void PFCandidate::setPFPhotonExtraRef

(

const reco::PFCandidatePhotonExtraRef &

ref

)

set the PF Photon Extra Ref

Definition at line 620 of file PFCandidate.cc.

References edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefPFPhotonExtraBit, kRefPFPhotonExtraMask, edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), and storeRefInfo().

                                                                               {
  storeRefInfo(
      kRefPFPhotonExtraMask, kRefPFPhotonExtraBit, iRef.isNonnull(), iRef.refCore(), iRef.key(), iRef.productGetter());
}

setPhotonRef()

void PFCandidate::setPhotonRef

(

const reco::PhotonRef &

phRef

)

set ref to the corresponding reco::Photon if any

Definition at line 591 of file PFCandidate.cc.

References e, submitPVResolutionJobs::err, Exception, gamma, edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefPhotonBit, kRefPhotonMask, EgammaValidation_cff::num, particleId(), edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), and storeRefInfo().

                                                        {
  if (particleId() != gamma && particleId() != e) {
    string err;
    err += "PFCandidate::setSuperClusterRef: this is not an electron neither a photon ! particleId_=";
    char num[4];
    sprintf(num, "%d", particleId());
    err += num;

    throw cms::Exception("InconsistentReference", err.c_str());
  }

  storeRefInfo(kRefPhotonMask, kRefPhotonBit, iRef.isNonnull(), iRef.refCore(), iRef.key(), iRef.productGetter());
}

setPositionAtECALEntrance()

void reco::PFCandidate::setPositionAtECALEntrance ( const math::XYZPointF &  pos )

inline

set position at ECAL entrance

Definition at line 375 of file PFCandidate.h.

References positionAtECALEntrance_.

{ positionAtECALEntrance_ = pos; }

setPs1Energy()

void reco::PFCandidate::setPs1Energy ( float  e1 )

inline

set corrected PS1 energy

Definition at line 277 of file PFCandidate.h.

References StorageManager_cfg::e1, and ps1Energy_.

{ ps1Energy_ = e1; }

setPs2Energy()

void reco::PFCandidate::setPs2Energy ( float  e2 )

inline

set corrected PS2 energy

Definition at line 283 of file PFCandidate.h.

References ps2Energy_.

{ ps2Energy_ = e2; }

setSourceCandidatePtr()

void reco::PFCandidate::setSourceCandidatePtr ( const PFCandidatePtr &  ptr )

inline

Definition at line 120 of file PFCandidate.h.

References sourcePtr_.

Referenced by PuppiPhoton::produce(), and VirtualJetProducer::writeJetsWithConstituents().

{ sourcePtr_ = ptr; }

setSuperClusterRef()

void PFCandidate::setSuperClusterRef

(

const reco::SuperClusterRef &

scRef

)

Definition at line 605 of file PFCandidate.cc.

References e, submitPVResolutionJobs::err, Exception, gamma, edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefSuperClusterBit, kRefSuperClusterMask, EgammaValidation_cff::num, particleId(), edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), and storeRefInfo().

                                                                    {
  if (particleId() != gamma && particleId() != e) {
    string err;
    err += "PFCandidate::setSuperClusterRef: this is not an electron neither a photon ! particleId_=";
    char num[4];
    sprintf(num, "%d", particleId());
    err += num;

    throw cms::Exception("InconsistentReference", err.c_str());
  }

  storeRefInfo(
      kRefSuperClusterMask, kRefSuperClusterBit, iRef.isNonnull(), iRef.refCore(), iRef.key(), iRef.productGetter());
}

setTime()

void reco::PFCandidate::setTime ( float  time, float  timeError = 0.f  )

inline

the timing information

Definition at line 427 of file PFCandidate.h.

References time(), time_, timeError(), and timeError_.

                                                    {
      time_ = time;
      timeError_ = timeError;
    }

setTrackRef()

void PFCandidate::setTrackRef

(

const reco::TrackRef &

ref

)

set track reference

Definition at line 422 of file PFCandidate.cc.

References reco::LeafCandidate::charge(), submitPVResolutionJobs::err, Exception, edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefTrackBit, kRefTrackMask, EgammaValidation_cff::num, particleId(), edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), and storeRefInfo().

                                                      {
  if (!charge()) {
    string err;
    err += "PFCandidate::setTrackRef: this is a neutral candidate! ";
    err += "particleId_=";
    char num[4];
    sprintf(num, "%d", particleId());
    err += num;

    throw cms::Exception("InconsistentReference", err.c_str());
  }

  storeRefInfo(kRefTrackMask, kRefTrackBit, iRef.isNonnull(), iRef.refCore(), iRef.key(), iRef.productGetter());
}

setV0Ref()

void PFCandidate::setV0Ref

(

const reco::VertexCompositeCandidateRef &

ref

)

set ref to original reco conversion

Definition at line 545 of file PFCandidate.cc.

References edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), kRefV0Bit, kRefV0Mask, edm::Ref< C, T, F >::productGetter(), edm::Ref< C, T, F >::refCore(), and storeRefInfo().

                                                                      {
  storeRefInfo(kRefV0Mask, kRefV0Bit, iRef.isNonnull(), iRef.refCore(), iRef.key(), iRef.productGetter());
}

sourceCandidatePtr()

CandidatePtr reco::PFCandidate::sourceCandidatePtr ( size_type  i ) const

inlineoverridevirtual

return a Ptr to one of the source Candidates ( the candidates used to construct this Candidate)

Reimplemented from reco::LeafCandidate.

Definition at line 124 of file PFCandidate.h.

References sourcePtr_.

Referenced by reco::PFCandidateFwdPtrFactory::operator()(), and overlap().

{ return sourcePtr_; }

storeRefInfo()

void PFCandidate::storeRefInfo ( unsigned int  iMask, unsigned int  iBit, bool  iIsValid, const edm::RefCore &  iCore, size_t  iKey, const edm::EDProductGetter *  iGetter  )

private

Definition at line 372 of file PFCandidate.cc.

References cms::cuda::assert(), bitPackRefInfo(), runTheMatrix::const, getter_, edm::RefCore::productPtr(), refsCollectionCache_, refsInfo_, s_refsBefore, and storedRefsBitPattern_.

Referenced by setConversionRef(), setDisplacedVertexRef(), setGsfElectronRef(), setGsfTrackRef(), setMuonRef(), setPFEGammaExtraRef(), setPFElectronExtraRef(), setPFPhotonExtraRef(), setPhotonRef(), setSuperClusterRef(), setTrackRef(), and setV0Ref().

                                                                  {
  size_t index = s_refsBefore[storedRefsBitPattern_ & iMask];
  if (nullptr == getter_) {
    getter_ = iGetter;
  }

  if (iIsValid) {
    if (0 == (storedRefsBitPattern_ & iBit)) {
      refsInfo_.insert(refsInfo_.begin() + index, bitPackRefInfo(iCore, iKey));
      if (iGetter == nullptr)
        refsCollectionCache_.insert(refsCollectionCache_.begin() + index, static_cast<void const*>(iCore.productPtr()));
      else
        refsCollectionCache_.insert(refsCollectionCache_.begin() + index, nullptr);
    } else {
      assert(refsInfo_.size() > index);
      *(refsInfo_.begin() + index) = bitPackRefInfo(iCore, iKey);
      if (iGetter == nullptr)
        *(refsCollectionCache_.begin() + index) = static_cast<void const*>(iCore.productPtr());
      else
        *(refsCollectionCache_.begin() + index) = nullptr;
    }
    storedRefsBitPattern_ |= iBit;
  } else {
    if (storedRefsBitPattern_ & iBit) {
      refsInfo_.erase(refsInfo_.begin() + index);
      refsCollectionCache_.erase(refsCollectionCache_.begin() + index);
      storedRefsBitPattern_ ^= iBit;
    }
  }
}

superClusterRef()

reco::SuperClusterRef PFCandidate::superClusterRef

(

)

const

return a reference to the corresponding SuperCluster if any

Definition at line 587 of file PFCandidate.cc.

References GETREF, kRefSuperClusterBit, and kRefSuperClusterMask.

Referenced by PFIsolationEstimator::fGetIsolationInRings(), PFIsolationEstimator::isPhotonParticleVetoed(), and PFIsolationEstimator::matchPFObject().

                                                       {
  GETREF(reco::SuperCluster, kRefSuperClusterMask, kRefSuperClusterBit);
}

time()

float reco::PFCandidate::time ( ) const

inline

Returns

the timing

Definition at line 423 of file PFCandidate.h.

References time_.

Referenced by TransientTrackBuilder::build(), and setTime().

{ return time_; }

timeError()

float reco::PFCandidate::timeError ( ) const

inline

Returns

the timing uncertainty

Definition at line 425 of file PFCandidate.h.

References timeError_.

Referenced by TransientTrackBuilder::build(), and setTime().

{ return timeError_; }

trackRef()

reco::TrackRef PFCandidate::trackRef

(

)

const

return a reference to the corresponding track, if charged. otherwise, return a null reference

Definition at line 437 of file PFCandidate.cc.

References GETREF, kRefTrackBit, and kRefTrackMask.

Referenced by PFMuonAlgo::addMissingMuons(), bestTrack(), reco::PFMETProducerMVA::chargedFracInCone(), PileupJetIdAlgo::computeIdVariables(), reco::PFMETProducerMVA::computePFCandidateInfo(), metsig::SignAlgoResolutions::evalPF(), TauDiscriminationAgainstElectronMVA6< TauType, TauDiscriminator, ElectronType >::getTauEtaAtECalEntrance(), pat::helper::VertexingHelper::getTrack_(), PFIsolationEstimator::isChargedParticleVetoed(), PFTauElecRejectionBenchmark::process(), reco::ParticleFlowForChargedMETProducer::produce(), HiBadParticleCleaner::produce(), PuppiProducer::produce(), pat::PATTauProducer::produce(), setMuonRef(), and vertexLegacy().

{ GETREF(reco::Track, kRefTrackMask, kRefTrackBit); }

translatePdgIdToType()

PFCandidate::ParticleType PFCandidate::translatePdgIdToType

(

int

pdgid

)

const

Definition at line 231 of file PFCandidate.cc.

References funct::abs(), e, egamma_HF, gamma, h, h0, h_HF, mu, EgammaValidation_cff::pdgid, and X.

Referenced by particleId(), DeltaBetaWeights::produce(), PuppiPhoton::produce(), PuppiProducer::produce(), SoftKillerProducer::produce(), HiFJRhoFlowModulationProducer::produce(), and VirtualJetProducer::writeJetsWithConstituents().

                                                                         {
  switch (std::abs(pdgid)) {
    case 211:
      return h;
    case 11:
      return e;
    case 13:
      return mu;
    case 22:
      return gamma;
    case 130:
      return h0;
    case 1:
      return h_HF;
    case 2:
      return egamma_HF;
    case 0:
      return X;
    default:
      return X;
  }
}

translateTypeToPdgId()

int PFCandidate::translateTypeToPdgId

(

ParticleType

type

)

const

returns the pdg id corresponding to the particle type. the particle type could be removed at some point to gain some space. low priority

Definition at line 254 of file PFCandidate.cc.

References reco::LeafCandidate::charge(), e, egamma_HF, gamma, h, h0, h_HF, mu, and X.

Referenced by PFCandidate(), and setParticleType().

                                                             {
  int thecharge = charge();

  switch (type) {
    case h:
      return thecharge * 211;  // pi+
    case e:
      return thecharge * (-11);
    case mu:
      return thecharge * (-13);
    case gamma:
      return 22;
    case h0:
      return 130;  // K_L0
    case h_HF:
      return 1;  // dummy pdg code
    case egamma_HF:
      return 2;  // dummy pdg code
    case X:
    default:
      return 0;
  }
}

v0Ref()

reco::VertexCompositeCandidateRef PFCandidate::v0Ref

(

)

const

return a reference to the original conversion

Definition at line 549 of file PFCandidate.cc.

References GETREF, kRefV0Bit, and kRefV0Mask.

                                                         {
  GETREF(reco::VertexCompositeCandidate, kRefV0Mask, kRefV0Bit);
}

vertex()

const math::XYZPoint & PFCandidate::vertex ( ) const

overridevirtual

vertex position (overwritten by PF...)

Reimplemented from reco::LeafCandidate.

Definition at line 60 of file PFCandidate.cc.

References vertexLegacy(), and vertexType_.

Referenced by FWPFCandidate3DProxyBuilder::build(), Tau.Tau::dxy(), vx(), vy(), and vz().

{ return vertexLegacy(vertexType_); }

vertexLegacy()

const math::XYZPoint & PFCandidate::vertexLegacy ( PFCandidate::PFVertexType  vertexType ) const

private

Definition at line 630 of file PFCandidate.cc.

References gsfTrackRef(), kCandVertex, kComMuonVertex, kDYTMuonVertex, kGSFVertex, kPickyMuonVertex, kSAMuonVertex, kTPFMSMuonVertex, kTrkMuonVertex, kTrkVertex, muonRef(), trackRef(), and reco::LeafCandidate::vertex().

Referenced by vertex().

                                                                                      {
  switch (vertexType) {
    case kCandVertex:
      return LeafCandidate::vertex();
      break;
    //the following cases will only be called for legacy AOD which does not have an embedded vertex
    case kTrkVertex:
      return trackRef()->vertex();
      break;
    case kComMuonVertex:
      return muonRef()->combinedMuon()->vertex();
      break;
    case kSAMuonVertex:
      return muonRef()->standAloneMuon()->vertex();
      break;
    case kTrkMuonVertex:
      return muonRef()->track()->vertex();
      break;
    case kTPFMSMuonVertex:
      return muonRef()->tpfmsTrack()->vertex();
      break;
    case kPickyMuonVertex:
      return muonRef()->pickyTrack()->vertex();
      break;
    case kDYTMuonVertex:
      return muonRef()->dytTrack()->vertex();
      break;

    case kGSFVertex:
      return gsfTrackRef()->vertex();
      break;
  }
  return LeafCandidate::vertex();
}

vx()

double reco::PFCandidate::vx ( ) const

inlineoverridevirtual

x coordinate of vertex position

Reimplemented from reco::LeafCandidate.

Definition at line 416 of file PFCandidate.h.

References vertex().

Referenced by PFIsolationEstimator::fGetIsolationInRings().

{ return vertex().x(); }

vy()

double reco::PFCandidate::vy ( ) const

inlineoverridevirtual

y coordinate of vertex position

Reimplemented from reco::LeafCandidate.

Definition at line 417 of file PFCandidate.h.

References vertex().

Referenced by PFIsolationEstimator::fGetIsolationInRings().

{ return vertex().y(); }

vz()

double reco::PFCandidate::vz ( ) const

inlineoverridevirtual

z coordinate of vertex position

Reimplemented from reco::LeafCandidate.

Definition at line 418 of file PFCandidate.h.

References vertex().

Referenced by PFIsolationEstimator::fGetIsolationInRings().

{ return vertex().z(); }

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  out, const PFCandidate &  c  )

friend

Member Data Documentation

bigMva_

constexpr float reco::PFCandidate::bigMva_ = -999.

static

Definition at line 411 of file PFCandidate.h.

blocksStorage_

Blocks reco::PFCandidate::blocksStorage_

private

Definition at line 455 of file PFCandidate.h.

Referenced by addElementInBlock(), elementsInBlocks(), operator=(), and PFCandidate().

deltaP_

float reco::PFCandidate::deltaP_

private

uncertainty on 3-momentum

Definition at line 494 of file PFCandidate.h.

Referenced by deltaP(), operator=(), and setDeltaP().

dnn_e_bkgNonIsolated_

float reco::PFCandidate::dnn_e_bkgNonIsolated_

private

DNN for electron PFid: non-isolated bkg.

Definition at line 527 of file PFCandidate.h.

Referenced by dnn_e_bkgNonIsolated(), operator=(), and set_dnn_e_bkgNonIsolated().

dnn_e_bkgPhoton_

float reco::PFCandidate::dnn_e_bkgPhoton_

private

DNN for electron PFid: photon bkg.

Definition at line 533 of file PFCandidate.h.

Referenced by dnn_e_bkgPhoton(), operator=(), and set_dnn_e_bkgPhoton().

dnn_e_bkgTau_

float reco::PFCandidate::dnn_e_bkgTau_

private

DNN for electron PFid: tau bkg.

Definition at line 530 of file PFCandidate.h.

Referenced by dnn_e_bkgTau(), operator=(), and set_dnn_e_bkgTau().

dnn_e_sigIsolated_

float reco::PFCandidate::dnn_e_sigIsolated_

private

DNN for electron PFid: isolated signal.

Definition at line 521 of file PFCandidate.h.

Referenced by dnn_e_sigIsolated(), operator=(), and set_dnn_e_sigIsolated().

dnn_e_sigNonIsolated_

float reco::PFCandidate::dnn_e_sigNonIsolated_

private

DNN for electron PFid: non-isolated signal.

Definition at line 524 of file PFCandidate.h.

Referenced by dnn_e_sigNonIsolated(), operator=(), and set_dnn_e_sigNonIsolated().

dnn_gamma_

float reco::PFCandidate::dnn_gamma_

private

Definition at line 536 of file PFCandidate.h.

Referenced by dnn_gamma(), operator=(), and set_dnn_gamma().

ecalERatio_

float reco::PFCandidate::ecalERatio_

private

corrected ECAL energy ratio (corrected/raw)

Definition at line 467 of file PFCandidate.h.

Referenced by ecalEnergy(), operator=(), and setEcalEnergy().

elementsInBlocks_

std::atomic<ElementsInBlocks*> reco::PFCandidate::elementsInBlocks_

mutableprivate

Definition at line 451 of file PFCandidate.h.

Referenced by addElementInBlock(), elementsInBlocks(), operator=(), PFCandidate(), and ~PFCandidate().

elementsStorage_

Elements reco::PFCandidate::elementsStorage_

private

Definition at line 456 of file PFCandidate.h.

Referenced by addElementInBlock(), elementsInBlocks(), operator=(), and PFCandidate().

flags_

unsigned reco::PFCandidate::flags_

private

all flags, packed (ecal regional, hcal regional, tracking)

Definition at line 491 of file PFCandidate.h.

Referenced by flag(), operator=(), and setFlag().

getter_

const edm::EDProductGetter* reco::PFCandidate::getter_

private

Definition at line 551 of file PFCandidate.h.

Referenced by operator=(), and storeRefInfo().

hcalDepthEnergyFractions_

std::array<float, 7> reco::PFCandidate::hcalDepthEnergyFractions_

private

Definition at line 561 of file PFCandidate.h.

Referenced by hcalDepthEnergyFraction(), hcalDepthEnergyFractions(), operator=(), PFCandidate(), and setHcalDepthEnergyFractions().

hcalERatio_

float reco::PFCandidate::hcalERatio_

private

corrected HCAL energy ratio (corrected/raw)

Definition at line 470 of file PFCandidate.h.

Referenced by hcalEnergy(), operator=(), and setHcalEnergy().

hoERatio_

float reco::PFCandidate::hoERatio_

private

corrected HO energy ratio (corrected/raw)

Definition at line 473 of file PFCandidate.h.

Referenced by hoEnergy(), operator=(), and setHoEnergy().

muonTrackType_

reco::Muon::MuonTrackType reco::PFCandidate::muonTrackType_

private

Reference to the best track if it is a muon pF is allowed to switch the default muon track

Definition at line 464 of file PFCandidate.h.

Referenced by bestMuonTrackType(), operator=(), PFCandidate(), and setMuonTrackType().

mva_e_mu_

float reco::PFCandidate::mva_e_mu_

private

mva for electron-muon discrimination

Definition at line 506 of file PFCandidate.h.

Referenced by mva_e_mu(), operator=(), and set_mva_e_mu().

mva_e_pi_

float reco::PFCandidate::mva_e_pi_

private

mva for electron-pion discrimination

Definition at line 503 of file PFCandidate.h.

Referenced by mva_e_pi(), operator=(), and set_mva_e_pi().

mva_gamma_nh_

float reco::PFCandidate::mva_gamma_nh_

private

mva for neutral hadron - gamma discrimination

Definition at line 518 of file PFCandidate.h.

Referenced by mva_gamma_nh(), operator=(), and set_mva_gamma_nh().

mva_Isolated_

float reco::PFCandidate::mva_Isolated_

private

Definition at line 500 of file PFCandidate.h.

Referenced by mva_Isolated(), operator=(), and set_mva_Isolated().

mva_nothing_gamma_

float reco::PFCandidate::mva_nothing_gamma_

private

mva for gamma detection

Definition at line 512 of file PFCandidate.h.

Referenced by mva_nothing_gamma(), operator=(), and set_mva_nothing_gamma().

mva_nothing_nh_

float reco::PFCandidate::mva_nothing_nh_

private

mva for neutral hadron detection

Definition at line 515 of file PFCandidate.h.

Referenced by mva_nothing_nh(), operator=(), and set_mva_nothing_nh().

mva_pi_mu_

float reco::PFCandidate::mva_pi_mu_

private

mva for pi-muon discrimination

Definition at line 509 of file PFCandidate.h.

Referenced by mva_pi_mu(), operator=(), and set_mva_pi_mu().

positionAtECALEntrance_

math::XYZPointF reco::PFCandidate::positionAtECALEntrance_

private

position at ECAL entrance, from the PFRecTrack

Definition at line 539 of file PFCandidate.h.

Referenced by operator=(), positionAtECALEntrance(), and setPositionAtECALEntrance().

ps1Energy_

float reco::PFCandidate::ps1Energy_

private

corrected PS1 energy

Definition at line 485 of file PFCandidate.h.

Referenced by operator=(), pS1Energy(), and setPs1Energy().

ps2Energy_

float reco::PFCandidate::ps2Energy_

private

corrected PS2 energy

Definition at line 488 of file PFCandidate.h.

Referenced by operator=(), pS2Energy(), and setPs2Energy().

rawEcalEnergy_

float reco::PFCandidate::rawEcalEnergy_

private

raw ECAL energy

Definition at line 476 of file PFCandidate.h.

Referenced by ecalEnergy(), operator=(), rawEcalEnergy(), and setEcalEnergy().

rawHcalEnergy_

float reco::PFCandidate::rawHcalEnergy_

private

raw HCAL energy

Definition at line 479 of file PFCandidate.h.

Referenced by hcalEnergy(), operator=(), rawHcalEnergy(), and setHcalEnergy().

rawHoEnergy_

float reco::PFCandidate::rawHoEnergy_

private

raw HO energy

Definition at line 482 of file PFCandidate.h.

Referenced by hoEnergy(), operator=(), rawHoEnergy(), and setHoEnergy().

refsCollectionCache_

std::vector<const void*> reco::PFCandidate::refsCollectionCache_

private

Definition at line 554 of file PFCandidate.h.

Referenced by operator=(), and storeRefInfo().

refsInfo_

std::vector<unsigned long long> reco::PFCandidate::refsInfo_

private

Definition at line 553 of file PFCandidate.h.

Referenced by getRefInfo(), operator=(), PFCandidate(), and storeRefInfo().

sourcePtr_

PFCandidatePtr reco::PFCandidate::sourcePtr_

private

reference to the source PFCandidate, if any

Definition at line 460 of file PFCandidate.h.

Referenced by operator=(), overlap(), PFCandidate(), setSourceCandidatePtr(), and sourceCandidatePtr().

storedRefsBitPattern_

unsigned short reco::PFCandidate::storedRefsBitPattern_

private

Definition at line 552 of file PFCandidate.h.

Referenced by getRefInfo(), operator=(), and storeRefInfo().

time_

float reco::PFCandidate::time_

private

timing information (valid if timeError_ >= 0)

Definition at line 557 of file PFCandidate.h.

Referenced by operator=(), setTime(), and time().

timeError_

float reco::PFCandidate::timeError_

private

timing information uncertainty (<0 if timing not available)

Definition at line 559 of file PFCandidate.h.

Referenced by isTimeValid(), operator=(), setTime(), and timeError().

vertexType_

PFVertexType reco::PFCandidate::vertexType_

private

Definition at line 497 of file PFCandidate.h.

Referenced by operator=(), and vertex().