ParticleNetFeatureEvaluator Class Reference

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
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	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 252 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")),
      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 279 of file ParticleNetFeatureEvaluator.cc.

{}

Member Function Documentation

beginStream()

void ParticleNetFeatureEvaluator::beginStream ( edm::StreamID  )

inlineoverrideprivate

Definition at line 42 of file ParticleNetFeatureEvaluator.cc.

{}

endStream()

void ParticleNetFeatureEvaluator::endStream ( )

inlineoverrideprivate

Definition at line 44 of file ParticleNetFeatureEvaluator.cc.

{}

fillDescriptions()

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

static

Definition at line 281 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<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 713 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_2023v12_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) {
    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", std::isnan(ltrack.dz(pv_ass_pos)) ? 0 : ltrack.dz(pv_ass_pos));
    fts.fill("jet_losttrack_dxy", 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()));

    const reco::Track *track = ltrack.bestTrack();
    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", 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 395 of file ParticleNetFeatureEvaluator.cc.

References a, funct::abs(), b, 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_2023v12_cff::full5x5_sigmaIetaIeta, cutBasedMuonId_MuonPOG_V0_cff::globalTrack, mps_fire::i, edm::errors::InvalidReference, CommonMethods::isnan(), metsig::jet, IPTools::jetTrackDistance(), dqm-mbProfile::log, HLT_2023v12_cff::minDR, PDWG_BPHSkim_cff::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_2023v12_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());

    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", std::isnan(cand->dz(pv_ass_pos)) ? 0 : cand->dz(pv_ass_pos));
    fts.fill("jet_pfcand_dxy", 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", 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 665 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());

  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", 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", 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 307 of file ParticleNetFeatureEvaluator.cc.

References funct::abs(), pwdgSkimBPark_cfi::electrons, lowptgsfeleseed::features(), edm::EventSetup::getHandle(), iEvent, metsig::jet, PDWG_EXODelayedJetMET_cff::jets, eostools::move(), PDWG_BPHSkim_cff::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 390 of file ParticleNetFeatureEvaluator.cc.

References HLT_2023v12_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 68 of file ParticleNetFeatureEvaluator.cc.

event

unsigned int ParticleNetFeatureEvaluator::event

private

Definition at line 90 of file ParticleNetFeatureEvaluator.cc.

Referenced by Types.EventID::cppID().

ijet

unsigned int ParticleNetFeatureEvaluator::ijet

private

Definition at line 96 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 93 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_charge

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_charge

private

Definition at line 155 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_deta

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_deta

private

Definition at line 153 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_dphi

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_dphi

private

Definition at line 154 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_dxy

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_dxy

private

Definition at line 160 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_dxysig

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_dxysig

private

Definition at line 162 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_dz

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_dz

private

Definition at line 159 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_dzsig

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_dzsig

private

Definition at line 161 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_eta

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_eta

private

Definition at line 152 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_etarel

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_etarel

private

Definition at line 163 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_frompv

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_frompv

private

Definition at line 156 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_npixhits

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_npixhits

private

Definition at line 168 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_nstriphits

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_nstriphits

private

Definition at line 169 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_pt_log

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_pt_log

private

Definition at line 151 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_track_chi2

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_track_chi2

private

Definition at line 157 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_track_qual

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_track_qual

private

Definition at line 158 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_trackjet_d3d

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_trackjet_d3d

private

Definition at line 164 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_trackjet_d3dsig

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_trackjet_d3dsig

private

Definition at line 165 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_trackjet_decayL

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_trackjet_decayL

private

Definition at line 167 of file ParticleNetFeatureEvaluator.cc.

jet_losttrack_trackjet_dist

std::vector<float> ParticleNetFeatureEvaluator::jet_losttrack_trackjet_dist

private

Definition at line 166 of file ParticleNetFeatureEvaluator.cc.

jet_mass

float ParticleNetFeatureEvaluator::jet_mass

private

Definition at line 95 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_calofraction

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_calofraction

private

Definition at line 121 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_charge

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_charge

private

Definition at line 102 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_deta

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_deta

private

Definition at line 99 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_dphi

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_dphi

private

Definition at line 100 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_dxy

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_dxy

private

Definition at line 109 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_dxysig

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_dxysig

private

Definition at line 110 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_dz

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_dz

private

Definition at line 107 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_dzsig

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_dzsig

private

Definition at line 108 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_electron_convProb

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_convProb

private

Definition at line 135 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_electron_detaIn

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_detaIn

private

Definition at line 130 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_electron_dphiIn

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_dphiIn

private

Definition at line 131 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_electron_r9

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_r9

private

Definition at line 134 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_electron_sigIetaIeta

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_sigIetaIeta

private

Definition at line 132 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_electron_sigIphiIphi

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_electron_sigIphiIphi

private

Definition at line 133 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_energy_log

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_energy_log

private

Definition at line 98 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_eta

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_eta

private

Definition at line 101 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_etarel

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_etarel

private

Definition at line 111 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_frompv

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_frompv

private

Definition at line 103 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_hcalfraction

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_hcalfraction

private

Definition at line 122 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_id

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_id

private

Definition at line 120 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_muon_chi2

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_chi2

private

Definition at line 126 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_muon_id

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_id

private

Definition at line 124 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_muon_isglobal

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_isglobal

private

Definition at line 125 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_muon_nstation

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_nstation

private

Definition at line 129 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_muon_nvalidhit

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_nvalidhit

private

Definition at line 128 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_muon_segcomp

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_muon_segcomp

private

Definition at line 127 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_nlostinnerhits

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_nlostinnerhits

private

Definition at line 104 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_npixhits

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_npixhits

private

Definition at line 117 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_nstriphits

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_nstriphits

private

Definition at line 118 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_photon_eVeto

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_photon_eVeto

private

Definition at line 138 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_photon_r9

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_photon_r9

private

Definition at line 137 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_photon_sigIetaIeta

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_photon_sigIetaIeta

private

Definition at line 136 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_ppara_ratio

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_ppara_ratio

private

Definition at line 113 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_pperp_ratio

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_pperp_ratio

private

Definition at line 112 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_pt_log

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_pt_log

private

Definition at line 97 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_puppiw

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_puppiw

private

Definition at line 123 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_tau_signal

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_tau_signal

private

Definition at line 139 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_track_chi2

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_track_chi2

private

Definition at line 105 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_track_qual

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_track_qual

private

Definition at line 106 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_trackjet_d3d

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_trackjet_d3d

private

Definition at line 114 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_trackjet_d3dsig

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_trackjet_d3dsig

private

Definition at line 115 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_trackjet_decayL

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_trackjet_decayL

private

Definition at line 119 of file ParticleNetFeatureEvaluator.cc.

jet_pfcand_trackjet_dist

std::vector<float> ParticleNetFeatureEvaluator::jet_pfcand_trackjet_dist

private

Definition at line 116 of file ParticleNetFeatureEvaluator.cc.

jet_phi

float ParticleNetFeatureEvaluator::jet_phi

private

Definition at line 94 of file ParticleNetFeatureEvaluator.cc.

jet_pt

float ParticleNetFeatureEvaluator::jet_pt

private

Definition at line 91 of file ParticleNetFeatureEvaluator.cc.

jet_pt_raw

float ParticleNetFeatureEvaluator::jet_pt_raw

private

Definition at line 92 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 146 of file ParticleNetFeatureEvaluator.cc.

jet_sv_d3d

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_d3d

private

Definition at line 149 of file ParticleNetFeatureEvaluator.cc.

jet_sv_d3dsig

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_d3dsig

private

Definition at line 150 of file ParticleNetFeatureEvaluator.cc.

jet_sv_deta

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_deta

private

Definition at line 142 of file ParticleNetFeatureEvaluator.cc.

jet_sv_dphi

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_dphi

private

Definition at line 143 of file ParticleNetFeatureEvaluator.cc.

jet_sv_dxy

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_dxy

private

Definition at line 147 of file ParticleNetFeatureEvaluator.cc.

jet_sv_dxysig

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_dxysig

private

Definition at line 148 of file ParticleNetFeatureEvaluator.cc.

jet_sv_eta

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_eta

private

Definition at line 144 of file ParticleNetFeatureEvaluator.cc.

jet_sv_mass

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_mass

private

Definition at line 141 of file ParticleNetFeatureEvaluator.cc.

jet_sv_ntrack

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_ntrack

private

Definition at line 145 of file ParticleNetFeatureEvaluator.cc.

jet_sv_pt_log

std::vector<float> ParticleNetFeatureEvaluator::jet_sv_pt_log

private

Definition at line 140 of file ParticleNetFeatureEvaluator.cc.

jet_token_

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

private

Definition at line 71 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 86 of file ParticleNetFeatureEvaluator.cc.

losttrack_token_

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

private

Definition at line 72 of file ParticleNetFeatureEvaluator.cc.

losttracks_

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

private

Definition at line 81 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.

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 67 of file ParticleNetFeatureEvaluator.cc.

particle_features_

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

staticprivate

Definition at line 84 of file ParticleNetFeatureEvaluator.cc.

pfcand_token_

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

private

Definition at line 75 of file ParticleNetFeatureEvaluator.cc.

pfcands_

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

private

Definition at line 80 of file ParticleNetFeatureEvaluator.cc.

photon_token_

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

private

Definition at line 69 of file ParticleNetFeatureEvaluator.cc.

pv_

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

private

Definition at line 87 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 85 of file ParticleNetFeatureEvaluator.cc.

sv_token_

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

private

Definition at line 74 of file ParticleNetFeatureEvaluator.cc.

svs_

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

private

Definition at line 79 of file ParticleNetFeatureEvaluator.cc.

tau_token_

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

private

Definition at line 70 of file ParticleNetFeatureEvaluator.cc.

track_builder_

edm::ESHandle<TransientTrackBuilder> ParticleNetFeatureEvaluator::track_builder_

private

Definition at line 82 of file ParticleNetFeatureEvaluator.cc.

track_builder_token_

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

private

Definition at line 76 of file ParticleNetFeatureEvaluator.cc.

tree

TTree* ParticleNetFeatureEvaluator::tree

private

Definition at line 89 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 73 of file ParticleNetFeatureEvaluator.cc.

vtxs_

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

private

Definition at line 78 of file ParticleNetFeatureEvaluator.cc.