Reference Manual

pat::PackedCandidate::egammaFlagsMask

uint16_t qualityFlags_

Definition: PackedCandidate.h:1075

◆ isGoodEgamma()

bool pat::PackedCandidate::isGoodEgamma ( ) const

inline

Definition at line 927 of file PackedCandidate.h.

References egammaFlagsMask, and qualityFlags_.

Referenced by setGoodEgamma().

927 { return (qualityFlags_ & egammaFlagsMask) != 0; }

Definition: PackedCandidate.h:1128

pat::PackedCandidate::muonFlagsMask

uint16_t qualityFlags_

Definition: PackedCandidate.h:1075

◆ isIsolatedChargedHadron()

bool pat::PackedCandidate::isIsolatedChargedHadron ( ) const

inline

Set isolation (as in particle flow, i.e. at calorimeter surface rather than at PV) flat for charged hadrons

Definition at line 959 of file PackedCandidate.h.

                                          {
       return isIsolatedChargedHadron_;
     }  

◆ isJet()

bool pat::PackedCandidate::isJet ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 926 of file PackedCandidate.h.

926 { return false; }

◆ isMuon()

bool pat::PackedCandidate::isMuon ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 919 of file PackedCandidate.h.

919 { return false; }

◆ isPhoton()

bool pat::PackedCandidate::isPhoton ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 924 of file PackedCandidate.h.

924 { return false; }

◆ isStandAloneMuon()

bool pat::PackedCandidate::isStandAloneMuon ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 920 of file PackedCandidate.h.

References muonFlagsMask, muonFlagsShift, and qualityFlags_.

920 { return ((qualityFlags_ & muonFlagsMask) >> muonFlagsShift) & 1; }

Definition: PackedCandidate.h:1126

pat::PackedCandidate::muonFlagsShift

Definition: PackedCandidate.h:1127

pat::PackedCandidate::pixelLayersWithMeasurement

uint16_t qualityFlags_

Definition: PackedCandidate.h:1075

◆ isTrackerMuon()

bool pat::PackedCandidate::isTrackerMuon ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 922 of file PackedCandidate.h.

922 { return false; }

◆ longLived()

bool pat::PackedCandidate::longLived ( ) const

overridevirtual

is long lived?

Implements reco::Candidate.

Definition at line 419 of file PackedCandidate.cc.

419 { return false; }

◆ lostInnerHits()

LostInnerHits pat::PackedCandidate::lostInnerHits ( ) const

inline

Definition at line 824 of file PackedCandidate.h.

References lostInnerHitsMask, lostInnerHitsShift, and qualityFlags_.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

                                         {
       return LostInnerHits(int16_t((qualityFlags_ & lostInnerHitsMask) >> lostInnerHitsShift) - 1);
     }

◆ mass()

double pat::PackedCandidate::mass ( ) const

inlineoverridevirtual

mass

Implements reco::Candidate.

Definition at line 479 of file PackedCandidate.h.

References p4_, p4c_, and unpack().

Referenced by Particle.Particle::__str__(), and DiObject.DiMuon::__str__().

                                  {
       if (!p4c_)
         unpack();
       return p4_.load()->M();
     }

◆ massConstraint()

bool pat::PackedCandidate::massConstraint ( ) const

overridevirtual

do mass constraint?

Implements reco::Candidate.

Definition at line 421 of file PackedCandidate.cc.

421 { return false; }

◆ massSqr()

double pat::PackedCandidate::massSqr ( ) const

inlineoverridevirtual

mass squared

Implements reco::Candidate.

Definition at line 485 of file PackedCandidate.h.

References visualization-live-secondInstance_cfg::m, p4_, p4c_, and unpack().

                                     {
       if (!p4c_)
         unpack();
       auto m = p4_.load()->M();
       return m * m;
     }

◆ masterClone()

const reco::CandidateBaseRef & pat::PackedCandidate::masterClone ( ) const

overridevirtual

returns ptr to master clone, if existing. Throws an exception unless the concrete Candidate type is ShallowCloneCandidate

Implements reco::Candidate.

Definition at line 360 of file PackedCandidate.cc.

References Exception.

Referenced by masterRef().

                                                                   {
   throw cms::Exception("Invalid Reference") << "this Candidate has no master clone reference."
                                             << "Can't call masterClone() method.\n";
 }

◆ masterClonePtr()

const reco::CandidatePtr & pat::PackedCandidate::masterClonePtr ( ) const

overridevirtual

returns ptr to master clone, if existing. Throws an exception unless the concrete Candidate type is ShallowClonePtrCandidate

Implements reco::Candidate.

Definition at line 369 of file PackedCandidate.cc.

References Exception.

                                                                  {
   throw cms::Exception("Invalid Reference") << "this Candidate has no master clone ptr."
                                             << "Can't call masterClonePtr() method.\n";
 }

◆ masterRef()

template<typename Ref >

Ref pat::PackedCandidate::masterRef ( ) const

inline

cast master clone reference to a concrete type

Definition at line 914 of file PackedCandidate.h.

References masterClone().

                           {
       return masterClone().template castTo<Ref>();
     }

◆ maybeUnpackBoth()

void pat::PackedCandidate::maybeUnpackBoth ( ) const

inlineprotected

Definition at line 1027 of file PackedCandidate.h.

References p4c_, unpack(), unpackVtx(), and vertex_.

Referenced by dxy(), dz(), dzAssociatedPV(), etaAtVtx(), phiAtVtx(), ptTrk(), setP4(), setPz(), setTrackProperties(), setVertex(), vertex(), vx(), vy(), and vz().

                                  {
       if (!p4c_)
         unpack();
       if (!vertex_)
         unpackVtx();
     }

◆ maybeUnpackCovariance()

void pat::PackedCandidate::maybeUnpackCovariance ( ) const

inlineprotected

Definition at line 1037 of file PackedCandidate.h.

References m_, and unpackCovariance().

Referenced by dxyError(), and dzError().

                                        {
       if (!m_)
         unpackCovariance();
     }

◆ maybeUnpackTrack()

void pat::PackedCandidate::maybeUnpackTrack ( ) const

inlineprotected

Definition at line 1033 of file PackedCandidate.h.

References track_, and unpackTrk().

Referenced by bestTrack().

                                   {
       if (!track_)
         unpackTrk();
     }

◆ momentum()

Vector pat::PackedCandidate::momentum ( ) const

inlineoverridevirtual

spatial momentum vector

Implements reco::Candidate.

Definition at line 450 of file PackedCandidate.h.

References p4c_, and unpack().

                                      {
       if (!p4c_)
         unpack();
       return p4c_.load()->Vect();
     }

◆ mother()

const reco::Candidate * pat::PackedCandidate::mother ( size_type ) const

overridevirtual

return mother at a given position (throws an exception)

Implements reco::Candidate.

Definition at line 385 of file PackedCandidate.cc.

385 { return nullptr; }

◆ mt()

double pat::PackedCandidate::mt ( ) const

inlineoverridevirtual

transverse mass

Implements reco::Candidate.

Definition at line 493 of file PackedCandidate.h.

References p4_, p4c_, and unpack().

                                {
       if (!p4c_)
         unpack();
       return p4_.load()->Mt();
     }

◆ mtSqr()

double pat::PackedCandidate::mtSqr ( ) const

inlineoverridevirtual

transverse mass squared

Implements reco::Candidate.

Definition at line 499 of file PackedCandidate.h.

References p4_, p4c_, and unpack().

                                   {
       if (!p4c_)
         unpack();
       return p4_.load()->Mt2();
     }

◆ numberOfDaughters()

size_t pat::PackedCandidate::numberOfDaughters ( ) const

overridevirtual

number of daughters

Implements reco::Candidate.

Definition at line 374 of file PackedCandidate.cc.

374 { return 0; }

◆ numberOfHits()

int pat::PackedCandidate::numberOfHits ( ) const

inline

Definition at line 675 of file PackedCandidate.h.

References numberOfPixelHits(), packedHits_, stripLayersWithMeasurement(), and trackStripHitsShift.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures(), packCovarianceElement(), and unpackCovarianceElement().

                              {
       return (packedHits_ >> trackStripHitsShift) + stripLayersWithMeasurement() + numberOfPixelHits();
     }

◆ numberOfMothers()

size_t pat::PackedCandidate::numberOfMothers ( ) const

overridevirtual

number of mothers

Implements reco::Candidate.

Definition at line 376 of file PackedCandidate.cc.

376 { return 0; }

◆ numberOfPixelHits()

int pat::PackedCandidate::numberOfPixelHits ( ) const

inline

Definition at line 674 of file PackedCandidate.h.

References packedHits_, pixelLayersWithMeasurement(), and trackPixelHitsMask.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures(), numberOfHits(), packCovarianceElement(), and unpackCovarianceElement().

674 { return (packedHits_ & trackPixelHitsMask) + pixelLayersWithMeasurement(); }

int pixelLayersWithMeasurement() const

Definition: PackedCandidate.h:678

pat::PackedCandidate::trackPixelHitsMask

Definition: PackedCandidate.h:620

pat::PackedCandidate::packedHits_

uint8_t packedHits_

Definition: PackedCandidate.h:1082

◆ numberOfSourceCandidatePtrs()

size_t pat::PackedCandidate::numberOfSourceCandidatePtrs ( ) const

inlineoverridevirtual

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

Implements reco::Candidate.

Definition at line 409 of file PackedCandidate.h.

409 { return 0; }

◆ operator=() [1/2]

PackedCandidate& pat::PackedCandidate::operator= ( const PackedCandidate & iOther )

inline

Definition at line 267 of file PackedCandidate.h.

References caloFraction_, covarianceSchema_, covarianceVersion_, deta_, dphi_, dtrkpt_, dxy_, dz_, firstHit_, hcalFraction_, isIsolatedChargedHadron_, m_, normalizedChi2_, p4(), p4_, p4c_, packedCovariance_, packedDEta_, packedDPhi_, packedDTrkPt_, packedDxy_, packedDz_, packedEta_, packedHits_, packedLayers_, packedM_, packedPhi_, packedPt_, packedPuppiweight_, packedPuppiweightNoLepDiff_, packedTime_, packedTimeError_, pdgId_, polarP4(), pvRefKey_, pvRefProd_, qualityFlags_, rawCaloFraction_, rawHcalFraction_, track_, vertex(), and vertex_.

                                                               {
       if (this == &iOther) {
         return *this;
       }
       packedPt_ = iOther.packedPt_;
       packedEta_ = iOther.packedEta_;
       packedPhi_ = iOther.packedPhi_;
       packedM_ = iOther.packedM_;
       packedDxy_ = iOther.packedDxy_;
       packedDz_ = iOther.packedDz_;
       packedDPhi_ = iOther.packedDPhi_;
       packedDEta_ = iOther.packedDEta_;
       packedDTrkPt_ = iOther.packedDTrkPt_;
       packedCovariance_ = iOther.packedCovariance_;
       packedPuppiweight_ = iOther.packedPuppiweight_;
       packedPuppiweightNoLepDiff_ = iOther.packedPuppiweightNoLepDiff_;
       rawCaloFraction_ = iOther.rawCaloFraction_;
       rawHcalFraction_ = iOther.rawHcalFraction_;
       caloFraction_ = iOther.caloFraction_;
       hcalFraction_ = iOther.hcalFraction_;
       packedTime_ = iOther.packedTime_;
       packedTimeError_ = iOther.packedTimeError_;
       isIsolatedChargedHadron_ = iOther.isIsolatedChargedHadron_;
       // Need to trigger unpacking in iOther
       if (p4_) {
         *p4_ = iOther.polarP4();
       } else {
         p4_.store(new PolarLorentzVector(iOther.polarP4()));
       }
       if (p4c_) {
         *p4c_ = iOther.p4();
       } else {
         p4c_.store(new LorentzVector(iOther.p4()));
       }
       if (vertex_) {
         *vertex_ = iOther.vertex();
       } else {
         vertex_.store(new Point(iOther.vertex()));
       }
       dxy_ = iOther.dxy_;
       dz_ = iOther.dz_;
       dphi_ = iOther.dphi_;
       deta_ = iOther.deta_;
       dtrkpt_ = iOther.dtrkpt_;
 
       if (!iOther.track_) {
         delete track_.exchange(nullptr);
       } else {
         if (!track_) {
           track_.store(new reco::Track(*iOther.track_));
         } else {
           *track_ = *(iOther.track_);
         }
       }
 
       pdgId_ = iOther.pdgId_;
       qualityFlags_ = iOther.qualityFlags_;
       pvRefProd_ = iOther.pvRefProd_;
       pvRefKey_ = iOther.pvRefKey_;
       if (!iOther.m_) {
         delete m_.exchange(nullptr);
       } else {
         if (!m_) {
           m_.store(new reco::Track::CovarianceMatrix(*iOther.m_));
         } else {
           *m_ = *(iOther.m_);
         }
       }
 
       packedHits_ = iOther.packedHits_;
       packedLayers_ = iOther.packedLayers_;
       normalizedChi2_ = iOther.normalizedChi2_;
       covarianceVersion_ = iOther.covarianceVersion_;
       covarianceSchema_ = iOther.covarianceSchema_;
       firstHit_ = iOther.firstHit_;
       return *this;
     }

◆ operator=() [2/2]

PackedCandidate& pat::PackedCandidate::operator= ( PackedCandidate && iOther )

inline

Definition at line 345 of file PackedCandidate.h.

References caloFraction_, covarianceSchema_, covarianceVersion_, deta_, dphi_, dtrkpt_, dxy_, dz_, firstHit_, hcalFraction_, isIsolatedChargedHadron_, m_, normalizedChi2_, p4_, p4c_, packedCovariance_, packedDEta_, packedDPhi_, packedDTrkPt_, packedDxy_, packedDz_, packedEta_, packedHits_, packedLayers_, packedM_, packedPhi_, packedPt_, packedPuppiweight_, packedPuppiweightNoLepDiff_, packedTime_, packedTimeError_, pdgId_, pvRefKey_, pvRefProd_, qualityFlags_, rawCaloFraction_, rawHcalFraction_, track_, and vertex_.

                                                          {
       if (this == &iOther) {
         return *this;
       }
       packedPt_ = iOther.packedPt_;
       packedEta_ = iOther.packedEta_;
       packedPhi_ = iOther.packedPhi_;
       packedM_ = iOther.packedM_;
       packedDxy_ = iOther.packedDxy_;
       packedDz_ = iOther.packedDz_;
       packedDPhi_ = iOther.packedDPhi_;
       packedDEta_ = iOther.packedDEta_;
       packedDTrkPt_ = iOther.packedDTrkPt_;
       packedCovariance_ = iOther.packedCovariance_;
       packedPuppiweight_ = iOther.packedPuppiweight_;
       packedPuppiweightNoLepDiff_ = iOther.packedPuppiweightNoLepDiff_;
       rawCaloFraction_ = iOther.rawCaloFraction_;
       rawHcalFraction_ = iOther.rawHcalFraction_;
       caloFraction_ = iOther.caloFraction_;
       hcalFraction_ = iOther.hcalFraction_;
       packedTime_ = iOther.packedTime_;
       packedTimeError_ = iOther.packedTimeError_;
       isIsolatedChargedHadron_ = iOther.isIsolatedChargedHadron_;
       delete p4_.exchange(iOther.p4_.exchange(nullptr));
       delete p4c_.exchange(iOther.p4c_.exchange(nullptr));
       delete vertex_.exchange(iOther.vertex_.exchange(nullptr));
       dxy_ = iOther.dxy_;
       dz_ = iOther.dz_;
       dphi_ = iOther.dphi_;
       deta_ = iOther.deta_;
       dtrkpt_ = iOther.dtrkpt_;
       delete track_.exchange(iOther.track_.exchange(nullptr));
       pdgId_ = iOther.pdgId_;
       qualityFlags_ = iOther.qualityFlags_;
       pvRefProd_ = iOther.pvRefProd_;
       pvRefKey_ = iOther.pvRefKey_;
       delete m_.exchange(iOther.m_.exchange(nullptr));
       packedHits_ = iOther.packedHits_;
       packedLayers_ = iOther.packedLayers_;
       normalizedChi2_ = iOther.normalizedChi2_;
       covarianceVersion_ = iOther.covarianceVersion_;
       covarianceSchema_ = iOther.covarianceSchema_;
       firstHit_ = iOther.firstHit_;
       return *this;
     }

◆ overlap()

bool pat::PackedCandidate::overlap ( const reco::Candidate & o ) const

overrideprotectedvirtual

check overlap with another Candidate

Implements reco::Candidate.

Definition at line 378 of file PackedCandidate.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, EcalTangentSkim_cfg::o, and bphysicsOniaDQM_cfi::vertex.

                                                              {
   return p4() == o.p4() && vertex() == o.vertex() && charge() == o.charge();
   //  return  p4() == o.p4() && charge() == o.charge();
 }

◆ p()

double pat::PackedCandidate::p ( ) const

inlineoverridevirtual

magnitude of momentum vector

Implements reco::Candidate.

Definition at line 463 of file PackedCandidate.h.

References p4c_, and unpack().

Referenced by AntiElectronIDMVA6< TauType, ElectronType >::getTauVarsTypeSpecific(), and Electron.Electron::ptErr().

                               {
       if (!p4c_)
         unpack();
       return p4c_.load()->P();
     }

◆ p4()

const LorentzVector& pat::PackedCandidate::p4 ( ) const

inlineoverridevirtual

four-momentum Lorentz vecto r

Implements reco::Candidate.

Definition at line 438 of file PackedCandidate.h.

References p4c_, and unpack().

Referenced by Tau.Tau::dxy_approx(), Tau.Tau::dz(), operator=(), Lepton.Lepton::p4WithFSR(), pat::PATIsolatedTrackProducer::produce(), and setP4().

                                              {
       if (!p4c_)
         unpack();
       return *p4c_;
     }

◆ pack()

void pat::PackedCandidate::pack ( bool unpackAfterwards = true )

protected

Definition at line 16 of file PackedCandidate.cc.

References MiniFloatConverter::float32to16(), MiniFloatConverter::max(), SiStripPI::max, and BeamSpotPI::unpack().

Referenced by packBoth(), and setMass().

                                                    {
   float unpackedPt = std::min<float>(p4_.load()->Pt(), MiniFloatConverter::max());
   packedPt_ = MiniFloatConverter::float32to16(unpackedPt);
   packedEta_ = int16_t(std::round(p4_.load()->Eta() / 6.0f * std::numeric_limits<int16_t>::max()));
   packedPhi_ = int16_t(std::round(p4_.load()->Phi() / 3.2f * std::numeric_limits<int16_t>::max()));
   packedM_ = MiniFloatConverter::float32to16(p4_.load()->M());
   if (unpackAfterwards) {
     delete p4_.exchange(nullptr);
     delete p4c_.exchange(nullptr);
     unpack();  // force the values to match with the packed ones
   }
 }

◆ packBoth()

void pat::PackedCandidate::packBoth ( )

inlineprotected

Definition at line 1041 of file PackedCandidate.h.

References p4_, p4c_, pack(), packVtx(), unpack(), unpackVtx(), and vertex_.

Referenced by PackedCandidate(), setP4(), setPz(), and setTrackProperties().

                     {
       pack(false);
       packVtx(false);
       delete p4_.exchange(nullptr);
       delete p4c_.exchange(nullptr);
       delete vertex_.exchange(nullptr);
       unpack();
       unpackVtx();
     }  // do it this way, so that we don't loose precision on the angles before

◆ packCovariance()

void pat::PackedCandidate::packCovariance	(	const reco::TrackBase::CovarianceMatrix &	m,
		bool	unpackAfterwards = `true`
	)

protected

Definition at line 81 of file PackedCandidate.cc.

References visualization-live-secondInstance_cfg::m.

Referenced by setTrackProperties().

                                                                                                      {
   packedCovariance_.dptdpt = packCovarianceElement(m, 0, 0);
   packedCovariance_.detadeta = packCovarianceElement(m, 1, 1);
   packedCovariance_.dphidphi = packCovarianceElement(m, 2, 2);
   packedCovariance_.dxydxy = packCovarianceElement(m, 3, 3);
   packedCovariance_.dzdz = packCovarianceElement(m, 4, 4);
   packedCovariance_.dxydz = packCovarianceElement(m, 3, 4);
   packedCovariance_.dlambdadz = packCovarianceElement(m, 1, 4);
   packedCovariance_.dphidxy = packCovarianceElement(m, 2, 3);
   // unpack afterwards
   if (unpackAfterwards)
     unpackCovariance();
 }

◆ packCovarianceElement()

uint16_t pat::PackedCandidate::packCovarianceElement	(	const reco::TrackBase::CovarianceMatrix &	m,
		int	i,
		int	j
	)		const

inlineprivate

Definition at line 1007 of file PackedCandidate.h.

References covarianceParameterization(), covarianceSchema_, eta(), mps_fire::i, dqmiolumiharvest::j, visualization-live-secondInstance_cfg::m, numberOfHits(), numberOfPixelHits(), CovarianceParameterization::pack(), and pt().

                                                                                                {
       return covarianceParameterization().pack(
           m(i, j), covarianceSchema_, i, j, pt(), eta(), numberOfHits(), numberOfPixelHits());
     }

◆ packTimeError()

uint8_t pat::PackedCandidate::packTimeError ( float timeError )

staticprotected

static to allow unit testing

Definition at line 470 of file PackedCandidate.cc.

References f, and SiStripPI::min.

                                                          {
   if (timeError <= 0)
     return 0;
   // log-scale packing.
   // for MIN_TIMEERROR = 0.002, EXPO_TIMEERROR = 5:
   //      minimum value 0.002 = 2ps (packed as 1)
   //      maximum value 0.5 ns      (packed as 255)
   //      constant *relative* precision of about 2%
   return std::max<uint8_t>(
       std::min(std::round(std::ldexp(std::log2(timeError / MIN_TIMEERROR), +EXPO_TIMEERROR)), 255.f), 1);
 }

◆ packTimeNoError()

int16_t pat::PackedCandidate::packTimeNoError ( float time )

staticprotected

Definition at line 490 of file PackedCandidate.cc.

References funct::abs(), f, SiStripPI::min, and protons_cff::time.

                                                       {
   // encoding in log scale to store times in a large range with few bits.
   // for MIN_TIME_NOERROR = 0.0002 and EXPO_TIME_NOERROR = 6:
   //    smallest non-zero time = 0.2 ps (encoded as +/-1)
   //    one BX, +/- 12.5 ns, is fully covered with 11 bits (+/- 1023)
   //    12 bits cover by far any plausible value (+/-2047 corresponds to about
   //    +/- 0.8 ms!) constant *relative* ~1% precision
   if (std::abs(time) < MIN_TIME_NOERROR)
     return 0;  // prevent underflows
   float fpacked = std::ldexp(std::log2(std::abs(time / MIN_TIME_NOERROR)), +EXPO_TIME_NOERROR);
   return (time > 0 ? +1 : -1) * std::min(std::round(fpacked), 2047.f);
 }

◆ packTimeWithError()

int16_t pat::PackedCandidate::packTimeWithError	(	float	time,
		float	timeError
	)

staticprotected

Definition at line 511 of file PackedCandidate.cc.

References funct::abs(), f, and protons_cff::time.

                                                                          {
   // Encode in units of timeError * 2^EXPO_TIME_WITHERROR (~1.6% if
   // EXPO_TIME_WITHERROR = -6) the largest value that can be stored in 14 bits +
   // sign bit + overflow bit is about 260 sigmas values larger than that will be
   // stored using the no-timeError packing (with less precision). overflows of
   // these kinds should happen only for particles that are late arriving,
   // out-of-time, or mis-reconstructed, as timeError is O(20ps) and the beam
   // spot witdth is O(200ps)
   float fpacked = std::round(time / std::ldexp(timeError, EXPO_TIME_WITHERROR));
   if (std::abs(fpacked) < 16383.f) {  // 16383 = (2^14 - 1) = largest absolute
                                       // value for a signed 15 bit integer
     return int16_t(fpacked) * 2;      // make it even, and fit in a signed 16 bit int
   } else {
     int16_t packed = packTimeNoError(time);    // encode
     return packed * 2 + (time > 0 ? +1 : -1);  // make it odd, to signal that there was an overlow
   }
 }

◆ packVtx()

void pat::PackedCandidate::packVtx ( bool unpackAfterwards = true )

protected

Definition at line 29 of file PackedCandidate.cc.

References c, funct::cos(), f, MiniFloatConverter::float32to16(), edm::Ref< C, T, F >::isNonnull(), SiStripPI::max, MetAnalyzer::pv(), alignCSCRings::s, and funct::sin().

Referenced by packBoth(), and setVertex().

                                                       {
   reco::VertexRef pvRef = vertexRef();
   Point pv = pvRef.isNonnull() ? pvRef->position() : Point();
   float dxPV = vertex_.load()->X() - pv.X(),
         dyPV = vertex_.load()->Y() - pv.Y();  //, rPV = std::hypot(dxPV, dyPV);
   float s = std::sin(float(p4_.load()->Phi()) + dphi_),
         c = std::cos(float(p4_.load()->Phi() + dphi_));  // not the fastest option, but we're in reduced
                                                          // precision already, so let's avoid more roundoffs
   dxy_ = -dxPV * s + dyPV * c;
   // if we want to go back to the full x,y,z we need to store also
   // float dl = dxPV * c + dyPV * s;
   // float xRec = - dxy_ * s + dl * c, yRec = dxy_ * c + dl * s;
   float pzpt = p4_.load()->Pz() / p4_.load()->Pt();
   dz_ = vertex_.load()->Z() - pv.Z() - (dxPV * c + dyPV * s) * pzpt;
   packedDxy_ = MiniFloatConverter::float32to16(dxy_ * 100);
   packedDz_ = pvRef.isNonnull() ? MiniFloatConverter::float32to16(dz_ * 100)
                                 : int16_t(std::round(dz_ / 40.f * std::numeric_limits<int16_t>::max()));
   packedDPhi_ = int16_t(std::round(dphi_ / 3.2f * std::numeric_limits<int16_t>::max()));
   packedDEta_ = MiniFloatConverter::float32to16(deta_);
   packedDTrkPt_ = MiniFloatConverter::float32to16(dtrkpt_);
 
   if (unpackAfterwards) {
     delete vertex_.exchange(nullptr);
     unpackVtx();
   }
 }

◆ pdgId()

int pat::PackedCandidate::pdgId ( ) const

inlineoverridevirtual

PDG identifier.

Implements reco::Candidate.

Definition at line 851 of file PackedCandidate.h.

References pdgId_.

Referenced by Particle.Particle::__str__(), TauDiscriminationAgainstElectronMVA6< TauType, TauDiscriminator, ElectronType >::discriminate(), fromPV(), AntiElectronIDMVA6< TauType, ElectronType >::getTauVars(), PATPuppiJetSpecificProducer::produce(), PuppiProducer::produce(), pat::PATIsolatedTrackProducer::produce(), and setPdgId().

851 { return pdgId_; }

pat::PackedCandidate::pdgId_

int pdgId_

PDG identifier.

Definition: PackedCandidate.h:1074

◆ phi()

double pat::PackedCandidate::phi ( ) const

inlineoverridevirtual

momentum azimuthal angle

Implements reco::Candidate.

Definition at line 529 of file PackedCandidate.h.

References p4_, p4c_, and unpack().

Referenced by Particle.Particle::__str__(), reco::tau::qcuts::minPackedCandVertexWeight(), ntupleDataFormat.Track::phiPull(), and pat::PATTauProducer::produce().

                                 {
       if (!p4c_)
         unpack();
       return p4_.load()->Phi();
     }

◆ phiAtVtx()

virtual float pat::PackedCandidate::phiAtVtx ( ) const

inlinevirtual

momentum azimuthal angle from the track (normally identical to phi())

Definition at line 541 of file PackedCandidate.h.

References dphi_, dqmMemoryStats::float, M_PI, maybeUnpackBoth(), p4_, and runTheMatrix::ret.

                                    {
       maybeUnpackBoth();
       float ret = p4_.load()->Phi() + dphi_;
       while (ret > float(M_PI))
         ret -= 2 * float(M_PI);
       while (ret < -float(M_PI))
         ret += 2 * float(M_PI);
       return ret;
     }

◆ pixelLayersWithMeasurement()

int pat::PackedCandidate::pixelLayersWithMeasurement ( ) const

inline

Definition at line 678 of file PackedCandidate.h.

References packedLayers_, and trackPixelHitsMask.

Referenced by numberOfPixelHits(), and trackerLayersWithMeasurement().

678 { return packedLayers_ & trackPixelHitsMask; }

pat::PackedCandidate::packedLayers_

uint8_t packedLayers_

Definition: PackedCandidate.h:1082

pat::PackedCandidate::trackPixelHitsMask

Definition: PackedCandidate.h:620

◆ polarP4()

const PolarLorentzVector& pat::PackedCandidate::polarP4 ( ) const

inlineoverridevirtual

four-momentum Lorentz vector

Implements reco::Candidate.

Definition at line 444 of file PackedCandidate.h.

References p4_, p4c_, and unpack().

Referenced by operator=(), pat::PATIsolatedTrackProducer::produce(), setP4(), and setPz().

                                                        {
       if (!p4c_)
         unpack();
       return *p4_;
     }

◆ pseudoPosDefTrack()

const reco::Track pat::PackedCandidate::pseudoPosDefTrack ( ) const

virtual

Return reference to a pseudo track made with candidate kinematics, parameterized error for eta,phi,pt and full IP covariance and the coviriance matrix is forced to be positive definite according to BPH recommandations

Definition at line 168 of file PackedCandidate.cc.

References dumpMFGeometry_cfg::delta, MillePedeFileConverter_cfg::e, mps_fire::i, CommonMethods::isnan(), dqmiolumiharvest::j, reco::TrackBase::loose, visualization-live-secondInstance_cfg::m, and reco::TrackBase::undefAlgorithm.

                                                             {
   // perform the regular unpacking of the track
   if (!track_)
     unpackTrk();
 
   //calculate the determinant and verify positivity
   double det = 0;
   bool notPosDef = (!(*m_).Sub<AlgebraicSymMatrix22>(0, 0).Det(det) || det < 0) ||
                    (!(*m_).Sub<AlgebraicSymMatrix33>(0, 0).Det(det) || det < 0) ||
                    (!(*m_).Sub<AlgebraicSymMatrix44>(0, 0).Det(det) || det < 0) || (!(*m_).Det(det) || det < 0);
 
   if (notPosDef) {
     reco::TrackBase::CovarianceMatrix m(*m_);
     //if not positive-definite, alter values to allow for pos-def
     TMatrixDSym eigenCov(5);
     for (int i = 0; i < 5; i++) {
       for (int j = 0; j < 5; j++) {
         if (std::isnan((m)(i, j)) || std::isinf((m)(i, j)))
           eigenCov(i, j) = 1e-6;
         else
           eigenCov(i, j) = (m)(i, j);
       }
     }
     TVectorD eigenValues(5);
     eigenCov.EigenVectors(eigenValues);
     double minEigenValue = eigenValues.Min();
     double delta = 1e-6;
     if (minEigenValue < 0) {
       for (int i = 0; i < 5; i++)
         m(i, i) += delta - minEigenValue;
     }
 
     // make a track object with pos def covariance matrix
     return reco::Track(normalizedChi2_ * (*track_).ndof(),
                        (*track_).ndof(),
                        *vertex_,
                        (*track_).momentum(),
                        (*track_).charge(),
                        m,
                        reco::TrackBase::undefAlgorithm,
                        reco::TrackBase::loose);
   } else {
     // just return a copy of the unpacked track
     return reco::Track(*track_);
   }
 }

◆ pseudoTrack()

virtual const reco::Track& pat::PackedCandidate::pseudoTrack ( ) const

inlinevirtual

Return reference to a pseudo track made with candidate kinematics, parameterized error for eta,phi,pt and full IP covariance

Definition at line 785 of file PackedCandidate.h.

References track_, and unpackTrk().

Referenced by reco::tau::lead_track_chi2(), and btagbtvdeep::packedCandidateToFeatures().

                                                  {
       if (!track_)
         unpackTrk();
       return *track_;
     }

◆ pt()

double pat::PackedCandidate::pt ( ) const

inlineoverridevirtual

transverse momentum

Implements reco::Candidate.

Definition at line 523 of file PackedCandidate.h.

References p4_, p4c_, and unpack().

Referenced by Particle.Particle::__str__(), DiObject.DiMuon::__str__(), Photon.Photon::calScaledIsoValueExp(), Photon.Photon::calScaledIsoValueLin(), Photon.Photon::calScaledIsoValueQuadr(), et(), et2(), DeepBoostedJetTagInfoProducer::fillParticleFeatures(), reco::tau::RecoTauQualityCuts::filterChargedCand(), reco::tau::qcuts::minPackedCandVertexWeight(), Electron.Electron::mvaIDLoose(), Electron.Electron::mvaIDRun2(), Electron.Electron::mvaIDTight(), packCovarianceElement(), PuppiProducer::produce(), Electron.Electron::ptErr(), ntupleDataFormat.Track::ptPull(), Lepton.Lepton::relIso(), Lepton.Lepton::relIsoFromEA(), Lepton.Lepton::relIsoR(), Jet.Jet::setCorrP4(), and unpackCovarianceElement().

                                {
       if (!p4c_)
         unpack();
       return p4_.load()->Pt();
     }

◆ ptTrk()

virtual double pat::PackedCandidate::ptTrk ( ) const

inlinevirtual

pt from the track (normally identical to pt())

Definition at line 536 of file PackedCandidate.h.

References dtrkpt_, maybeUnpackBoth(), and p4_.

                                  {
       maybeUnpackBoth();
       return p4_.load()->pt() + dtrkpt_;
     }

◆ puppiWeight()

float pat::PackedCandidate::puppiWeight ( ) const

Set both weights at once (with option for only full PUPPI)

Definition at line 431 of file PackedCandidate.cc.

References SiStripPI::max.

Referenced by PileupJetIdAlgo::computeIdVariables(), btagbtvdeep::packedCandidateToFeatures(), PATPuppiJetSpecificProducer::produce(), citk::PFIsolationSumProducerForPUPPI::produce(), and PuppiProducer::produce().

                                             {
   return 1.f * packedPuppiweight_ / std::numeric_limits<uint8_t>::max();
 }

◆ puppiWeightNoLep()

float pat::PackedCandidate::puppiWeightNoLep ( ) const

Weight from full PUPPI.

Definition at line 435 of file PackedCandidate.cc.

References SiStripPI::max.

Referenced by citk::PFIsolationSumProducerForPUPPI::produce(), and PuppiProducer::produce().

                                                  {
   return 1.f * packedPuppiweightNoLepDiff_ / std::numeric_limits<int8_t>::max() +
          1.f * packedPuppiweight_ / std::numeric_limits<uint8_t>::max();
 }

◆ pvAssociationQuality()

const PVAssociationQuality pat::PackedCandidate::pvAssociationQuality ( ) const

inline

Definition at line 740 of file PackedCandidate.h.

References assignmentQualityMask, assignmentQualityShift, and qualityFlags_.

Referenced by fromPV(), reco::tau::qcuts::minPackedCandVertexWeight(), and btagbtvdeep::packedCandidateToFeatures().

                                                             {
       return PVAssociationQuality((qualityFlags_ & assignmentQualityMask) >> assignmentQualityShift);
     }

◆ px()

double pat::PackedCandidate::px ( ) const

inlineoverridevirtual

x coordinate of momentum vector

Implements reco::Candidate.

Definition at line 505 of file PackedCandidate.h.

References p4c_, and unpack().

                                {
       if (!p4c_)
         unpack();
       return p4c_.load()->Px();
     }

◆ py()

double pat::PackedCandidate::py ( ) const

inlineoverridevirtual

y coordinate of momentum vector

Implements reco::Candidate.

Definition at line 511 of file PackedCandidate.h.

References p4c_, and unpack().

                                {
       if (!p4c_)
         unpack();
       return p4c_.load()->Py();
     }

◆ pz()

double pat::PackedCandidate::pz ( ) const

inlineoverridevirtual

z coordinate of momentum vector

Implements reco::Candidate.

Definition at line 517 of file PackedCandidate.h.

References p4c_, and unpack().

Referenced by setPz().

                                {
       if (!p4c_)
         unpack();
       return p4c_.load()->Pz();
     }

◆ rapidity()

double pat::PackedCandidate::rapidity ( ) const

inlineoverridevirtual

rapidity

Implements reco::Candidate.

Definition at line 569 of file PackedCandidate.h.

References p4_, p4c_, and unpack().

                                      {
       if (!p4c_)
         unpack();
       return p4_.load()->Rapidity();
     }

◆ rawCaloFraction()

float pat::PackedCandidate::rawCaloFraction ( ) const

inline

Set the raw ECAL+HCAL energy over candidate energy for isolated charged hadrons

Definition at line 939 of file PackedCandidate.h.

                                   {
       return (rawCaloFraction_ / 100.);
     }                                  

◆ rawHcalFraction()

float pat::PackedCandidate::rawHcalFraction ( ) const

inline

Set the fraction of Hcal needed isolated charged hadrons.

Definition at line 943 of file PackedCandidate.h.

References rawHcalFraction_.

                                   {
       return (rawHcalFraction_ / 100.);
     }                               

◆ setAssociationQuality()

void pat::PackedCandidate::setAssociationQuality ( PVAssociationQuality q )

inline

Definition at line 743 of file PackedCandidate.h.

References assignmentQualityMask, assignmentQualityShift, submitPVResolutionJobs::q, and qualityFlags_.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

                                                        {
       qualityFlags_ =
           (qualityFlags_ & ~assignmentQualityMask) | ((q << assignmentQualityShift) & assignmentQualityMask);
     }

◆ setCaloFraction()

void pat::PackedCandidate::setCaloFraction ( float p )

Fraction of Hcal for isolated charged hadrons.

Definition at line 449 of file PackedCandidate.cc.

pat::PackedCandidate::caloFraction_

449 { caloFraction_ = 100 * p; }

uint8_t caloFraction_

Definition: PackedCandidate.h:1058

pat::PackedCandidate::covarianceVersion_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:463

◆ setCharge()

void pat::PackedCandidate::setCharge ( int charge )

inlineoverridevirtual

set electric charge

Implements reco::Candidate.

Definition at line 432 of file PackedCandidate.h.

432 {}

◆ setCovarianceVersion()

virtual void pat::PackedCandidate::setCovarianceVersion ( int v )

inlinevirtual

Definition at line 681 of file PackedCandidate.h.

References covarianceVersion_, and findQualityFiles::v.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

681 { covarianceVersion_ = v; }

findQualityFiles.v

v

Definition: findQualityFiles.py:179

uint16_t covarianceVersion_

Definition: PackedCandidate.h:1089

◆ setDTimeAssociatedPV()

void pat::PackedCandidate::setDTimeAssociatedPV	(	float	aTime,
		float	aTimeError = `0`
	)

set time measurement

Definition at line 455 of file PackedCandidate.cc.

Referenced by setTime().

                                                                            {
   if (aTime == 0 && aTimeError == 0) {
     packedTime_ = 0;
     packedTimeError_ = 0;
   } else if (aTimeError == 0) {
     packedTimeError_ = 0;
     packedTime_ = packTimeNoError(aTime);
   } else {
     packedTimeError_ = packTimeError(aTimeError);
     aTimeError = unpackTimeError(packedTimeError_);  // for reproducibility
     packedTime_ = packTimeWithError(aTime, aTimeError);
   }
 }

◆ setFirstHit()

void pat::PackedCandidate::setFirstHit ( uint16_t pattern )

inline

Set first hit from HitPattern.

Definition at line 836 of file PackedCandidate.h.

References firstHit_, and topSingleLeptonDQM_PU_cfi::pattern.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

836 { firstHit_ = pattern; }

topSingleLeptonDQM_PU_cfi.pattern

pattern

Definition: topSingleLeptonDQM_PU_cfi.py:39

pat::PackedCandidate::firstHit_

uint16_t firstHit_

Definition: PackedCandidate.h:1146

◆ setGoodEgamma()

void pat::PackedCandidate::setGoodEgamma ( bool isGoodEgamma = true )

inline

Definition at line 845 of file PackedCandidate.h.

References egammaFlagsMask, egammaFlagsShift, isGoodEgamma(), and qualityFlags_.

                                                  {
       int16_t egFlags = (isGoodEgamma << egammaFlagsShift) & egammaFlagsMask;
       qualityFlags_ = (qualityFlags_ & ~egammaFlagsMask) | egFlags;
     }

◆ setHcalFraction()

void pat::PackedCandidate::setHcalFraction ( float p )

Fraction of ECAL+HCAL energy over candidate energy.

Definition at line 451 of file PackedCandidate.cc.

451 { hcalFraction_ = 100 * p; }

pat::PackedCandidate::hcalFraction_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:463

int8_t hcalFraction_

Definition: PackedCandidate.h:1059

◆ setHits()

virtual void pat::PackedCandidate::setHits ( const reco::Track & tk )

inlinevirtual

Definition at line 623 of file PackedCandidate.h.

References reco::TrackBase::hitPattern(), reco::HitPattern::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), packedHits_, packedLayers_, reco::HitPattern::pixelLayersWithMeasurement(), reco::HitPattern::stripLayersWithMeasurement(), trackPixelHitsMask, trackStripHitsMask, and trackStripHitsShift.

Referenced by setTrackProperties().

                                               {
       // first we count the number of layers with hits
       int numberOfPixelLayers_ = tk.hitPattern().pixelLayersWithMeasurement();
       if (numberOfPixelLayers_ > trackPixelHitsMask)
         numberOfPixelLayers_ = trackPixelHitsMask;
       int numberOfStripLayers_ = tk.hitPattern().stripLayersWithMeasurement();
       if (numberOfStripLayers_ > trackStripHitsMask)
         numberOfStripLayers_ = trackStripHitsMask;
       packedLayers_ = (numberOfPixelLayers_ & trackPixelHitsMask) | (numberOfStripLayers_ << trackStripHitsShift);
       // now we count number of additional hits, beyond the one-per-layer implied
       // by packedLayers_
       int numberOfPixelHits_ = tk.hitPattern().numberOfValidPixelHits() - numberOfPixelLayers_;
       if (numberOfPixelHits_ > trackPixelHitsMask)
         numberOfPixelHits_ = trackPixelHitsMask;
       int numberOfStripHits_ =
           tk.hitPattern().numberOfValidHits() - numberOfPixelHits_ - numberOfPixelLayers_ - numberOfStripLayers_;
       if (numberOfStripHits_ > trackStripHitsMask)
         numberOfStripHits_ = trackStripHitsMask;
 
       packedHits_ = (numberOfPixelHits_ & trackPixelHitsMask) | (numberOfStripHits_ << trackStripHitsShift);
     }

◆ setIsIsolatedChargedHadron()

void pat::PackedCandidate::setIsIsolatedChargedHadron ( bool p )

Fraction of Hcal for HF, neutral hadrons, and charged particles.

Definition at line 453 of file PackedCandidate.cc.

453 { isIsolatedChargedHadron_ = p; }

pat::PackedCandidate::isIsolatedChargedHadron_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:463

bool isIsolatedChargedHadron_

Definition: PackedCandidate.h:1063

◆ setLongLived()

void pat::PackedCandidate::setLongLived ( )

inlineoverridevirtual

set long lived flag

Implements reco::Candidate.

Definition at line 861 of file PackedCandidate.h.

861 {} /*FIXME*/

◆ setLostInnerHits()

void pat::PackedCandidate::setLostInnerHits ( LostInnerHits hits )

inline

Definition at line 827 of file PackedCandidate.h.

References hfClusterShapes_cfi::hits, lostInnerHitsMask, lostInnerHitsShift, and qualityFlags_.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

                                               {
       int lost = hits;
       if (lost > 2)
         lost = 2;  // protection against misuse
       lost++;      // shift so it's 0 .. 3 instead of (-1) .. 2
       qualityFlags_ = (qualityFlags_ & ~lostInnerHitsMask) | ((lost << lostInnerHitsShift) & lostInnerHitsMask);
     }

◆ setMass()

void pat::PackedCandidate::setMass ( double m )

inlineoverridevirtual

set particle mass

Implements reco::Candidate.

Definition at line 601 of file PackedCandidate.h.

References visualization-live-secondInstance_cfg::m, p4_, p4c_, pack(), and unpack().

                                     {
       if (!p4c_)
         unpack();
       *p4_ = PolarLorentzVector(p4_.load()->Pt(), p4_.load()->Eta(), p4_.load()->Phi(), m);
       pack();
     }

◆ setMassConstraint()

void pat::PackedCandidate::setMassConstraint ( )

inlineoverridevirtual

set mass constraint flag

Implements reco::Candidate.

Definition at line 867 of file PackedCandidate.h.

867 {} /*FIXME*/

◆ setMuonID()

void pat::PackedCandidate::setMuonID	(	bool	isStandAlone,
		bool	isGlobal
	)

inline

Definition at line 840 of file PackedCandidate.h.

References muons_cff::isGlobal, muonFlagsMask, muonFlagsShift, and qualityFlags_.

                                                      {
       int16_t muonFlags = isStandAlone | (2 * isGlobal);
       qualityFlags_ = (qualityFlags_ & ~muonFlagsMask) | ((muonFlags << muonFlagsShift) & muonFlagsMask);
     }

◆ setP4() [1/2]

void pat::PackedCandidate::setP4 ( const LorentzVector & p4 )

inlineoverridevirtual

set 4-momentum

Implements reco::Candidate.

Definition at line 581 of file PackedCandidate.h.

References deta_, dphi_, dtrkpt_, maybeUnpackBoth(), p4(), p4_, packBoth(), and polarP4().

Referenced by Jet.Jet::setCorrP4().

                                                  {
       maybeUnpackBoth();  // changing px,py,pz changes also mapping between dxy,dz
                           // and x,y,z
       dphi_ += polarP4().Phi() - p4.Phi();
       deta_ += polarP4().Eta() - p4.Eta();
       dtrkpt_ += polarP4().Pt() - p4.Pt();
       *p4_ = PolarLorentzVector(p4.Pt(), p4.Eta(), p4.Phi(), p4.M());
       packBoth();
     }

◆ setP4() [2/2]

void pat::PackedCandidate::setP4 ( const PolarLorentzVector & p4 )

inlineoverride

set 4-momentum

Definition at line 591 of file PackedCandidate.h.

References deta_, dphi_, dtrkpt_, maybeUnpackBoth(), p4(), p4_, packBoth(), and polarP4().

Referenced by Jet.Jet::setCorrP4().

                                                       {
       maybeUnpackBoth();  // changing px,py,pz changes also mapping between dxy,dz
                           // and x,y,z
       dphi_ += polarP4().Phi() - p4.Phi();
       deta_ += polarP4().Eta() - p4.Eta();
       dtrkpt_ += polarP4().Pt() - p4.Pt();
       *p4_ = p4;
       packBoth();
     }

◆ setPdgId()

void pat::PackedCandidate::setPdgId ( int pdgId )

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 853 of file PackedCandidate.h.

References pdgId(), and pdgId_.

853 { pdgId_ = pdgId; }

pat::PackedCandidate::pdgId

int pdgId() const override

PDG identifier.

Definition: PackedCandidate.h:851

pat::PackedCandidate::pdgId_

int pdgId_

PDG identifier.

Definition: PackedCandidate.h:1074

◆ setPuppiWeight()

void pat::PackedCandidate::setPuppiWeight	(	float	p,
		float	p_nolep = `0.0`
	)

Definition at line 424 of file PackedCandidate.cc.

References SiStripPI::max, and AlCaHLTBitMon_ParallelJobs::p.

                                                               {
   // Set both weights at once to avoid misconfigured weights if called in the
   // wrong order
   packedPuppiweight_ = std::numeric_limits<uint8_t>::max() * p;
   packedPuppiweightNoLepDiff_ = std::numeric_limits<int8_t>::max() * (p_nolep - p);
 }

◆ setPz()

void pat::PackedCandidate::setPz ( double pz )

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 607 of file PackedCandidate.h.

References deta_, dphi_, dtrkpt_, maybeUnpackBoth(), p4_, p4c_, packBoth(), polarP4(), and pz().

                                    {
       maybeUnpackBoth();  // changing px,py,pz changes also mapping between dxy,dz
                           // and x,y,z
       *p4c_ = LorentzVector(p4c_.load()->Px(), p4c_.load()->Py(), pz, p4c_.load()->E());
       dphi_ += polarP4().Phi() - p4c_.load()->Phi();
       deta_ += polarP4().Eta() - p4c_.load()->Eta();
       dtrkpt_ += polarP4().Pt() - p4c_.load()->Pt();
       *p4_ = PolarLorentzVector(p4c_.load()->Pt(), p4c_.load()->Eta(), p4c_.load()->Phi(), p4c_.load()->M());
       packBoth();
     }

◆ setRawCaloFraction()

void pat::PackedCandidate::setRawCaloFraction ( float p )

Weight from PUPPI removing leptons.

Definition at line 440 of file PackedCandidate.cc.

References SiStripPI::max, and AlCaHLTBitMon_ParallelJobs::p.

                                                    {
   if (100 * p > std::numeric_limits<uint8_t>::max())
     rawCaloFraction_ = std::numeric_limits<uint8_t>::max();  // Set to overflow value
   else
     rawCaloFraction_ = 100 * p;
 }

◆ setRawHcalFraction()

void pat::PackedCandidate::setRawHcalFraction ( float p )

Raw ECAL+HCAL energy over candidate energy for isolated charged hadrons.

Definition at line 447 of file PackedCandidate.cc.

447 { rawHcalFraction_ = 100 * p; }

pat::PackedCandidate::rawHcalFraction_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:463

int8_t rawHcalFraction_

Definition: PackedCandidate.h:1057

◆ setStatus()

void pat::PackedCandidate::setStatus ( int status )

inlineoverridevirtual

set status word

Implements reco::Candidate.

Definition at line 857 of file PackedCandidate.h.

857 {} /*FIXME*/

◆ setThreeCharge()

void pat::PackedCandidate::setThreeCharge ( int threecharge )

inlineoverridevirtual

set electric charge

Implements reco::Candidate.

Definition at line 436 of file PackedCandidate.h.

436 {}

◆ setTime()

void pat::PackedCandidate::setTime	(	float	aTime,
		float	aTimeError = `0`
	)

inline

set time measurement

Definition at line 1000 of file PackedCandidate.h.

References setDTimeAssociatedPV(), submitPVValidationJobs::t, and vertexRef().

1000 { setDTimeAssociatedPV(aTime - vertexRef()->t(), aTimeError); }

submitPVValidationJobs.t

string t

Definition: submitPVValidationJobs.py:651

pat::PackedCandidate::vertexRef

const reco::VertexRef vertexRef() const

Definition: PackedCandidate.h:748

pat::PackedCandidate::setDTimeAssociatedPV

void setDTimeAssociatedPV(float aTime, float aTimeError=0)

set time measurement

Definition: PackedCandidate.cc:455

◆ setTrackHighPurity()

void pat::PackedCandidate::setTrackHighPurity ( bool highPurity )

inline

set to true if the track had the highPurity quality bit

Definition at line 811 of file PackedCandidate.h.

References qualityFlags_, trackHighPurityMask, and trackHighPurityShift.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

                                              {
       qualityFlags_ =
           (qualityFlags_ & ~trackHighPurityMask) | ((highPurity << trackHighPurityShift) & trackHighPurityMask);
     }

◆ setTrackProperties() [1/2]

virtual void pat::PackedCandidate::setTrackProperties	(	const reco::Track &	tk,
		const reco::Track::CovarianceMatrix &	covariance,
		int	quality,
		int	covarianceVersion
	)

inlinevirtual

Definition at line 645 of file PackedCandidate.h.

References covarianceSchema_, covarianceVersion(), covarianceVersion_, maybeUnpackBoth(), reco::TrackBase::normalizedChi2(), normalizedChi2_, packBoth(), packCovariance(), quality, and setHits().

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures(), and setTrackProperties().

                                                            {
       covarianceVersion_ = covarianceVersion;
       covarianceSchema_ = quality;
       normalizedChi2_ = tk.normalizedChi2();
       setHits(tk);
       maybeUnpackBoth();
       packBoth();
       packCovariance(covariance, false);
     }

◆ setTrackProperties() [2/2]

virtual void pat::PackedCandidate::setTrackProperties	(	const reco::Track &	tk,
		int	quality,
		int	covarianceVersion
	)

inlinevirtual

Definition at line 660 of file PackedCandidate.h.

References reco::TrackBase::covariance(), covarianceVersion(), quality, and setTrackProperties().

                                                                                              {
       setTrackProperties(tk, tk.covariance(), quality, covarianceVersion);
     }

◆ setTrackPropertiesLite()

void pat::PackedCandidate::setTrackPropertiesLite	(	unsigned int	covSchema,
		unsigned int	covarianceVersion,
		unsigned int	nHits,
		unsigned int	nPixelHits
	)

inline

Definition at line 664 of file PackedCandidate.h.

References covarianceSchema_, covarianceVersion(), covarianceVersion_, nHits, packedHits_, trackPixelHitsMask, trackStripHitsMask, and trackStripHitsShift.

                                                          {
       covarianceVersion_ = covarianceVersion;
       covarianceSchema_ = covSchema;
       packedHits_ =
           (nPixelHits & trackPixelHitsMask) | (((nHits - nPixelHits) & trackStripHitsMask) << trackStripHitsShift);
     }

◆ setVertex()

void pat::PackedCandidate::setVertex ( const Point & vertex )

inlineoverridevirtual

set vertex

Implements reco::Candidate.

Definition at line 706 of file PackedCandidate.h.

References maybeUnpackBoth(), packVtx(), vertex(), and vertex_.

                                                  {
       maybeUnpackBoth();
       *vertex_ = vertex;
       packVtx();
     }

◆ sourceCandidatePtr()

reco::CandidatePtr pat::PackedCandidate::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::Candidate.

Definition at line 412 of file PackedCandidate.h.

412 { return reco::CandidatePtr(); }

reco::CandidatePtr

edm::Ptr< Candidate > CandidatePtr

persistent reference to an object in a collection of Candidate objects

Definition: CandidateFwd.h:25

◆ status()

int pat::PackedCandidate::status ( ) const

inlineoverridevirtual

status word

Implements reco::Candidate.

Definition at line 855 of file PackedCandidate.h.

References qualityFlags_.

855 { return qualityFlags_; } /*FIXME*/

pat::PackedCandidate::packedLayers_

uint16_t qualityFlags_

Definition: PackedCandidate.h:1075

◆ stripLayersWithMeasurement()

int pat::PackedCandidate::stripLayersWithMeasurement ( ) const

inline

Definition at line 679 of file PackedCandidate.h.

References packedLayers_, and trackStripHitsShift.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures(), numberOfHits(), and trackerLayersWithMeasurement().

679 { return (packedLayers_ >> trackStripHitsShift); }

uint8_t packedLayers_

Definition: PackedCandidate.h:1082

pat::PackedCandidate::trackStripHitsShift

Definition: PackedCandidate.h:620

◆ theta()

double pat::PackedCandidate::theta ( ) const

inlineoverridevirtual

momentum polar angle

Implements reco::Candidate.

Definition at line 557 of file PackedCandidate.h.

References p4_, p4c_, and unpack().

Referenced by Tau.Tau::zImpact().

                                   {
       if (!p4c_)
         unpack();
       return p4_.load()->Theta();
     }

◆ threeCharge()

int pat::PackedCandidate::threeCharge ( ) const

inlineoverridevirtual

electric charge

Implements reco::Candidate.

Definition at line 434 of file PackedCandidate.h.

References charge().

434 { return charge() * 3; }

pat::PackedCandidate::charge

int charge() const override

electric charge

Definition: PackedCandidate.h:415

◆ time()

virtual float pat::PackedCandidate::time ( ) const

inlinevirtual

time (wrt nominal zero of the collision)

Definition at line 981 of file PackedCandidate.h.

References dtimeAssociatedPV(), and vertexRef().

Referenced by TransientTrackBuilder::build().

981 { return vertexRef()->t() + dtimeAssociatedPV(); }

pat::PackedCandidate::vertexRef

const reco::VertexRef vertexRef() const

Definition: PackedCandidate.h:748

pat::PackedCandidate::dtimeAssociatedPV

virtual float dtimeAssociatedPV() const

dtime with respect to the PV ref

Definition: PackedCandidate.h:987

◆ timeError()

virtual float pat::PackedCandidate::timeError ( ) const

inlinevirtual

time measurement uncertainty (-1 if not available)

Definition at line 996 of file PackedCandidate.h.

References packedTimeError_, and unpackTimeError().

Referenced by TransientTrackBuilder::build().

996 { return unpackTimeError(packedTimeError_); }

pat::PackedCandidate::packedTimeError_

uint8_t packedTimeError_

Definition: PackedCandidate.h:1061

pat::PackedCandidate::unpackTimeError

static float unpackTimeError(uint8_t timeError)

Definition: PackedCandidate.cc:481

◆ trackerLayersWithMeasurement()

int pat::PackedCandidate::trackerLayersWithMeasurement ( ) const

inline

Definition at line 680 of file PackedCandidate.h.

References pixelLayersWithMeasurement(), and stripLayersWithMeasurement().

680 { return stripLayersWithMeasurement() + pixelLayersWithMeasurement(); }

pat::PackedCandidate::pixelLayersWithMeasurement

int pixelLayersWithMeasurement() const

Definition: PackedCandidate.h:678

pat::PackedCandidate::stripLayersWithMeasurement

int stripLayersWithMeasurement() const

Definition: PackedCandidate.h:679

◆ trackHighPurity()

bool pat::PackedCandidate::trackHighPurity ( ) const

inline

true if the track had the highPurity quality bit

Definition at line 809 of file PackedCandidate.h.

References qualityFlags_, trackHighPurityMask, and trackHighPurityShift.

809 { return (qualityFlags_ & trackHighPurityMask) >> trackHighPurityShift; }

pat::PackedCandidate::trackHighPurityMask

Definition: PackedCandidate.h:1122

pat::PackedCandidate::trackHighPurityShift

Definition: PackedCandidate.h:1123