Inheritance diagram for ParticleNetFeatureEvaluator:

Public Member Functions
	ParticleNetFeatureEvaluator (const edm::ParameterSet &)

	~ParticleNetFeatureEvaluator () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	beginStream (edm::StreamID) override

void	endStream () override

void	fillLostTrackFeatures (DeepBoostedJetFeatures &fts, const reco::Jet &jet)

void	fillParticleFeatures (DeepBoostedJetFeatures &fts, const reco::Jet &jet, const std::vector< math::XYZTLorentzVector > &tau_pfcandidates, const pat::MuonCollection &muons, const pat::ElectronCollection &electrons, const pat::PhotonCollection &photons)

void	fillSVFeatures (DeepBoostedJetFeatures &fts, const reco::Jet &jet)

void	produce (edm::Event &, const edm::EventSetup &) override

bool	useTrackProperties (const pat::PackedCandidate *cand)

Private Attributes
edm::EDGetTokenT< pat::ElectronCollection >	electron_token_

unsigned int	event

const bool	flip_ip_sign_

unsigned int	ijet

const bool	include_neutrals_

float	jet_eta

std::vector< float >	jet_losttrack_charge

std::vector< float >	jet_losttrack_deta

std::vector< float >	jet_losttrack_dphi

std::vector< float >	jet_losttrack_dxy

std::vector< float >	jet_losttrack_dxysig

std::vector< float >	jet_losttrack_dz

std::vector< float >	jet_losttrack_dzsig

std::vector< float >	jet_losttrack_eta

std::vector< float >	jet_losttrack_etarel

std::vector< float >	jet_losttrack_frompv

std::vector< float >	jet_losttrack_npixhits

std::vector< float >	jet_losttrack_nstriphits

std::vector< float >	jet_losttrack_pt_log

std::vector< float >	jet_losttrack_track_chi2

std::vector< float >	jet_losttrack_track_qual

std::vector< float >	jet_losttrack_trackjet_d3d

std::vector< float >	jet_losttrack_trackjet_d3dsig

std::vector< float >	jet_losttrack_trackjet_decayL

std::vector< float >	jet_losttrack_trackjet_dist

float	jet_mass

std::vector< float >	jet_pfcand_calofraction

std::vector< float >	jet_pfcand_charge

std::vector< float >	jet_pfcand_deta

std::vector< float >	jet_pfcand_dphi

std::vector< float >	jet_pfcand_dxy

std::vector< float >	jet_pfcand_dxysig

std::vector< float >	jet_pfcand_dz

std::vector< float >	jet_pfcand_dzsig

std::vector< float >	jet_pfcand_electron_convProb

std::vector< float >	jet_pfcand_electron_detaIn

std::vector< float >	jet_pfcand_electron_dphiIn

std::vector< float >	jet_pfcand_electron_r9

std::vector< float >	jet_pfcand_electron_sigIetaIeta

std::vector< float >	jet_pfcand_electron_sigIphiIphi

std::vector< float >	jet_pfcand_energy_log

std::vector< float >	jet_pfcand_eta

std::vector< float >	jet_pfcand_etarel

std::vector< float >	jet_pfcand_frompv

std::vector< float >	jet_pfcand_hcalfraction

std::vector< float >	jet_pfcand_id

std::vector< float >	jet_pfcand_muon_chi2

std::vector< float >	jet_pfcand_muon_id

std::vector< float >	jet_pfcand_muon_isglobal

std::vector< float >	jet_pfcand_muon_nstation

std::vector< float >	jet_pfcand_muon_nvalidhit

std::vector< float >	jet_pfcand_muon_segcomp

std::vector< float >	jet_pfcand_nlostinnerhits

std::vector< float >	jet_pfcand_npixhits

std::vector< float >	jet_pfcand_nstriphits

std::vector< float >	jet_pfcand_photon_eVeto

std::vector< float >	jet_pfcand_photon_r9

std::vector< float >	jet_pfcand_photon_sigIetaIeta

std::vector< float >	jet_pfcand_ppara_ratio

std::vector< float >	jet_pfcand_pperp_ratio

std::vector< float >	jet_pfcand_pt_log

std::vector< float >	jet_pfcand_puppiw

std::vector< float >	jet_pfcand_tau_signal

std::vector< float >	jet_pfcand_track_chi2

std::vector< float >	jet_pfcand_track_qual

std::vector< float >	jet_pfcand_trackjet_d3d

std::vector< float >	jet_pfcand_trackjet_d3dsig

std::vector< float >	jet_pfcand_trackjet_decayL

std::vector< float >	jet_pfcand_trackjet_dist

float	jet_phi

float	jet_pt

float	jet_pt_raw

const double	jet_radius_

std::vector< float >	jet_sv_chi2

std::vector< float >	jet_sv_d3d

std::vector< float >	jet_sv_d3dsig

std::vector< float >	jet_sv_deta

std::vector< float >	jet_sv_dphi

std::vector< float >	jet_sv_dxy

std::vector< float >	jet_sv_dxysig

std::vector< float >	jet_sv_eta

std::vector< float >	jet_sv_mass

std::vector< float >	jet_sv_ntrack

std::vector< float >	jet_sv_pt_log

edm::EDGetTokenT< edm::View< reco::Jet > >	jet_token_

edm::EDGetTokenT< pat::PackedCandidateCollection >	losttrack_token_

edm::Handle< pat::PackedCandidateCollection >	losttracks_

const double	max_dr_for_losttrack_

const double	max_eta_for_taus_

const double	max_jet_eta_

const double	max_sip3dsig_for_flip_

const double	min_jet_eta_

const double	min_jet_pt_

const double	min_pt_for_losttrack_

const double	min_pt_for_pfcandidates_

const double	min_pt_for_taus_

const double	min_pt_for_track_properties_

edm::EDGetTokenT< pat::MuonCollection >	muon_token_

edm::EDGetTokenT< edm::View< reco::Candidate > >	pfcand_token_

edm::Handle< edm::View< reco::Candidate > >	pfcands_

edm::EDGetTokenT< pat::PhotonCollection >	photon_token_

const reco::Vertex *	pv_ = nullptr

edm::EDGetTokenT< reco::VertexCompositePtrCandidateCollection >	sv_token_

edm::Handle< reco::VertexCompositePtrCandidateCollection >	svs_

edm::EDGetTokenT< pat::TauCollection >	tau_token_

edm::ESHandle< TransientTrackBuilder >	track_builder_

edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	track_builder_token_

TTree *	tree

edm::EDGetTokenT< reco::VertexCollection >	vtx_token_

edm::Handle< reco::VertexCollection >	vtxs_

Static Private Attributes
static const std::vector< std::string >	losttrack_features_

static const std::vector< std::string >	particle_features_

static const std::vector< std::string >	sv_features_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 34 of file ParticleNetFeatureEvaluator.cc.

Constructor & Destructor Documentation

◆ ParticleNetFeatureEvaluator()

ParticleNetFeatureEvaluator::ParticleNetFeatureEvaluator ( const edm::ParameterSet & iConfig )

explicit

Definition at line 254 of file ParticleNetFeatureEvaluator.cc.

     : jet_radius_(iConfig.getParameter<double>("jet_radius")),
       min_jet_pt_(iConfig.getParameter<double>("min_jet_pt")),
       max_jet_eta_(iConfig.getParameter<double>("max_jet_eta")),
       min_jet_eta_(iConfig.getParameter<double>("min_jet_eta")),
       min_pt_for_track_properties_(iConfig.getParameter<double>("min_pt_for_track_properties")),
       min_pt_for_pfcandidates_(iConfig.getParameter<double>("min_pt_for_pfcandidates")),
       min_pt_for_losttrack_(iConfig.getParameter<double>("min_pt_for_losttrack")),
       max_dr_for_losttrack_(iConfig.getParameter<double>("max_dr_for_losttrack")),
       min_pt_for_taus_(iConfig.getParameter<double>("min_pt_for_taus")),
       max_eta_for_taus_(iConfig.getParameter<double>("max_eta_for_taus")),
       include_neutrals_(iConfig.getParameter<bool>("include_neutrals")),
       flip_ip_sign_(iConfig.getParameter<bool>("flip_ip_sign")),
       max_sip3dsig_for_flip_(iConfig.getParameter<double>("max_sip3dsig_for_flip")),
       muon_token_(consumes<pat::MuonCollection>(iConfig.getParameter<edm::InputTag>("muons"))),
       electron_token_(consumes<pat::ElectronCollection>(iConfig.getParameter<edm::InputTag>("electrons"))),
       photon_token_(consumes<pat::PhotonCollection>(iConfig.getParameter<edm::InputTag>("photons"))),
       tau_token_(consumes<pat::TauCollection>(iConfig.getParameter<edm::InputTag>("taus"))),
       jet_token_(consumes<edm::View<reco::Jet>>(iConfig.getParameter<edm::InputTag>("jets"))),
       losttrack_token_(consumes<pat::PackedCandidateCollection>(iConfig.getParameter<edm::InputTag>("losttracks"))),
       vtx_token_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertices"))),
       sv_token_(consumes<reco::VertexCompositePtrCandidateCollection>(
           iConfig.getParameter<edm::InputTag>("secondary_vertices"))),
       pfcand_token_(consumes<edm::View<reco::Candidate>>(iConfig.getParameter<edm::InputTag>("pf_candidates"))),
       track_builder_token_(
           esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"))) {
   produces<std::vector<reco::DeepBoostedJetTagInfo>>();
 }

◆ ~ParticleNetFeatureEvaluator()

ParticleNetFeatureEvaluator::~ParticleNetFeatureEvaluator ( )

override

Definition at line 283 of file ParticleNetFeatureEvaluator.cc.

283 {}

Member Function Documentation

◆ beginStream()

void ParticleNetFeatureEvaluator::beginStream ( edm::StreamID )

inlineoverrideprivate

Definition at line 42 of file ParticleNetFeatureEvaluator.cc.

42 {}

◆ endStream()

void ParticleNetFeatureEvaluator::endStream ( )

inlineoverrideprivate

Definition at line 44 of file ParticleNetFeatureEvaluator.cc.

44 {}

◆ fillDescriptions()

void ParticleNetFeatureEvaluator::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 285 of file ParticleNetFeatureEvaluator.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                              {
   // pfDeepBoostedJetTagInfos
   edm::ParameterSetDescription desc;
   desc.add<double>("jet_radius", 0.8);
   desc.add<double>("min_jet_pt", 150);
   desc.add<double>("max_jet_eta", 99);
   desc.add<double>("min_jet_eta", 0.0);
   desc.add<double>("min_pt_for_track_properties", -1);
   desc.add<double>("min_pt_for_pfcandidates", -1);
   desc.add<double>("min_pt_for_losttrack", 1);
   desc.add<double>("max_dr_for_losttrack", 0.4);
   desc.add<double>("min_pt_for_taus", 20.);
   desc.add<double>("max_eta_for_taus", 2.5);
   desc.add<bool>("include_neutrals", true);
   desc.add<bool>("flip_ip_sign", false);
   desc.add<double>("max_sip3dsig_for_flip", 99999);
   desc.add<edm::InputTag>("vertices", edm::InputTag("offlineSlimmedPrimaryVertices"));
   desc.add<edm::InputTag>("secondary_vertices", edm::InputTag("slimmedSecondaryVertices"));
   desc.add<edm::InputTag>("pf_candidates", edm::InputTag("packedPFCandidates"));
   desc.add<edm::InputTag>("losttracks", edm::InputTag("lostTracks"));
   desc.add<edm::InputTag>("jets", edm::InputTag("slimmedJetsAK8"));
   desc.add<edm::InputTag>("muons", edm::InputTag("slimmedMuons"));
   desc.add<edm::InputTag>("taus", edm::InputTag("slimmedTaus"));
   desc.add<edm::InputTag>("electrons", edm::InputTag("slimmedElectrons"));
   desc.add<edm::InputTag>("photons", edm::InputTag("slimmedPhotons"));
   descriptions.add("ParticleNetFeatureEvaluator", desc);
 }

◆ fillLostTrackFeatures()

void ParticleNetFeatureEvaluator::fillLostTrackFeatures	(	DeepBoostedJetFeatures &	fts,
		const reco::Jet &	jet
	)

private

Definition at line 731 of file ParticleNetFeatureEvaluator.cc.

References a, b, reco::deltaR(), reco::btau::etaRel(), btagbtvdeep::DeepBoostedJetFeatures::fill(), CommonMethods::isnan(), metsig::jet, IPTools::jetTrackDistance(), dqm-mbProfile::log, Skims_PA_cff::name, btagbtvdeep::DeepBoostedJetFeatures::reserve(), IPTools::signedDecayLength3D(), IPTools::signedImpactParameter3D(), Measurement1D::significance(), jetUpdater_cfi::sort, HLT_2024v12_cff::track, and Measurement1D::value().

                                                                                                        {
   // some jet properties
   TVector3 jet_direction(jet.momentum().Unit().x(), jet.momentum().Unit().y(), jet.momentum().Unit().z());
   GlobalVector jet_ref_track_dir(jet.px(), jet.py(), jet.pz());
   math::XYZVector jet_dir = jet.momentum().Unit();
 
   std::vector<pat::PackedCandidate> jet_lost_tracks;
   for (size_t itrk = 0; itrk < losttracks_->size(); itrk++) {
     if (reco::deltaR(losttracks_->at(itrk).p4(), jet.p4()) < max_dr_for_losttrack_ and
         losttracks_->at(itrk).pt() > min_pt_for_losttrack_) {
       jet_lost_tracks.push_back(losttracks_->at(itrk));
     }
   }
   std::sort(
       jet_lost_tracks.begin(), jet_lost_tracks.end(), [](const auto &a, const auto &b) { return a.pt() > b.pt(); });
 
   // reserve space
   for (const auto &name : losttrack_features_)
     fts.reserve(name, jet_lost_tracks.size());
 
   reco::VertexRef pv_ass = reco::VertexRef(vtxs_, 0);
   math::XYZPoint pv_ass_pos = pv_ass->position();
 
   for (auto const &ltrack : jet_lost_tracks) {
     const reco::Track *track = ltrack.bestTrack();
 
     // only when computing the nagative tagger: remove charged candidates with high sip3d
     if (flip_ip_sign_) {
       reco::TransientTrack transientTrack = track_builder_->build(*track);
       Measurement1D meas_ip3d = IPTools::signedImpactParameter3D(transientTrack, jet_ref_track_dir, *pv_).second;
       if (!std::isnan(meas_ip3d.significance()) && meas_ip3d.significance() > max_sip3dsig_for_flip_) {
         continue;
       }
     }
     float ip_sign = flip_ip_sign_ ? -1.f : 1.f;
 
     fts.fill("jet_losttrack_pt_log", std::isnan(std::log(ltrack.pt())) ? 0 : std::log(ltrack.pt()));
     fts.fill("jet_losttrack_eta", ltrack.eta());
     fts.fill("jet_losttrack_charge", ltrack.charge());
     fts.fill("jet_losttrack_frompv", ltrack.fromPV());
     fts.fill("jet_losttrack_dz", ip_sign * (std::isnan(ltrack.dz(pv_ass_pos)) ? 0 : ltrack.dz(pv_ass_pos)));
     fts.fill("jet_losttrack_dxy", ip_sign * (std::isnan(ltrack.dxy(pv_ass_pos)) ? 0 : ltrack.dxy(pv_ass_pos)));
     fts.fill("jet_losttrack_npixhits", ltrack.numberOfPixelHits());
     fts.fill("jet_losttrack_nstriphits", ltrack.stripLayersWithMeasurement());
 
     TVector3 ltrack_momentum(ltrack.momentum().x(), ltrack.momentum().y(), ltrack.momentum().z());
     fts.fill("jet_losttrack_deta", jet_direction.Eta() - ltrack_momentum.Eta());
     fts.fill("jet_losttrack_dphi", jet_direction.DeltaPhi(ltrack_momentum));
     fts.fill("jet_losttrack_etarel",
              std::isnan(reco::btau::etaRel(jet_dir, ltrack.momentum()))
                  ? 0
                  : reco::btau::etaRel(jet_dir, ltrack.momentum()));
 
     if (track) {
       fts.fill("jet_losttrack_track_chi2", track->normalizedChi2());
       fts.fill("jet_losttrack_track_qual", track->qualityMask());
       fts.fill("jet_losttrack_dxysig",
                std::isnan(fabs(ltrack.dxy(pv_ass_pos)) / ltrack.dxyError())
                    ? 0
                    : fabs(ltrack.dxy(pv_ass_pos)) / ltrack.dxyError());
       fts.fill("jet_losttrack_dzsig",
                std::isnan(fabs(ltrack.dz(pv_ass_pos)) / ltrack.dzError())
                    ? 0
                    : fabs(ltrack.dz(pv_ass_pos)) / ltrack.dzError());
 
       reco::TransientTrack transientTrack = track_builder_->build(*track);
       Measurement1D meas_ip3d = IPTools::signedImpactParameter3D(transientTrack, jet_ref_track_dir, *pv_).second;
       Measurement1D meas_jetdist = IPTools::jetTrackDistance(transientTrack, jet_ref_track_dir, *pv_).second;
       Measurement1D meas_decayl = IPTools::signedDecayLength3D(transientTrack, jet_ref_track_dir, *pv_).second;
 
       fts.fill("jet_losttrack_trackjet_d3d", ip_sign * (std::isnan(meas_ip3d.value()) ? 0 : meas_ip3d.value()));
       fts.fill("jet_losttrack_trackjet_d3dsig",
                std::isnan(fabs(meas_ip3d.significance())) ? 0 : fabs(meas_ip3d.significance()));
       fts.fill("jet_losttrack_trackjet_dist", std::isnan(-meas_jetdist.value()) ? 0 : -meas_jetdist.value());
       fts.fill("jet_losttrack_trackjet_decayL", std::isnan(meas_decayl.value()) ? 0 : meas_decayl.value());
     } else {
       fts.fill("jet_losttrack_track_chi2", 0);
       fts.fill("jet_losttrack_track_qual", 0);
       fts.fill("jet_losttrack_dxysig", 0);
       fts.fill("jet_losttrack_dzsig", 0);
       fts.fill("jet_losttrack_trackjet_d3d", 0);
       fts.fill("jet_losttrack_trackjet_d3dsig", 0);
       fts.fill("jet_losttrack_trackjet_dist", 0);
       fts.fill("jet_losttrack_trackjet_decayL", 0);
     }
 
     fts.fill("lt_mask", 1);
   }
 }

◆ fillParticleFeatures()

void ParticleNetFeatureEvaluator::fillParticleFeatures	(	DeepBoostedJetFeatures &	fts,
		const reco::Jet &	jet,
		const std::vector< math::XYZTLorentzVector > &	tau_pfcandidates,
		const pat::MuonCollection &	muons,
		const pat::ElectronCollection &	electrons,
		const pat::PhotonCollection &	photons
	)

private

Definition at line 401 of file ParticleNetFeatureEvaluator.cc.

References a, funct::abs(), b, electrons_cff::convVtxFitProb, reco::Muon::CutBasedIdGlobalHighPt, reco::Muon::CutBasedIdLoose, reco::Muon::CutBasedIdMedium, reco::Muon::CutBasedIdTight, reco::Muon::CutBasedIdTrkHighPt, BPhysicsValidation_cfi::daughters, reco::deltaR(), HGC3DClusterGenMatchSelector_cfi::dR, pwdgSkimBPark_cfi::electrons, reco::btau::etaRel(), Exception, btagbtvdeep::DeepBoostedJetFeatures::fill(), spr::find(), HLT_2024v12_cff::full5x5_sigmaIetaIeta, cutBasedMuonId_MuonPOG_V0_cff::globalTrack, mps_fire::i, edm::errors::InvalidReference, CommonMethods::isnan(), metsig::jet, IPTools::jetTrackDistance(), dqm-mbProfile::log, HLT_2024v12_cff::minDR, DiMuonV_cfg::muons, Skims_PA_cff::name, TrackCollections2monitor_cff::normalizedChi2, or, TriggerAnalyzer::passed, BPHMonitor_cfi::photons, btagbtvdeep::DeepBoostedJetFeatures::reserve(), muon::segmentCompatibility(), IPTools::signedDecayLength3D(), IPTools::signedImpactParameter3D(), IPTools::signedTransverseImpactParameter(), Measurement1D::significance(), jetUpdater_cfi::sort, HLT_2024v12_cff::track, TrackInfoProducer_cfi::trackinfo, and Measurement1D::value().

                                                                                            {
   // some jet properties
   math::XYZVector jet_dir = jet.momentum().Unit();
   TVector3 jet_direction(jet.momentum().Unit().x(), jet.momentum().Unit().y(), jet.momentum().Unit().z());
   GlobalVector jet_ref_track_dir(jet.px(), jet.py(), jet.pz());
   // vertexes
   reco::VertexRefProd PVRefProd(vtxs_);
   // track builder
   TrackInfoBuilder trackinfo(track_builder_);
 
   // make list of pf-candidates to be considered
   std::vector<const pat::PackedCandidate *> daughters;
   for (const auto &dau : jet.daughterPtrVector()) {
     // remove particles w/ extremely low puppi weights
     const pat::PackedCandidate *cand = dynamic_cast<const pat::PackedCandidate *>(&(*dau));
     if (not cand)
       throw edm::Exception(edm::errors::InvalidReference) << "Cannot convert to either pat::PackedCandidate";
     // base requirements on PF candidates
     if (cand->pt() < min_pt_for_pfcandidates_)
       continue;
     // charged candidate selection (for Higgs Interaction Net)
     if (!include_neutrals_ and (cand->charge() == 0 or cand->pt() < min_pt_for_track_properties_))
       continue;
     // filling daughters
     daughters.push_back(cand);
   }
 
   // sort by original pt (not Puppi-weighted)
   std::sort(daughters.begin(), daughters.end(), [](const auto &a, const auto &b) { return a->pt() > b->pt(); });
 
   // reserve space
   for (const auto &name : particle_features_)
     fts.reserve(name, daughters.size());
 
   // Build observables
   for (const auto &cand : daughters) {
     if (!include_neutrals_ and !useTrackProperties(cand))
       continue;
 
     // input particle is a packed PF candidate
     auto candP4 = cand->p4();
     auto candP3 = cand->momentum();
 
     // candidate track
     const reco::Track *track = nullptr;
     if (useTrackProperties(cand))
       track = cand->bestTrack();
 
     // reco-vertex association
     reco::VertexRef pv_ass = reco::VertexRef(vtxs_, 0);
     math::XYZPoint pv_ass_pos = pv_ass->position();
 
     TVector3 cand_direction(candP3.x(), candP3.y(), candP3.z());
 
     // only when computing the nagative tagger: remove charged candidates with high sip3d
     if (flip_ip_sign_ && track) {
       reco::TransientTrack transientTrack = track_builder_->build(*track);
       Measurement1D meas_ip3d = IPTools::signedImpactParameter3D(transientTrack, jet_ref_track_dir, *pv_).second;
       if (!std::isnan(meas_ip3d.significance()) && meas_ip3d.significance() > max_sip3dsig_for_flip_) {
         continue;
       }
     }
     float ip_sign = flip_ip_sign_ ? -1.f : 1.f;
 
     fts.fill("jet_pfcand_pt_log", std::isnan(std::log(candP4.pt())) ? 0 : std::log(candP4.pt()));
     fts.fill("jet_pfcand_energy_log", std::isnan(std::log(candP4.energy())) ? 0 : std::log(candP4.energy()));
     fts.fill("jet_pfcand_eta", candP4.eta());
     fts.fill("jet_pfcand_deta", jet_direction.Eta() - cand_direction.Eta());
     fts.fill("jet_pfcand_dphi", jet_direction.DeltaPhi(cand_direction));
     fts.fill("jet_pfcand_charge", cand->charge());
     fts.fill("jet_pfcand_etarel",
              std::isnan(reco::btau::etaRel(jet_dir, candP3)) ? 0 : reco::btau::etaRel(jet_dir, candP3));
     fts.fill("jet_pfcand_pperp_ratio",
              std::isnan(jet_direction.Perp(cand_direction) / cand_direction.Mag())
                  ? 0
                  : jet_direction.Perp(cand_direction) / cand_direction.Mag());
     fts.fill("jet_pfcand_ppara_ratio",
              std::isnan(jet_direction.Dot(cand_direction) / cand_direction.Mag())
                  ? 0
                  : jet_direction.Dot(cand_direction) / cand_direction.Mag());
     fts.fill("jet_pfcand_frompv", cand->fromPV());
     fts.fill("jet_pfcand_dz", ip_sign * (std::isnan(cand->dz(pv_ass_pos)) ? 0 : cand->dz(pv_ass_pos)));
     fts.fill("jet_pfcand_dxy", ip_sign * (std::isnan(cand->dxy(pv_ass_pos)) ? 0 : cand->dxy(pv_ass_pos)));
     fts.fill("jet_pfcand_puppiw", cand->puppiWeight());
     fts.fill("jet_pfcand_nlostinnerhits", cand->lostInnerHits());
     fts.fill("jet_pfcand_nhits", cand->numberOfHits());
     fts.fill("jet_pfcand_npixhits", cand->numberOfPixelHits());
     fts.fill("jet_pfcand_nstriphits", cand->stripLayersWithMeasurement());
 
     if (abs(cand->pdgId()) == 11 and cand->charge() != 0)
       fts.fill("jet_pfcand_id", 0);
     else if (abs(cand->pdgId()) == 13 and cand->charge() != 0)
       fts.fill("jet_pfcand_id", 1);
     else if (abs(cand->pdgId()) == 22 and cand->charge() == 0)
       fts.fill("jet_pfcand_id", 2);
     else if (abs(cand->pdgId()) != 22 and cand->charge() == 0 and abs(cand->pdgId()) != 1 and abs(cand->pdgId()) != 2)
       fts.fill("jet_pfcand_id", 3);
     else if (abs(cand->pdgId()) != 11 and abs(cand->pdgId()) != 13 and cand->charge() != 0)
       fts.fill("jet_pfcand_id", 4);
     else if (cand->charge() == 0 and abs(cand->pdgId()) == 1)
       fts.fill("jet_pfcand_id", 5);
     else if (cand->charge() == 0 and abs(cand->pdgId()) == 2)
       fts.fill("jet_pfcand_id", 6);
     else
       fts.fill("jet_pfcand_id", -1);
 
     fts.fill("jet_pfcand_hcalfraction", std::isnan(cand->hcalFraction()) ? 0 : cand->hcalFraction());
     fts.fill("jet_pfcand_calofraction", std::isnan(cand->caloFraction()) ? 0 : cand->caloFraction());
     fts.fill("pfcand_mask", 1);
 
     if (track) {
       fts.fill(
           "jet_pfcand_dzsig",
           std::isnan(fabs(cand->dz(pv_ass_pos)) / cand->dzError()) ? 0 : fabs(cand->dz(pv_ass_pos)) / cand->dzError());
       fts.fill("jet_pfcand_dxysig",
                std::isnan(fabs(cand->dxy(pv_ass_pos)) / cand->dxyError())
                    ? 0
                    : fabs(cand->dxy(pv_ass_pos)) / cand->dxyError());
       fts.fill("jet_pfcand_track_chi2", track->normalizedChi2());
       fts.fill("jet_pfcand_track_qual", track->qualityMask());
 
       reco::TransientTrack transientTrack = track_builder_->build(*track);
       Measurement1D meas_ip2d =
           IPTools::signedTransverseImpactParameter(transientTrack, jet_ref_track_dir, *pv_).second;
       Measurement1D meas_ip3d = IPTools::signedImpactParameter3D(transientTrack, jet_ref_track_dir, *pv_).second;
       Measurement1D meas_jetdist = IPTools::jetTrackDistance(transientTrack, jet_ref_track_dir, *pv_).second;
       Measurement1D meas_decayl = IPTools::signedDecayLength3D(transientTrack, jet_ref_track_dir, *pv_).second;
 
       fts.fill("jet_pfcand_trackjet_d3d", ip_sign * (std::isnan(meas_ip3d.value()) ? 0 : meas_ip3d.value()));
       fts.fill("jet_pfcand_trackjet_d3dsig",
                std::isnan(fabs(meas_ip3d.significance())) ? 0 : fabs(meas_ip3d.significance()));
       fts.fill("jet_pfcand_trackjet_dist", std::isnan(-meas_jetdist.value()) ? 0 : -meas_jetdist.value());
       fts.fill("jet_pfcand_trackjet_decayL", std::isnan(meas_decayl.value()) ? 0 : meas_decayl.value());
     } else {
       fts.fill("jet_pfcand_dzsig", 0);
       fts.fill("jet_pfcand_dxysig", 0);
       fts.fill("jet_pfcand_track_chi2", 0);
       fts.fill("jet_pfcand_track_qual", 0);
       fts.fill("jet_pfcand_trackjet_d3d", 0);
       fts.fill("jet_pfcand_trackjet_d3dsig", 0);
       fts.fill("jet_pfcand_trackjet_dist", 0);
       fts.fill("jet_pfcand_trackjet_decayL", 0);
     }
 
     // muons specific
     if (abs(cand->pdgId()) == 13) {
       std::vector<unsigned int> muonsToSkip;
       int ipos = -1;
       float minDR = 1000;
       for (size_t i = 0; i < muons.size(); i++) {
         if (not muons[i].isPFMuon())
           continue;
         if (std::find(muonsToSkip.begin(), muonsToSkip.end(), i) != muonsToSkip.end())
           continue;
         float dR = reco::deltaR(muons[i].p4(), candP4);
         if (dR < jet_radius_ and dR < minDR) {
           minDR = dR;
           ipos = i;
           muonsToSkip.push_back(i);
         }
       }
       if (ipos >= 0) {
         int muonId = 0;
         if (muons[ipos].passed(reco::Muon::CutBasedIdLoose))
           muonId++;
         if (muons[ipos].passed(reco::Muon::CutBasedIdMedium))
           muonId++;
         if (muons[ipos].passed(reco::Muon::CutBasedIdTight))
           muonId++;
         if (muons[ipos].passed(reco::Muon::CutBasedIdGlobalHighPt))
           muonId++;
         if (muons[ipos].passed(reco::Muon::CutBasedIdTrkHighPt))
           muonId++;
         fts.fill("jet_pfcand_muon_id", muonId);
         fts.fill("jet_pfcand_muon_isglobal", muons[ipos].isGlobalMuon());
         fts.fill("jet_pfcand_muon_chi2",
                  (muons[ipos].isGlobalMuon()) ? muons[ipos].globalTrack()->normalizedChi2() : 0);
         fts.fill("jet_pfcand_muon_nvalidhit",
                  (muons[ipos].isGlobalMuon()) ? muons[ipos].globalTrack()->hitPattern().numberOfValidMuonHits() : 0);
         fts.fill("jet_pfcand_muon_nstation", muons[ipos].numberOfMatchedStations());
         fts.fill("jet_pfcand_muon_segcomp", muon::segmentCompatibility(muons[ipos]));
       } else {
         fts.fill("jet_pfcand_muon_id", 0);
         fts.fill("jet_pfcand_muon_isglobal", 0);
         fts.fill("jet_pfcand_muon_chi2", 0);
         fts.fill("jet_pfcand_muon_nvalidhit", 0);
         fts.fill("jet_pfcand_muon_nstation", 0);
         fts.fill("jet_pfcand_muon_segcomp", 0);
       }
     } else {
       fts.fill("jet_pfcand_muon_id", 0);
       fts.fill("jet_pfcand_muon_isglobal", 0);
       fts.fill("jet_pfcand_muon_chi2", 0);
       fts.fill("jet_pfcand_muon_nvalidhit", 0);
       fts.fill("jet_pfcand_muon_nstation", 0);
       fts.fill("jet_pfcand_muon_segcomp", 0);
     }
 
     // electrons specific
     if (abs(cand->pdgId()) == 11) {
       int ipos = -1;
       for (size_t i = 0; i < electrons.size(); i++) {
         if (electrons[i].isPF()) {
           for (const auto &element : electrons[i].associatedPackedPFCandidates()) {
             if (abs(element->pdgId()) == 11 and element->p4() == candP4)
               ipos = i;
           }
         }
       }
       if (ipos >= 0) {
         fts.fill("jet_pfcand_electron_detaIn",
                  std::isnan(electrons[ipos].deltaEtaSuperClusterTrackAtVtx())
                      ? 0
                      : electrons[ipos].deltaEtaSuperClusterTrackAtVtx());
         fts.fill("jet_pfcand_electron_dphiIn",
                  std::isnan(electrons[ipos].deltaPhiSuperClusterTrackAtVtx())
                      ? 0
                      : electrons[ipos].deltaPhiSuperClusterTrackAtVtx());
         fts.fill("jet_pfcand_electron_sigIetaIeta",
                  std::isnan(electrons[ipos].full5x5_sigmaIetaIeta()) ? 0 : electrons[ipos].full5x5_sigmaIetaIeta());
         fts.fill("jet_pfcand_electron_sigIphiIphi",
                  std::isnan(electrons[ipos].full5x5_sigmaIphiIphi()) ? 0 : electrons[ipos].full5x5_sigmaIphiIphi());
         fts.fill("jet_pfcand_electron_r9", std::isnan(electrons[ipos].full5x5_r9()) ? 0 : electrons[ipos].full5x5_r9());
         fts.fill("jet_pfcand_electron_convProb",
                  std::isnan(electrons[ipos].convVtxFitProb()) ? 0 : electrons[ipos].convVtxFitProb());
       } else {
         fts.fill("jet_pfcand_electron_detaIn", 0);
         fts.fill("jet_pfcand_electron_dphiIn", 0);
         fts.fill("jet_pfcand_electron_sigIetaIeta", 0);
         fts.fill("jet_pfcand_electron_sigIphiIphi", 0);
         fts.fill("jet_pfcand_electron_r9", 0);
         fts.fill("jet_pfcand_electron_convProb", 0);
       }
     } else {
       fts.fill("jet_pfcand_electron_detaIn", 0);
       fts.fill("jet_pfcand_electron_dphiIn", 0);
       fts.fill("jet_pfcand_electron_sigIetaIeta", 0);
       fts.fill("jet_pfcand_electron_sigIphiIphi", 0);
       fts.fill("jet_pfcand_electron_r9", 0);
       fts.fill("jet_pfcand_electron_convProb", 0);
     }
 
     // photons specific
     if (abs(cand->pdgId()) == 22) {
       int ipos = -1;
       for (size_t i = 0; i < photons.size(); i++) {
         for (const auto &element : photons[i].associatedPackedPFCandidates()) {
           if (abs(element->pdgId()) == 22 and element->p4() == candP4)
             ipos = i;
         }
       }
       if (ipos >= 0) {
         fts.fill("jet_pfcand_photon_sigIetaIeta",
                  std::isnan(photons[ipos].full5x5_sigmaIetaIeta()) ? 0 : photons[ipos].full5x5_sigmaIetaIeta());
         fts.fill("jet_pfcand_photon_r9", std::isnan(photons[ipos].full5x5_r9()) ? 0 : photons[ipos].full5x5_r9());
         fts.fill("jet_pfcand_photon_eVeto", photons[ipos].passElectronVeto());
       } else {
         fts.fill("jet_pfcand_photon_sigIetaIeta", 0);
         fts.fill("jet_pfcand_photon_r9", 0);
         fts.fill("jet_pfcand_photon_eVeto", 0);
       }
     } else {
       fts.fill("jet_pfcand_photon_sigIetaIeta", 0);
       fts.fill("jet_pfcand_photon_r9", 0);
       fts.fill("jet_pfcand_photon_eVeto", 0);
     }
 
     // tau specific prior to any puppi weight application
     if (std::find(tau_pfcandidates.begin(), tau_pfcandidates.end(), cand->p4()) != tau_pfcandidates.end())
       fts.fill("jet_pfcand_tau_signal", 1);
     else
       fts.fill("jet_pfcand_tau_signal", 0);
   }
 }

◆ fillSVFeatures()

void ParticleNetFeatureEvaluator::fillSVFeatures	(	DeepBoostedJetFeatures &	fts,
		const reco::Jet &	jet
	)

private

Definition at line 681 of file ParticleNetFeatureEvaluator.cc.

References reco::deltaR2(), PVValHelper::dxy, btagbtvdeep::DeepBoostedJetFeatures::fill(), CommonMethods::isnan(), metsig::jet, dqm-mbProfile::log, Skims_PA_cff::name, btagbtvdeep::DeepBoostedJetFeatures::reserve(), VertexDistance3D::signedDistance(), jetUpdater_cfi::sort, pfDeepBoostedJetPreprocessParams_cfi::sv, and btagbtvdeep::sv_vertex_comparator().

                                                                                                 {
   // secondary vertexes matching jet
   std::vector<const reco::VertexCompositePtrCandidate *> jetSVs;
   for (const auto &sv : *svs_) {
     if (reco::deltaR2(sv, jet) < jet_radius_ * jet_radius_) {
       jetSVs.push_back(&sv);
     }
   }
 
   // sort by dxy significance
   std::sort(jetSVs.begin(),
             jetSVs.end(),
             [&](const reco::VertexCompositePtrCandidate *sva, const reco::VertexCompositePtrCandidate *svb) {
               return sv_vertex_comparator(*sva, *svb, *pv_);
             });
 
   // reserve space
   for (const auto &name : sv_features_)
     fts.reserve(name, jetSVs.size());
 
   GlobalVector jet_global_vec(jet.px(), jet.py(), jet.pz());
 
   float ip_sign = flip_ip_sign_ ? -1.f : 1.f;
 
   for (const auto *sv : jetSVs) {
     fts.fill("sv_mask", 1);
     fts.fill("jet_sv_pt_log", std::isnan(std::log(sv->pt())) ? 0 : std::log(sv->pt()));
     fts.fill("jet_sv_eta", sv->eta());
     fts.fill("jet_sv_mass", sv->mass());
     fts.fill("jet_sv_deta", sv->eta() - jet.eta());
     fts.fill("jet_sv_dphi", sv->phi() - jet.phi());
     fts.fill("jet_sv_ntrack", sv->numberOfDaughters());
     fts.fill("jet_sv_chi2", sv->vertexNormalizedChi2());
 
     reco::Vertex::CovarianceMatrix csv;
     sv->fillVertexCovariance(csv);
     reco::Vertex svtx(sv->vertex(), csv);
 
     VertexDistanceXY dxy;
     auto valxy = dxy.signedDistance(svtx, *pv_, jet_global_vec);
     fts.fill("jet_sv_dxy", ip_sign * (std::isnan(valxy.value()) ? 0 : valxy.value()));
     fts.fill("jet_sv_dxysig", std::isnan(fabs(valxy.significance())) ? 0 : fabs(valxy.significance()));
 
     VertexDistance3D d3d;
     auto val3d = d3d.signedDistance(svtx, *pv_, jet_global_vec);
     fts.fill("jet_sv_d3d", ip_sign * (std::isnan(val3d.value()) ? 0 : val3d.value()));
     fts.fill("jet_sv_d3dsig", std::isnan(fabs(val3d.significance())) ? 0 : fabs(val3d.significance()));
   }
 }

◆ produce()

void ParticleNetFeatureEvaluator::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 313 of file ParticleNetFeatureEvaluator.cc.

References funct::abs(), pwdgSkimBPark_cfi::electrons, lowptgsfeleseed::features(), edm::EventSetup::getHandle(), iEvent, metsig::jet, PDWG_EXODelayedJetMET_cff::jets, eostools::move(), DiMuonV_cfg::muons, Skims_PA_cff::name, or, pfDeepBoostedJetPreprocessParams_cfi::pfcand, BPHMonitor_cfi::photons, reco::LeafCandidate::pt(), and Tau3MuMonitor_cff::taus.

                                                                                        {
   // output collection
   auto output_tag_infos = std::make_unique<std::vector<reco::DeepBoostedJetTagInfo>>();
   // Input jets
   auto jets = iEvent.getHandle(jet_token_);
   // Input muons
   auto muons = iEvent.getHandle(muon_token_);
   // Input taus
   auto taus = iEvent.getHandle(tau_token_);
   // Input electrons
   auto electrons = iEvent.getHandle(electron_token_);
   // Input photons
   auto photons = iEvent.getHandle(photon_token_);
   // Input lost tracks
   iEvent.getByToken(losttrack_token_, losttracks_);
   // Primary vertexes
   iEvent.getByToken(vtx_token_, vtxs_);
   if (vtxs_->empty()) {
     // produce empty TagInfos in case no primary vertex
     iEvent.put(std::move(output_tag_infos));
     return;  // exit event
   }
   // Leading vertex
   pv_ = &vtxs_->at(0);
   // Secondary vertexs
   iEvent.getByToken(sv_token_, svs_);
   // PF candidates
   iEvent.getByToken(pfcand_token_, pfcands_);
   // Track builder
   track_builder_ = iSetup.getHandle(track_builder_token_);
 
   // tau signal candidates
   std::vector<math::XYZTLorentzVector> tau_pfcandidates;
   for (size_t itau = 0; itau < taus->size(); itau++) {
     if (taus->at(itau).pt() < min_pt_for_taus_)
       continue;
     if (fabs(taus->at(itau).eta()) > max_eta_for_taus_)
       continue;
     for (unsigned ipart = 0; ipart < taus->at(itau).signalCands().size(); ipart++) {
       const pat::PackedCandidate *pfcand =
           dynamic_cast<const pat::PackedCandidate *>(taus->at(itau).signalCands()[ipart].get());
       tau_pfcandidates.push_back(pfcand->p4());
     }
   }
 
   // Loop over jet
   for (std::size_t jet_n = 0; jet_n < jets->size(); jet_n++) {
     const auto &jet = (*jets)[jet_n];
     edm::RefToBase<reco::Jet> jet_ref(jets, jet_n);
 
     // create jet features
     DeepBoostedJetFeatures features;
     for (const auto &name : particle_features_)
       features.add(name);
     for (const auto &name : sv_features_)
       features.add(name);
 
     // fill values only if above pt threshold and has daughters, otherwise left
     bool fill_vars = true;
     if ((jet.pt() < min_jet_pt_ and
          dynamic_cast<const pat::Jet *>(&jet)->correctedJet("Uncorrected").pt() < min_jet_pt_) or
         std::abs(jet.eta()) >= max_jet_eta_ or std::abs(jet.eta()) < min_jet_eta_)
       fill_vars = false;
     if (jet.numberOfDaughters() == 0)
       fill_vars = false;
 
     // fill features
     if (fill_vars) {
       fillParticleFeatures(features, jet, tau_pfcandidates, *muons, *electrons, *photons);
       fillSVFeatures(features, jet);
       fillLostTrackFeatures(features, jet);
       features.check_consistency(particle_features_);
       features.check_consistency(sv_features_);
       features.check_consistency(losttrack_features_);
     }
 
     // this should always be done even if features are not filled
     output_tag_infos->emplace_back(features, jet_ref);
   }
   // move output collection
   iEvent.put(std::move(output_tag_infos));
 }

◆ useTrackProperties()

bool ParticleNetFeatureEvaluator::useTrackProperties ( const pat::PackedCandidate * cand )

private

Definition at line 396 of file ParticleNetFeatureEvaluator.cc.

References HLT_2024v12_cff::track.

                                                                                    {
   const auto *track = cand->bestTrack();
   return track != nullptr and track->pt() > min_pt_for_track_properties_;
 };

Member Data Documentation

◆ electron_token_

edm::EDGetTokenT<pat::ElectronCollection> ParticleNetFeatureEvaluator::electron_token_

private

Definition at line 70 of file ParticleNetFeatureEvaluator.cc.

◆ event

unsigned int ParticleNetFeatureEvaluator::event

private

Definition at line 92 of file ParticleNetFeatureEvaluator.cc.

Referenced by Types.EventID::cppID().

◆ flip_ip_sign_

const bool ParticleNetFeatureEvaluator::flip_ip_sign_

private

Definition at line 66 of file ParticleNetFeatureEvaluator.cc.

◆ ijet

unsigned int ParticleNetFeatureEvaluator::ijet

private

Definition at line 98 of file ParticleNetFeatureEvaluator.cc.

◆ include_neutrals_

const bool ParticleNetFeatureEvaluator::include_neutrals_

private

Definition at line 65 of file ParticleNetFeatureEvaluator.cc.

◆ jet_eta

float ParticleNetFeatureEvaluator::jet_eta

private

Definition at line 95 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_charge

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_charge

private

Definition at line 157 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_deta

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_deta

private

Definition at line 155 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_dphi

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_dphi

private

Definition at line 156 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_dxy

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_dxy

private

Definition at line 162 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_dxysig

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_dxysig

private

Definition at line 164 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_dz

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_dz

private

Definition at line 161 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_dzsig

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_dzsig

private

Definition at line 163 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_eta

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_eta

private

Definition at line 154 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_etarel

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_etarel

private

Definition at line 165 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_frompv

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_frompv

private

Definition at line 158 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_npixhits

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_npixhits

private

Definition at line 170 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_nstriphits

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_nstriphits

private

Definition at line 171 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_pt_log

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_pt_log

private

Definition at line 153 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_track_chi2

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_track_chi2

private

Definition at line 159 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_track_qual

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_track_qual

private

Definition at line 160 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_trackjet_d3d

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_trackjet_d3d

private

Definition at line 166 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_trackjet_d3dsig

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_trackjet_d3dsig

private

Definition at line 167 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_trackjet_decayL

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_trackjet_decayL

private

Definition at line 169 of file ParticleNetFeatureEvaluator.cc.

◆ jet_losttrack_trackjet_dist

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_trackjet_dist

private

Definition at line 168 of file ParticleNetFeatureEvaluator.cc.

◆ jet_mass

float ParticleNetFeatureEvaluator::jet_mass

private

Definition at line 97 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_calofraction

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_calofraction

private

Definition at line 123 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_charge

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_charge

private

Definition at line 104 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_deta

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_deta

private

Definition at line 101 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_dphi

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_dphi

private

Definition at line 102 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_dxy

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_dxy

private

Definition at line 111 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_dxysig

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_dxysig

private

Definition at line 112 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_dz

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_dz

private

Definition at line 109 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_dzsig

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_dzsig

private

Definition at line 110 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_electron_convProb

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_convProb

private

Definition at line 137 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_electron_detaIn

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_detaIn

private

Definition at line 132 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_electron_dphiIn

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_dphiIn

private

Definition at line 133 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_electron_r9

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_r9

private

Definition at line 136 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_electron_sigIetaIeta

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_sigIetaIeta

private

Definition at line 134 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_electron_sigIphiIphi

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_sigIphiIphi

private

Definition at line 135 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_energy_log

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_energy_log

private

Definition at line 100 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_eta

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_eta

private

Definition at line 103 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_etarel

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_etarel

private

Definition at line 113 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_frompv

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_frompv

private

Definition at line 105 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_hcalfraction

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_hcalfraction

private

Definition at line 124 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_id

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_id

private

Definition at line 122 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_muon_chi2

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_chi2

private

Definition at line 128 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_muon_id

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_id

private

Definition at line 126 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_muon_isglobal

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_isglobal

private

Definition at line 127 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_muon_nstation

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_nstation

private

Definition at line 131 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_muon_nvalidhit

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_nvalidhit

private

Definition at line 130 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_muon_segcomp

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_segcomp

private

Definition at line 129 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_nlostinnerhits

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_nlostinnerhits

private

Definition at line 106 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_npixhits

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_npixhits

private

Definition at line 119 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_nstriphits

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_nstriphits

private

Definition at line 120 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_photon_eVeto

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_photon_eVeto

private

Definition at line 140 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_photon_r9

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_photon_r9

private

Definition at line 139 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_photon_sigIetaIeta

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_photon_sigIetaIeta

private

Definition at line 138 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_ppara_ratio

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_ppara_ratio

private

Definition at line 115 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_pperp_ratio

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_pperp_ratio

private

Definition at line 114 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_pt_log

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_pt_log

private

Definition at line 99 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_puppiw

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_puppiw

private

Definition at line 125 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_tau_signal

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_tau_signal

private

Definition at line 141 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_track_chi2

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_track_chi2

private

Definition at line 107 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_track_qual

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_track_qual

private

Definition at line 108 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_trackjet_d3d

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_trackjet_d3d

private

Definition at line 116 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_trackjet_d3dsig

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_trackjet_d3dsig

private

Definition at line 117 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_trackjet_decayL

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_trackjet_decayL

private

Definition at line 121 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pfcand_trackjet_dist

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_trackjet_dist

private

Definition at line 118 of file ParticleNetFeatureEvaluator.cc.

◆ jet_phi

float ParticleNetFeatureEvaluator::jet_phi

private

Definition at line 96 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pt

float ParticleNetFeatureEvaluator::jet_pt

private

Definition at line 93 of file ParticleNetFeatureEvaluator.cc.

◆ jet_pt_raw

float ParticleNetFeatureEvaluator::jet_pt_raw

private

Definition at line 94 of file ParticleNetFeatureEvaluator.cc.

◆ jet_radius_

const double ParticleNetFeatureEvaluator::jet_radius_

private

Definition at line 55 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_chi2

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_chi2

private

Definition at line 148 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_d3d

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_d3d

private

Definition at line 151 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_d3dsig

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_d3dsig

private

Definition at line 152 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_deta

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_deta

private

Definition at line 144 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_dphi

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_dphi

private

Definition at line 145 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_dxy

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_dxy

private

Definition at line 149 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_dxysig

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_dxysig

private

Definition at line 150 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_eta

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_eta

private

Definition at line 146 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_mass

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_mass

private

Definition at line 143 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_ntrack

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_ntrack

private

Definition at line 147 of file ParticleNetFeatureEvaluator.cc.

◆ jet_sv_pt_log

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_pt_log

private

Definition at line 142 of file ParticleNetFeatureEvaluator.cc.

◆ jet_token_

edm::EDGetTokenT<edm::View<reco::Jet> > ParticleNetFeatureEvaluator::jet_token_

private

Definition at line 73 of file ParticleNetFeatureEvaluator.cc.

◆ losttrack_features_

const std::vector< std::string > ParticleNetFeatureEvaluator::losttrack_features_

staticprivate

Initial value:

{"jet_losttrack_pt_log",
                                                                                "jet_losttrack_eta",
                                                                                "jet_losttrack_deta",
                                                                                "jet_losttrack_dphi",
                                                                                "jet_losttrack_charge",
                                                                                "jet_losttrack_frompv",
                                                                                "jet_losttrack_track_chi2",
                                                                                "jet_losttrack_track_qual",
                                                                                "jet_losttrack_dz",
                                                                                "jet_losttrack_dxy",
                                                                                "jet_losttrack_dzsig",
                                                                                "jet_losttrack_dxysig",
                                                                                "jet_losttrack_etarel",
                                                                                "jet_losttrack_trackjet_d3d",
                                                                                "jet_losttrack_trackjet_d3dsig",
                                                                                "jet_losttrack_trackjet_dist",
                                                                                "jet_losttrack_trackjet_decayL",
                                                                                "jet_losttrack_npixhits",
                                                                                "jet_losttrack_nstriphits",
                                                                                "lt_mask"}

Definition at line 88 of file ParticleNetFeatureEvaluator.cc.

◆ losttrack_token_

edm::EDGetTokenT<pat::PackedCandidateCollection> ParticleNetFeatureEvaluator::losttrack_token_

private

Definition at line 74 of file ParticleNetFeatureEvaluator.cc.

◆ losttracks_

edm::Handle<pat::PackedCandidateCollection> ParticleNetFeatureEvaluator::losttracks_

private

Definition at line 83 of file ParticleNetFeatureEvaluator.cc.

◆ max_dr_for_losttrack_

const double ParticleNetFeatureEvaluator::max_dr_for_losttrack_

private

Definition at line 62 of file ParticleNetFeatureEvaluator.cc.

◆ max_eta_for_taus_

const double ParticleNetFeatureEvaluator::max_eta_for_taus_

private

Definition at line 64 of file ParticleNetFeatureEvaluator.cc.

◆ max_jet_eta_

const double ParticleNetFeatureEvaluator::max_jet_eta_

private

Definition at line 57 of file ParticleNetFeatureEvaluator.cc.

◆ max_sip3dsig_for_flip_

const double ParticleNetFeatureEvaluator::max_sip3dsig_for_flip_

private

Definition at line 67 of file ParticleNetFeatureEvaluator.cc.

◆ min_jet_eta_

const double ParticleNetFeatureEvaluator::min_jet_eta_

private

Definition at line 58 of file ParticleNetFeatureEvaluator.cc.

◆ min_jet_pt_

const double ParticleNetFeatureEvaluator::min_jet_pt_

private

Definition at line 56 of file ParticleNetFeatureEvaluator.cc.

◆ min_pt_for_losttrack_

const double ParticleNetFeatureEvaluator::min_pt_for_losttrack_

private

Definition at line 61 of file ParticleNetFeatureEvaluator.cc.

◆ min_pt_for_pfcandidates_

const double ParticleNetFeatureEvaluator::min_pt_for_pfcandidates_

private

Definition at line 60 of file ParticleNetFeatureEvaluator.cc.

◆ min_pt_for_taus_

const double ParticleNetFeatureEvaluator::min_pt_for_taus_

private

Definition at line 63 of file ParticleNetFeatureEvaluator.cc.

◆ min_pt_for_track_properties_

const double ParticleNetFeatureEvaluator::min_pt_for_track_properties_

private

Definition at line 59 of file ParticleNetFeatureEvaluator.cc.

◆ muon_token_

edm::EDGetTokenT<pat::MuonCollection> ParticleNetFeatureEvaluator::muon_token_

private

Definition at line 69 of file ParticleNetFeatureEvaluator.cc.

◆ particle_features_

const std::vector< std::string > ParticleNetFeatureEvaluator::particle_features_

staticprivate

Definition at line 86 of file ParticleNetFeatureEvaluator.cc.

◆ pfcand_token_

edm::EDGetTokenT<edm::View<reco::Candidate> > ParticleNetFeatureEvaluator::pfcand_token_

private

Definition at line 77 of file ParticleNetFeatureEvaluator.cc.

◆ pfcands_

edm::Handle<edm::View<reco::Candidate> > ParticleNetFeatureEvaluator::pfcands_

private

Definition at line 82 of file ParticleNetFeatureEvaluator.cc.

◆ photon_token_

edm::EDGetTokenT<pat::PhotonCollection> ParticleNetFeatureEvaluator::photon_token_

private

Definition at line 71 of file ParticleNetFeatureEvaluator.cc.

◆ pv_

const reco::Vertex* ParticleNetFeatureEvaluator::pv_ = nullptr

private

Definition at line 89 of file ParticleNetFeatureEvaluator.cc.

◆ sv_features_

const std::vector< std::string > ParticleNetFeatureEvaluator::sv_features_

staticprivate

Initial value:

{"jet_sv_pt_log",
                                                                         "jet_sv_mass",
                                                                         "jet_sv_deta",
                                                                         "jet_sv_dphi",
                                                                         "jet_sv_eta",
                                                                         "jet_sv_ntrack",
                                                                         "jet_sv_chi2",
                                                                         "jet_sv_dxy",
                                                                         "jet_sv_dxysig",
                                                                         "jet_sv_d3d",
                                                                         "jet_sv_d3dsig",
                                                                         "sv_mask"}

Definition at line 87 of file ParticleNetFeatureEvaluator.cc.

◆ sv_token_

edm::EDGetTokenT<reco::VertexCompositePtrCandidateCollection> ParticleNetFeatureEvaluator::sv_token_

private

Definition at line 76 of file ParticleNetFeatureEvaluator.cc.

◆ svs_

edm::Handle<reco::VertexCompositePtrCandidateCollection> ParticleNetFeatureEvaluator::svs_

private

Definition at line 81 of file ParticleNetFeatureEvaluator.cc.

◆ tau_token_

edm::EDGetTokenT<pat::TauCollection> ParticleNetFeatureEvaluator::tau_token_

private

Definition at line 72 of file ParticleNetFeatureEvaluator.cc.

◆ track_builder_

edm::ESHandle<TransientTrackBuilder> ParticleNetFeatureEvaluator::track_builder_

private

Definition at line 84 of file ParticleNetFeatureEvaluator.cc.

◆ track_builder_token_

edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> ParticleNetFeatureEvaluator::track_builder_token_

private

Definition at line 78 of file ParticleNetFeatureEvaluator.cc.

◆ tree

TTree* ParticleNetFeatureEvaluator::tree

private

Definition at line 91 of file ParticleNetFeatureEvaluator.cc.

Referenced by svgfig.SVG::__str__(), ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::beginLoop(), MetTreeProducer.MetTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::declareVariables(), core.AutoFillTreeProducer.AutoFillTreeProducer::fillTree(), ZJetsTreeAnalyzer.ZJetsTreeAnalyzer::process(), MetTreeProducer.MetTreeProducer::process(), and python.cmstools.EventTree::SetAlias().

◆ vtx_token_

edm::EDGetTokenT<reco::VertexCollection> ParticleNetFeatureEvaluator::vtx_token_

private

Definition at line 75 of file ParticleNetFeatureEvaluator.cc.

◆ vtxs_

edm::Handle<reco::VertexCollection> ParticleNetFeatureEvaluator::vtxs_

private

Definition at line 80 of file ParticleNetFeatureEvaluator.cc.

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ParticleNetFeatureEvaluator()

◆ ~ParticleNetFeatureEvaluator()

Member Function Documentation

◆ beginStream()

◆ endStream()

◆ fillDescriptions()

◆ fillLostTrackFeatures()

◆ fillParticleFeatures()

◆ fillSVFeatures()

◆ produce()

◆ useTrackProperties()

Member Data Documentation

◆ electron_token_

◆ event

◆ flip_ip_sign_

◆ ijet

◆ include_neutrals_

◆ jet_eta

◆ jet_losttrack_charge

◆ jet_losttrack_deta

◆ jet_losttrack_dphi

◆ jet_losttrack_dxy

◆ jet_losttrack_dxysig

◆ jet_losttrack_dz

◆ jet_losttrack_dzsig

◆ jet_losttrack_eta

◆ jet_losttrack_etarel

◆ jet_losttrack_frompv

◆ jet_losttrack_npixhits

◆ jet_losttrack_nstriphits

◆ jet_losttrack_pt_log

◆ jet_losttrack_track_chi2

◆ jet_losttrack_track_qual

◆ jet_losttrack_trackjet_d3d

◆ jet_losttrack_trackjet_d3dsig

◆ jet_losttrack_trackjet_decayL

◆ jet_losttrack_trackjet_dist

◆ jet_mass

◆ jet_pfcand_calofraction

◆ jet_pfcand_charge

◆ jet_pfcand_deta

◆ jet_pfcand_dphi

◆ jet_pfcand_dxy

◆ jet_pfcand_dxysig

◆ jet_pfcand_dz

◆ jet_pfcand_dzsig

◆ jet_pfcand_electron_convProb

◆ jet_pfcand_electron_detaIn

◆ jet_pfcand_electron_dphiIn

◆ jet_pfcand_electron_r9

◆ jet_pfcand_electron_sigIetaIeta

◆ jet_pfcand_electron_sigIphiIphi

◆ jet_pfcand_energy_log

◆ jet_pfcand_eta

◆ jet_pfcand_etarel

◆ jet_pfcand_frompv

◆ jet_pfcand_hcalfraction

◆ jet_pfcand_id

◆ jet_pfcand_muon_chi2

◆ jet_pfcand_muon_id

◆ jet_pfcand_muon_isglobal

◆ jet_pfcand_muon_nstation

◆ jet_pfcand_muon_nvalidhit

◆ jet_pfcand_muon_segcomp

◆ jet_pfcand_nlostinnerhits

◆ jet_pfcand_npixhits

◆ jet_pfcand_nstriphits

◆ jet_pfcand_photon_eVeto

◆ jet_pfcand_photon_r9

◆ jet_pfcand_photon_sigIetaIeta

◆ jet_pfcand_ppara_ratio

◆ jet_pfcand_pperp_ratio