Reference Manual

pat::PackedCandidate::egammaFlagsMask

uint16_t qualityFlags_

Definition: PackedCandidate.h:1071

bool pat::PackedCandidate::isGoodEgamma ( ) const

inline

Definition at line 923 of file PackedCandidate.h.

References egammaFlagsMask, and qualityFlags_.

Referenced by setGoodEgamma().

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

Definition: PackedCandidate.h:1124

pat::PackedCandidate::muonFlagsMask

uint16_t qualityFlags_

Definition: PackedCandidate.h:1071

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

                                          {
       return isIsolatedChargedHadron_;
     }  

bool pat::PackedCandidate::isJet ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 922 of file PackedCandidate.h.

922 { return false; }

bool pat::PackedCandidate::isMuon ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 915 of file PackedCandidate.h.

915 { return false; }

bool pat::PackedCandidate::isPhoton ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 920 of file PackedCandidate.h.

920 { return false; }

bool pat::PackedCandidate::isStandAloneMuon ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 916 of file PackedCandidate.h.

References muonFlagsMask, muonFlagsShift, and qualityFlags_.

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

Definition: PackedCandidate.h:1122

pat::PackedCandidate::muonFlagsShift

Definition: PackedCandidate.h:1123

pat::PackedCandidate::pixelLayersWithMeasurement

uint16_t qualityFlags_

Definition: PackedCandidate.h:1071

bool pat::PackedCandidate::isTrackerMuon ( ) const

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 918 of file PackedCandidate.h.

918 { return false; }

bool pat::PackedCandidate::longLived ( ) const

overridevirtual

is long lived?

Implements reco::Candidate.

Definition at line 368 of file PackedCandidate.cc.

368 { return false; }

LostInnerHits pat::PackedCandidate::lostInnerHits ( ) const

inline

Definition at line 820 of file PackedCandidate.h.

References lostInnerHitsMask, lostInnerHitsShift, and qualityFlags_.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures(), and DPFIsolation::getPredictions().

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

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

bool pat::PackedCandidate::massConstraint ( ) const

overridevirtual

do mass constraint?

Implements reco::Candidate.

Definition at line 370 of file PackedCandidate.cc.

370 { return false; }

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

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

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 318 of file PackedCandidate.cc.

References Exception.

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

template<typename Ref >

Ref pat::PackedCandidate::masterRef ( ) const

inline

cast master clone reference to a concrete type

Definition at line 910 of file PackedCandidate.h.

References masterClone().

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

void pat::PackedCandidate::maybeUnpackBoth ( ) const

inlineprotected

Definition at line 1023 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();
     }

void pat::PackedCandidate::maybeUnpackCovariance ( ) const

inlineprotected

Definition at line 1033 of file PackedCandidate.h.

References m_, and unpackCovariance().

Referenced by dxyError(), and dzError().

                                        {
       if (!m_)
         unpackCovariance();
     }

void pat::PackedCandidate::maybeUnpackTrack ( ) const

inlineprotected

Definition at line 1029 of file PackedCandidate.h.

References track_, and unpackTrk().

Referenced by bestTrack().

                                   {
       if (!track_)
         unpackTrk();
     }

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

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 334 of file PackedCandidate.cc.

334 { return nullptr; }

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

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

size_t pat::PackedCandidate::numberOfDaughters ( ) const

overridevirtual

number of daughters

Implements reco::Candidate.

Definition at line 323 of file PackedCandidate.cc.

323 { return 0; }

int pat::PackedCandidate::numberOfHits ( ) const

inline

Definition at line 675 of file PackedCandidate.h.

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

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures(), DPFIsolation::getPredictions(), packCovarianceElement(), pat::PATTrackAndVertexUnpacker::produce(), and unpackCovarianceElement().

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

size_t pat::PackedCandidate::numberOfMothers ( ) const

overridevirtual

number of mothers

Implements reco::Candidate.

Definition at line 325 of file PackedCandidate.cc.

325 { return 0; }

int pat::PackedCandidate::numberOfPixelHits ( ) const

inline

Definition at line 674 of file PackedCandidate.h.

References packedHits_, pixelLayersWithMeasurement(), and trackPixelHitsMask.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures(), DPFIsolation::getPredictions(), 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:1078

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

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

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

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

overrideprotectedvirtual

check overlap with another Candidate

Implements reco::Candidate.

Definition at line 327 of file PackedCandidate.cc.

References RecoTauCleanerPlugins::charge, reco::Candidate::charge(), reco::Candidate::p4(), and reco::Candidate::vertex().

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

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

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(), DPFIsolation::getPredictions(), operator=(), Lepton.Lepton::p4WithFSR(), pat::PATIsolatedTrackProducer::produce(), and setP4().

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

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

protected

Definition at line 13 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
   }
 }

void pat::PackedCandidate::packBoth ( )

inlineprotected

Definition at line 1037 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

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

protected

Definition at line 78 of file PackedCandidate.cc.

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

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

inlineprivate

Definition at line 1003 of file PackedCandidate.h.

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

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

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

staticprotected

static to allow unit testing

Definition at line 419 of file PackedCandidate.cc.

References validate-o2o-wbm::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);
 }

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

staticprotected

Definition at line 439 of file PackedCandidate.cc.

References funct::abs(), validate-o2o-wbm::f, and SiStripPI::min.

                                                       {
   // 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);
 }

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

staticprotected

Definition at line 460 of file PackedCandidate.cc.

References funct::abs(), and validate-o2o-wbm::f.

                                                                          {
   // 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
   }
 }

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

protected

Definition at line 26 of file PackedCandidate.cc.

References c, funct::cos(), validate-o2o-wbm::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();
   }
 }

int pat::PackedCandidate::pdgId ( ) const

inlineoverridevirtual

PDG identifier.

Implements reco::Candidate.

Definition at line 847 of file PackedCandidate.h.

References pdgId_.

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

847 { return pdgId_; }

pat::PackedCandidate::pdgId_

int pdgId_

PDG identifier.

Definition: PackedCandidate.h:1070

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__(), DQMPFCandidateAnalyzer::analyze(), MuonFSRProducer::computeRelativeIsolation(), LeptonFSRProducer::computeRelativeIsolation(), DPFIsolation::getPredictions(), reco::tau::qcuts::minPackedCandVertexWeight(), ntupleDataFormat.Track::phiPull(), pat::PATTauProducer::produce(), and EvtPlaneProducer::produce().

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

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

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:1078

pat::PackedCandidate::trackPixelHitsMask

Definition: PackedCandidate.h:620

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

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 PrimaryVertexAssignment::chargedHadronVertex(), BPHTrackReference::getFromPC(), reco::tau::lead_track_chi2(), btagbtvdeep::packedCandidateToFeatures(), pat::PATTrackAndVertexUnpacker::produce(), and EvtPlaneProducer::produce().

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

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__(), DQMPFCandidateAnalyzer::analyze(), Photon.Photon::calScaledIsoValueExp(), Photon.Photon::calScaledIsoValueLin(), Photon.Photon::calScaledIsoValueQuadr(), MuonFSRProducer::computeRelativeIsolation(), LeptonFSRProducer::computeRelativeIsolation(), et(), et2(), DeepBoostedJetTagInfoProducer::fillParticleFeatures(), reco::tau::RecoTauQualityCuts::filterChargedCand(), DPFIsolation::getPredictions(), 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();
     }

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

float pat::PackedCandidate::puppiWeight ( ) const

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

Definition at line 380 of file PackedCandidate.cc.

References SiStripPI::max.

Referenced by DQMPFCandidateAnalyzer::analyze(), PileupJetIdAlgo::computeIdVariables(), DPFIsolation::getPredictions(), btagbtvdeep::packedCandidateToFeatures(), PATPuppiJetSpecificProducer::produce(), and PuppiProducer::produce().

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

float pat::PackedCandidate::puppiWeightNoLep ( ) const

Weight from full PUPPI.

Definition at line 384 of file PackedCandidate.cc.

References SiStripPI::max.

Referenced by DQMPFCandidateAnalyzer::analyze(), and PuppiProducer::produce().

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

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

inline

Definition at line 740 of file PackedCandidate.h.

References assignmentQualityMask, assignmentQualityShift, and qualityFlags_.

Referenced by PrimaryVertexAssignment::chargedHadronVertex(), fromPV(), DPFIsolation::getPredictions(), reco::tau::qcuts::minPackedCandVertexWeight(), and btagbtvdeep::packedCandidateToFeatures().

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

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

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

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

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

float pat::PackedCandidate::rawCaloFraction ( ) const

inline

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

Definition at line 935 of file PackedCandidate.h.

                                   {
       return (rawCaloFraction_ / 100.);
     }                                  

float pat::PackedCandidate::rawHcalFraction ( ) const

inline

Set the fraction of Hcal needed isolated charged hadrons.

Definition at line 939 of file PackedCandidate.h.

References rawHcalFraction_.

                                   {
       return (rawHcalFraction_ / 100.);
     }                               

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

inline

Definition at line 743 of file PackedCandidate.h.

References assignmentQualityMask, assignmentQualityShift, and qualityFlags_.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

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

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

Fraction of Hcal for isolated charged hadrons.

Definition at line 398 of file PackedCandidate.cc.

pat::PackedCandidate::caloFraction_

398 { caloFraction_ = 100 * p; }

uint8_t caloFraction_

Definition: PackedCandidate.h:1054

pat::PackedCandidate::covarianceVersion_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:463

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

inlineoverridevirtual

set electric charge

Implements reco::Candidate.

Definition at line 432 of file PackedCandidate.h.

432 {}

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:1085

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

set time measurement

Definition at line 404 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);
   }
 }

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

inline

Set first hit from HitPattern.

Definition at line 832 of file PackedCandidate.h.

References firstHit_.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

832 { firstHit_ = pattern; }

pat::PackedCandidate::firstHit_

uint16_t firstHit_

Definition: PackedCandidate.h:1142

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

inline

Definition at line 841 of file PackedCandidate.h.

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

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

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

Fraction of ECAL+HCAL energy over candidate energy.

Definition at line 400 of file PackedCandidate.cc.

400 { hcalFraction_ = 100 * p; }

pat::PackedCandidate::hcalFraction_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:463

int8_t hcalFraction_

Definition: PackedCandidate.h:1055

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

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

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

Definition at line 402 of file PackedCandidate.cc.

402 { isIsolatedChargedHadron_ = p; }

pat::PackedCandidate::isIsolatedChargedHadron_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:463

bool isIsolatedChargedHadron_

Definition: PackedCandidate.h:1059

void pat::PackedCandidate::setLongLived ( )

inlineoverridevirtual

set long lived flag

Implements reco::Candidate.

Definition at line 857 of file PackedCandidate.h.

857 {} /*FIXME*/

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

inline

Definition at line 823 of file PackedCandidate.h.

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

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

void pat::PackedCandidate::setMassConstraint ( )

inlineoverridevirtual

set mass constraint flag

Implements reco::Candidate.

Definition at line 863 of file PackedCandidate.h.

863 {} /*FIXME*/

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

inline

Definition at line 836 of file PackedCandidate.h.

References muonFlagsMask, muonFlagsShift, and qualityFlags_.

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

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_, 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();
     }

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

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

inlineoverridevirtual

Implements reco::Candidate.

Definition at line 849 of file PackedCandidate.h.

References pdgId(), and pdgId_.

849 { pdgId_ = pdgId; }

pat::PackedCandidate::pdgId

int pdgId() const override

PDG identifier.

Definition: PackedCandidate.h:847

pat::PackedCandidate::pdgId_

int pdgId_

PDG identifier.

Definition: PackedCandidate.h:1070

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

Definition at line 373 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);
 }

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

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

Weight from PUPPI removing leptons.

Definition at line 389 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;
 }

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

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

Definition at line 396 of file PackedCandidate.cc.

396 { rawHcalFraction_ = 100 * p; }

pat::PackedCandidate::rawHcalFraction_

double p() const override

magnitude of momentum vector

Definition: PackedCandidate.h:463

int8_t rawHcalFraction_

Definition: PackedCandidate.h:1053

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

inlineoverridevirtual

set status word

Implements reco::Candidate.

Definition at line 853 of file PackedCandidate.h.

853 {} /*FIXME*/

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

inlineoverridevirtual

set electric charge

Implements reco::Candidate.

Definition at line 436 of file PackedCandidate.h.

436 {}

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

inline

set time measurement

Definition at line 996 of file PackedCandidate.h.

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

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

submitPVValidationJobs.t

string t

Definition: submitPVValidationJobs.py:644

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:404

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

inline

set to true if the track had the highPurity quality bit

Definition at line 807 of file PackedCandidate.h.

References qualityFlags_, trackHighPurityMask, and trackHighPurityShift.

Referenced by DeepBoostedJetTagInfoProducer::fillParticleFeatures().

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

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

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

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_, packedHits_, trackPixelHitsMask, trackStripHitsMask, and trackStripHitsShift.

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

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

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

int pat::PackedCandidate::status ( ) const

inlineoverridevirtual

status word

Implements reco::Candidate.

Definition at line 851 of file PackedCandidate.h.

References qualityFlags_.

851 { return qualityFlags_; } /*FIXME*/

pat::PackedCandidate::packedLayers_

uint16_t qualityFlags_

Definition: PackedCandidate.h:1071

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:1078

pat::PackedCandidate::trackStripHitsShift

Definition: PackedCandidate.h:620

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

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

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

inlinevirtual

time (wrt nominal zero of the collision)

Definition at line 977 of file PackedCandidate.h.

References dtimeAssociatedPV(), and vertexRef().

Referenced by PrimaryVertexAssignment::chargedHadronVertex().

977 { 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:983

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

inlinevirtual

time measurement uncertainty (-1 if not available)

Definition at line 992 of file PackedCandidate.h.

References packedTimeError_, and unpackTimeError().

Referenced by PrimaryVertexAssignment::chargedHadronVertex().

992 { return unpackTimeError(packedTimeError_); }

pat::PackedCandidate::packedTimeError_

uint8_t packedTimeError_

Definition: PackedCandidate.h:1057

pat::PackedCandidate::unpackTimeError

static float unpackTimeError(uint8_t timeError)

Definition: PackedCandidate.cc:430

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

bool pat::PackedCandidate::trackHighPurity ( ) const

inline

true if the track had the highPurity quality bit

Definition at line 805 of file PackedCandidate.h.

References qualityFlags_, trackHighPurityMask, and trackHighPurityShift.

Referenced by DPFIsolation::getPredictions(), and EvtPlaneProducer::produce().

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

pat::PackedCandidate::trackHighPurityMask

Definition: PackedCandidate.h:1118

pat::PackedCandidate::trackHighPurityShift

Definition: PackedCandidate.h:1119