Reference Manual

pat::PackedCandidate::egammaFlagsMask

uint16_t qualityFlags_

Definition: PackedCandidate.h:1088

◆ isGoodEgamma()

bool pat::PackedCandidate::isGoodEgamma ( ) const

inline

Definition at line 940 of file PackedCandidate.h.

References egammaFlagsMask, and qualityFlags_.

Referenced by setGoodEgamma().

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

Definition: PackedCandidate.h:1147

pat::PackedCandidate::muonFlagsMask

uint16_t qualityFlags_

Definition: PackedCandidate.h:1088

◆ 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 972 of file PackedCandidate.h.

                                          {
       return isIsolatedChargedHadron_;
     }  

◆ isJet()

bool pat::PackedCandidate::isJet ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 939 of file PackedCandidate.h.

939 { return false; }

◆ isMuon()

bool pat::PackedCandidate::isMuon ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 932 of file PackedCandidate.h.

932 { return false; }

◆ isPhoton()

bool pat::PackedCandidate::isPhoton ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 937 of file PackedCandidate.h.

937 { return false; }

◆ isStandAloneMuon()

bool pat::PackedCandidate::isStandAloneMuon ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 933 of file PackedCandidate.h.

References muonFlagsMask, muonFlagsShift, and qualityFlags_.

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

Definition: PackedCandidate.h:1145

pat::PackedCandidate::muonFlagsShift

Definition: PackedCandidate.h:1146

pat::PackedCandidate::pixelLayersWithMeasurement

uint16_t qualityFlags_

Definition: PackedCandidate.h:1088

◆ isTrackerMuon()

bool pat::PackedCandidate::isTrackerMuon ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 935 of file PackedCandidate.h.

935 { return false; }

◆ longLived()

bool pat::PackedCandidate::longLived ( ) const

overridevirtual

is long lived?

Implements reco::Candidate.

Definition at line 423 of file PackedCandidate.cc.

423 { return false; }

◆ lostInnerHits()

LostInnerHits pat::PackedCandidate::lostInnerHits ( ) const

inline

Definition at line 828 of file PackedCandidate.h.

References lostInnerHitsMask, lostInnerHitsShift, and qualityFlags_.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures(), and btagbtvdeep::packedCandidateToFeatures().

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

◆ mass()

double pat::PackedCandidate::mass ( ) const

inlineoverridevirtual

mass

Implements reco::Candidate.

Definition at line 483 of file PackedCandidate.h.

References p4_, p4c_, and unpack().

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

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

◆ massConstraint()

bool pat::PackedCandidate::massConstraint ( ) const

overridevirtual

do mass constraint?

Implements reco::Candidate.

Definition at line 425 of file PackedCandidate.cc.

425 { return false; }

◆ massSqr()

double pat::PackedCandidate::massSqr ( ) const

inlineoverridevirtual

mass squared

Implements reco::Candidate.

Definition at line 489 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 364 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 373 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 927 of file PackedCandidate.h.

References masterClone().

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

◆ maybeUnpackBoth()

void pat::PackedCandidate::maybeUnpackBoth ( ) const

inlineprotected

Definition at line 1040 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 1050 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 1046 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 454 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 389 of file PackedCandidate.cc.

389 { return nullptr; }

◆ mt()

double pat::PackedCandidate::mt ( ) const

inlineoverridevirtual

transverse mass

Implements reco::Candidate.

Definition at line 497 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 503 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 378 of file PackedCandidate.cc.

378 { return 0; }

◆ numberOfHits()

int pat::PackedCandidate::numberOfHits ( ) const

inline

Definition at line 679 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 380 of file PackedCandidate.cc.

380 { return 0; }

◆ numberOfPixelHits()

int pat::PackedCandidate::numberOfPixelHits ( ) const

inline

Definition at line 678 of file PackedCandidate.h.

References packedHits_, pixelLayersWithMeasurement(), and trackPixelHitsMask.

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

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

int pixelLayersWithMeasurement() const

Definition: PackedCandidate.h:682

pat::PackedCandidate::trackPixelHitsMask

Definition: PackedCandidate.h:624

pat::PackedCandidate::packedHits_

uint8_t packedHits_

Definition: PackedCandidate.h:1095

◆ 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 413 of file PackedCandidate.h.

413 { return 0; }

◆ operator=() [1/2]

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

inline

Definition at line 269 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_, trkAlgoPacked_, 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_;
       trkAlgoPacked_ = iOther.trkAlgoPacked_;
       return *this;
     }

◆ operator=() [2/2]

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

inline

Definition at line 348 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_, trkAlgoPacked_, 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_;
       trkAlgoPacked_ = iOther.trkAlgoPacked_;
       return *this;
     }

◆ overlap()

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

overrideprotectedvirtual

check overlap with another Candidate

Implements reco::Candidate.

Definition at line 382 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 467 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 442 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 17 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 1054 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 85 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 1020 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 474 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 494 of file PackedCandidate.cc.

References funct::abs(), f, SiStripPI::min, and hcalRecHitTable_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 515 of file PackedCandidate.cc.

References funct::abs(), f, and hcalRecHitTable_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 30 of file PackedCandidate.cc.

References HltBtagPostValidation_cff::c, funct::cos(), f, MiniFloatConverter::float32to16(), edm::Ref< C, T, F >::isNonnull(), SiStripPI::max, 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;
   dz_ = 0;
   if (p4_.load()->Pt() != 0.f) {
     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 864 of file PackedCandidate.h.

References pdgId_.

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

864 { return pdgId_; }

pat::PackedCandidate::pdgId_

int pdgId_

PDG identifier.

Definition: PackedCandidate.h:1087

◆ phi()

double pat::PackedCandidate::phi ( ) const

inlineoverridevirtual

momentum azimuthal angle

Implements reco::Candidate.

Definition at line 533 of file PackedCandidate.h.

References p4_, p4c_, and unpack().

Referenced by Particle.Particle::__str__(), datamodel.Object::DeltaR(), reco::tau::qcuts::minPackedCandVertexWeight(), datamodel.Object::p4(), 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 545 of file PackedCandidate.h.

References dphi_, nano_mu_digi_cff::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 682 of file PackedCandidate.h.

References packedLayers_, and trackPixelHitsMask.

Referenced by numberOfPixelHits(), and trackerLayersWithMeasurement().

682 { return packedLayers_ & trackPixelHitsMask; }

pat::PackedCandidate::packedLayers_

uint8_t packedLayers_

Definition: PackedCandidate.h:1095

pat::PackedCandidate::trackPixelHitsMask

Definition: PackedCandidate.h:624

◆ polarP4()

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

inlineoverridevirtual

four-momentum Lorentz vector

Implements reco::Candidate.

Definition at line 448 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 172 of file PackedCandidate.cc.

References dumpMFGeometry_cfg::delta, MillePedeFileConverter_cfg::e, mps_fire::i, edm::isNotFinite(), 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 (edm::isNotFinite((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 789 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 527 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(), datamodel.Object::p4(), 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 540 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 435 of file PackedCandidate.cc.

References SiStripPI::max.

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

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

◆ puppiWeightNoLep()

float pat::PackedCandidate::puppiWeightNoLep ( ) const

Weight from full PUPPI.

Definition at line 439 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 744 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 509 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 515 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 521 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 573 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 952 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 956 of file PackedCandidate.h.

References rawHcalFraction_.

                                   {
       return (rawHcalFraction_ / 100.);
     }                               

◆ setAssociationQuality()

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

inline

Definition at line 747 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 453 of file PackedCandidate.cc.

pat::PackedCandidate::caloFraction_

453 { caloFraction_ = 100 * p; }

uint8_t caloFraction_

Definition: PackedCandidate.h:1071

pat::PackedCandidate::covarianceVersion_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:467

◆ setCharge()

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

inlineoverridevirtual

set electric charge

Implements reco::Candidate.

Definition at line 436 of file PackedCandidate.h.

436 {}

◆ setCovarianceVersion()

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

inlinevirtual

Definition at line 685 of file PackedCandidate.h.

References covarianceVersion_, and findQualityFiles::v.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

685 { covarianceVersion_ = v; }

findQualityFiles.v

v

Definition: findQualityFiles.py:179

uint16_t covarianceVersion_

Definition: PackedCandidate.h:1102

◆ setDTimeAssociatedPV()

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

set time measurement

Definition at line 459 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 840 of file PackedCandidate.h.

References firstHit_, and topSingleLeptonDQM_PU_cfi::pattern.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

840 { firstHit_ = pattern; }

topSingleLeptonDQM_PU_cfi.pattern

pattern

Definition: topSingleLeptonDQM_PU_cfi.py:39

pat::PackedCandidate::firstHit_

uint16_t firstHit_

details (hit pattern) of the first hit on track

Definition: PackedCandidate.h:1125

◆ setGoodEgamma()

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

inline

Definition at line 858 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 455 of file PackedCandidate.cc.

455 { hcalFraction_ = 100 * p; }

pat::PackedCandidate::hcalFraction_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:467

int8_t hcalFraction_

Definition: PackedCandidate.h:1072

◆ setHits()

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

inlinevirtual

Definition at line 627 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 457 of file PackedCandidate.cc.

457 { isIsolatedChargedHadron_ = p; }

pat::PackedCandidate::isIsolatedChargedHadron_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:467

bool isIsolatedChargedHadron_

Definition: PackedCandidate.h:1076

◆ setLongLived()

void pat::PackedCandidate::setLongLived ( )

inlineoverridevirtual

set long lived flag

Implements reco::Candidate.

Definition at line 874 of file PackedCandidate.h.

874 {} /*FIXME*/

◆ setLostInnerHits()

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

inline

Definition at line 831 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 605 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 880 of file PackedCandidate.h.

880 {} /*FIXME*/

◆ setMuonID()

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

inline

Definition at line 853 of file PackedCandidate.h.

References nano_mu_reco_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 585 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 595 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 866 of file PackedCandidate.h.

References pdgId(), and pdgId_.

866 { pdgId_ = pdgId; }

pat::PackedCandidate::pdgId

int pdgId() const override

PDG identifier.

Definition: PackedCandidate.h:864

pat::PackedCandidate::pdgId_

int pdgId_

PDG identifier.

Definition: PackedCandidate.h:1087

◆ setPuppiWeight()

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

Definition at line 428 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 611 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 444 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 451 of file PackedCandidate.cc.

451 { rawHcalFraction_ = 100 * p; }

pat::PackedCandidate::rawHcalFraction_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:467

int8_t rawHcalFraction_

Definition: PackedCandidate.h:1070

◆ setStatus()

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

inlineoverridevirtual

set status word

Implements reco::Candidate.

Definition at line 870 of file PackedCandidate.h.

870 {} /*FIXME*/

◆ setThreeCharge()

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

inlineoverridevirtual

set electric charge

Implements reco::Candidate.

Definition at line 440 of file PackedCandidate.h.

440 {}

◆ setTime()

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

inline

set time measurement

Definition at line 1013 of file PackedCandidate.h.

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

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

submitPVValidationJobs.t

string t

Definition: submitPVValidationJobs.py:649

pat::PackedCandidate::vertexRef

const reco::VertexRef vertexRef() const

Definition: PackedCandidate.h:752

pat::PackedCandidate::setDTimeAssociatedPV

void setDTimeAssociatedPV(float aTime, float aTimeError=0)

set time measurement

Definition: PackedCandidate.cc:459

◆ setTrackHighPurity()

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

inline

set to true if the track had the highPurity quality bit

Definition at line 815 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 649 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 664 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 668 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);
     }

◆ setTrkAlgo()

void pat::PackedCandidate::setTrkAlgo	(	uint8_t	algo,
		uint8_t	original
	)

inline

Set/get track algo.

Definition at line 845 of file PackedCandidate.h.

References definitions::original, and trkAlgoPacked_.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

                                                     {
       trkAlgoPacked_ = algo | ((algo == original ? 0 : original) << 8);
     }

◆ setVertex()

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

inlineoverridevirtual

set vertex

Implements reco::Candidate.

Definition at line 710 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 416 of file PackedCandidate.h.

416 { 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 868 of file PackedCandidate.h.

References qualityFlags_.

868 { return qualityFlags_; } /*FIXME*/

pat::PackedCandidate::packedLayers_

uint16_t qualityFlags_

Definition: PackedCandidate.h:1088

◆ stripLayersWithMeasurement()

int pat::PackedCandidate::stripLayersWithMeasurement ( ) const

inline

Definition at line 683 of file PackedCandidate.h.

References packedLayers_, and trackStripHitsShift.

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

683 { return (packedLayers_ >> trackStripHitsShift); }

uint8_t packedLayers_

Definition: PackedCandidate.h:1095

pat::PackedCandidate::trackStripHitsShift

Definition: PackedCandidate.h:624

◆ theta()

double pat::PackedCandidate::theta ( ) const

inlineoverridevirtual

momentum polar angle

Implements reco::Candidate.

Definition at line 561 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 438 of file PackedCandidate.h.

References charge().

438 { return charge() * 3; }

pat::PackedCandidate::charge

int charge() const override

electric charge

Definition: PackedCandidate.h:419

◆ time()

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

inlinevirtual

time (wrt nominal zero of the collision)

Definition at line 994 of file PackedCandidate.h.

References dtimeAssociatedPV(), and vertexRef().

Referenced by TransientTrackBuilder::build().

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

pat::PackedCandidate::vertexRef

const reco::VertexRef vertexRef() const

Definition: PackedCandidate.h:752

pat::PackedCandidate::dtimeAssociatedPV

virtual float dtimeAssociatedPV() const

dtime with respect to the PV ref

Definition: PackedCandidate.h:1000

◆ timeError()

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

inlinevirtual

time measurement uncertainty (-1 if not available)

Definition at line 1009 of file PackedCandidate.h.

References packedTimeError_, and unpackTimeError().

Referenced by TransientTrackBuilder::build().

1009 { return unpackTimeError(packedTimeError_); }

pat::PackedCandidate::packedTimeError_

uint8_t packedTimeError_

Definition: PackedCandidate.h:1074

pat::PackedCandidate::unpackTimeError

static float unpackTimeError(uint8_t timeError)

Definition: PackedCandidate.cc:485

◆ trackerLayersWithMeasurement()

int pat::PackedCandidate::trackerLayersWithMeasurement ( ) const

inline

Definition at line 684 of file PackedCandidate.h.

References pixelLayersWithMeasurement(), and stripLayersWithMeasurement().

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

pat::PackedCandidate::pixelLayersWithMeasurement

int pixelLayersWithMeasurement() const

Definition: PackedCandidate.h:682

pat::PackedCandidate::stripLayersWithMeasurement

int stripLayersWithMeasurement() const

Definition: PackedCandidate.h:683

◆ trackHighPurity()

bool pat::PackedCandidate::trackHighPurity ( ) const

inline

true if the track had the highPurity quality bit

Definition at line 813 of file PackedCandidate.h.

References qualityFlags_, trackHighPurityMask, and trackHighPurityShift.

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

pat::PackedCandidate::trackHighPurityMask

Definition: PackedCandidate.h:1141

pat::PackedCandidate::trackHighPurityShift

Definition: PackedCandidate.h:1142