From 17471e84c6b53ca2d2bdb4288dafd88601ec360b Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Fri, 10 Feb 2023 10:27:36 +0100 Subject: [PATCH 01/24] add ParticleNetFromMiniAOD --- .../plugins/ParticleNetFeatureEvaluator.cc | 712 ++++++++++++++++++ .../python/pfParticleNetFromMiniAODAK4_cff.py | 82 ++ .../python/pfParticleNetFromMiniAOD_cff.py | 31 + 3 files changed, 825 insertions(+) create mode 100644 RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc create mode 100644 RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py create mode 100644 RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAOD_cff.py diff --git a/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc b/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc new file mode 100644 index 0000000000000..c4217bf3ff0aa --- /dev/null +++ b/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc @@ -0,0 +1,712 @@ +#include +#include + +#include "CommonTools/UtilAlgos/interface/TFileService.h" + +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/StreamID.h" +#include "FWCore/Utilities/interface/ESGetToken.h" + +#include "DataFormats/Candidate/interface/Candidate.h" +#include "DataFormats/PatCandidates/interface/Jet.h" +#include "DataFormats/PatCandidates/interface/Muon.h" +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/PatCandidates/interface/Photon.h" +#include "DataFormats/PatCandidates/interface/Tau.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "RecoBTag/FeatureTools/interface/TrackInfoBuilder.h" +#include "RecoBTag/FeatureTools/interface/deep_helpers.h" +#include "RecoBTag/FeatureTools/interface/sorting_modules.h" +#include "TrackingTools/Records/interface/TransientTrackRecord.h" + +#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/BTauReco/interface/DeepBoostedJetTagInfo.h" + +using namespace btagbtvdeep; + +class ParticleNetFeatureEvaluator : public edm::stream::EDProducer<> { +public: + explicit ParticleNetFeatureEvaluator(const edm::ParameterSet &); + ~ParticleNetFeatureEvaluator() override; + + static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); + +private: + + void beginStream(edm::StreamID) override {} + void produce(edm::Event &, const edm::EventSetup &) override; + void endStream() override {} + void fillParticleFeatures(DeepBoostedJetFeatures & fts, + const reco::Jet & jet, + const std::vector & tau_pfcandidates, + const pat::MuonCollection & muons, + const pat::ElectronCollection & electrons, + const pat::PhotonCollection & photons + ); + void fillSVFeatures(DeepBoostedJetFeatures & fts, + const reco::Jet & jet); + void fillLostTrackFeatures(DeepBoostedJetFeatures & fts, + const reco::Jet & jet); + bool useTrackProperties(const pat::PackedCandidate* cand); + + const double jet_radius_; + const double min_jet_pt_; + const double max_jet_eta_; + const double min_jet_eta_; + const double min_pt_for_track_properties_; + const double min_pt_for_pfcandidates_; + const double min_pt_for_losttrack_; + const double max_dr_for_losttrack_; + const double min_pt_for_taus_; + const double max_eta_for_taus_; + const bool use_puppiP4_; + const double min_puppi_wgt_; + const bool include_neutrals_; + + edm::EDGetTokenT muon_token_; + edm::EDGetTokenT electron_token_; + edm::EDGetTokenT photon_token_; + edm::EDGetTokenT tau_token_; + edm::EDGetTokenT > jet_token_; + edm::EDGetTokenT losttrack_token_; + edm::EDGetTokenT vtx_token_; + edm::EDGetTokenT sv_token_; + edm::EDGetTokenT > pfcand_token_; + edm::ESGetToken track_builder_token_; + + edm::Handle vtxs_; + edm::Handle svs_; + edm::Handle > pfcands_; + edm::Handle losttracks_; + edm::ESHandle track_builder_; + + const static std::vector particle_features_; + const static std::vector sv_features_; + const static std::vector losttrack_features_; + const reco::Vertex *pv_ = nullptr; + + TTree* tree; + unsigned int event; + float jet_pt; + float jet_pt_raw; + float jet_eta; + float jet_phi; + float jet_mass; + unsigned int ijet; + std::vector jet_pfcand_pt_log; + std::vector jet_pfcand_energy_log; + std::vector jet_pfcand_deta; + std::vector jet_pfcand_dphi; + std::vector jet_pfcand_eta ; + std::vector jet_pfcand_charge; + std::vector jet_pfcand_frompv; + std::vector jet_pfcand_nlostinnerhits; + std::vector jet_pfcand_track_chi2; + std::vector jet_pfcand_track_qual; + std::vector jet_pfcand_dz; + std::vector jet_pfcand_dzsig; + std::vector jet_pfcand_dxy; + std::vector jet_pfcand_dxysig; + std::vector jet_pfcand_etarel; + std::vector jet_pfcand_pperp_ratio; + std::vector jet_pfcand_ppara_ratio; + std::vector jet_pfcand_trackjet_d3d; + std::vector jet_pfcand_trackjet_d3dsig; + std::vector jet_pfcand_trackjet_dist; + std::vector jet_pfcand_npixhits; + std::vector jet_pfcand_nstriphits; + std::vector jet_pfcand_trackjet_decayL; + std::vector jet_pfcand_id; + std::vector jet_pfcand_calofraction; + std::vector jet_pfcand_hcalfraction; + std::vector jet_pfcand_puppiw; + std::vector jet_pfcand_muon_id; + std::vector jet_pfcand_muon_isglobal; + std::vector jet_pfcand_muon_chi2; + std::vector jet_pfcand_muon_segcomp; + std::vector jet_pfcand_muon_nvalidhit; + std::vector jet_pfcand_muon_nstation; + std::vector jet_pfcand_electron_detaIn; + std::vector jet_pfcand_electron_dphiIn; + std::vector jet_pfcand_electron_sigIetaIeta; + std::vector jet_pfcand_electron_sigIphiIphi; + std::vector jet_pfcand_electron_r9; + std::vector jet_pfcand_electron_convProb; + std::vector jet_pfcand_photon_sigIetaIeta; + std::vector jet_pfcand_photon_r9; + std::vector jet_pfcand_photon_eVeto; + std::vector jet_pfcand_tau_signal; + std::vector jet_sv_pt_log; + std::vector jet_sv_mass; + std::vector jet_sv_deta; + std::vector jet_sv_dphi; + std::vector jet_sv_eta; + std::vector jet_sv_ntrack; + std::vector jet_sv_chi2; + std::vector jet_sv_dxy; + std::vector jet_sv_dxysig; + std::vector jet_sv_d3d; + std::vector jet_sv_d3dsig; + std::vector jet_losttrack_pt_log; + std::vector jet_losttrack_eta; + std::vector jet_losttrack_deta; + std::vector jet_losttrack_dphi; + std::vector jet_losttrack_charge; + std::vector jet_losttrack_frompv; + std::vector jet_losttrack_track_chi2; + std::vector jet_losttrack_track_qual; + std::vector jet_losttrack_dz; + std::vector jet_losttrack_dxy; + std::vector jet_losttrack_dzsig; + std::vector jet_losttrack_dxysig; + std::vector jet_losttrack_etarel; + std::vector jet_losttrack_trackjet_d3d; + std::vector jet_losttrack_trackjet_d3dsig; + std::vector jet_losttrack_trackjet_dist; + std::vector jet_losttrack_trackjet_decayL; + std::vector jet_losttrack_npixhits; + std::vector jet_losttrack_nstriphits; + +}; + +const std::vector ParticleNetFeatureEvaluator::particle_features_{ "jet_pfcand_pt_log", "jet_pfcand_energy_log", "jet_pfcand_deta", "jet_pfcand_dphi", "jet_pfcand_eta", "jet_pfcand_charge", "jet_pfcand_frompv", "jet_pfcand_nlostinnerhits", "jet_pfcand_track_chi2", "jet_pfcand_track_qual", "jet_pfcand_dz", "jet_pfcand_dzsig", "jet_pfcand_dxy", "jet_pfcand_dxysig", "jet_pfcand_etarel", "jet_pfcand_pperp_ratio", "jet_pfcand_ppara_ratio", "jet_pfcand_trackjet_d3d", "jet_pfcand_trackjet_d3dsig", "jet_pfcand_trackjet_dist", "jet_pfcand_nhits", "jet_pfcand_npixhits", "jet_pfcand_nstriphits", "jet_pfcand_trackjet_decayL", "jet_pfcand_id", "jet_pfcand_calofraction", "jet_pfcand_hcalfraction", "jet_pfcand_puppiw", "jet_pfcand_muon_id", "jet_pfcand_muon_isglobal", "jet_pfcand_muon_segcomp", "jet_pfcand_muon_chi2", "jet_pfcand_muon_nvalidhit", "jet_pfcand_muon_nstation", "jet_pfcand_electron_detaIn", "jet_pfcand_electron_dphiIn", "jet_pfcand_electron_sigIetaIeta", "jet_pfcand_electron_sigIphiIphi", "jet_pfcand_electron_r9", "jet_pfcand_electron_convProb", "jet_pfcand_photon_sigIetaIeta", "jet_pfcand_photon_r9", "jet_pfcand_photon_eVeto", "jet_pfcand_tau_signal", "pfcand_mask"}; + +const std::vector ParticleNetFeatureEvaluator::sv_features_{"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"}; + +const std::vector ParticleNetFeatureEvaluator::losttrack_features_{"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"}; + +ParticleNetFeatureEvaluator::ParticleNetFeatureEvaluator(const edm::ParameterSet &iConfig): + jet_radius_(iConfig.getParameter("jet_radius")), + min_jet_pt_(iConfig.getParameter("min_jet_pt")), + max_jet_eta_(iConfig.getParameter("max_jet_eta")), + min_jet_eta_(iConfig.getParameter("min_jet_eta")), + min_pt_for_track_properties_(iConfig.getParameter("min_pt_for_track_properties")), + min_pt_for_pfcandidates_(iConfig.getParameter("min_pt_for_pfcandidates")), + min_pt_for_losttrack_(iConfig.getParameter("min_pt_for_losttrack")), + max_dr_for_losttrack_(iConfig.getParameter("max_dr_for_losttrack")), + min_pt_for_taus_(iConfig.getParameter("min_pt_for_taus")), + max_eta_for_taus_(iConfig.getParameter("max_eta_for_taus")), + use_puppiP4_(iConfig.getParameter("use_puppiP4")), + min_puppi_wgt_(iConfig.getParameter("min_puppi_wgt")), + include_neutrals_(iConfig.getParameter("include_neutrals")), + muon_token_(consumes(iConfig.getParameter("muons"))), + electron_token_(consumes(iConfig.getParameter("electrons"))), + photon_token_(consumes(iConfig.getParameter("photons"))), + tau_token_(consumes(iConfig.getParameter("taus"))), + jet_token_(consumes >(iConfig.getParameter("jets"))), + losttrack_token_(consumes(iConfig.getParameter("losttracks"))), + vtx_token_(consumes(iConfig.getParameter("vertices"))), + sv_token_(consumes(iConfig.getParameter("secondary_vertices"))), + pfcand_token_(consumes >(iConfig.getParameter("pf_candidates"))), + track_builder_token_(esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))) { + + produces>(); + +} + +ParticleNetFeatureEvaluator::~ParticleNetFeatureEvaluator() {} + +void ParticleNetFeatureEvaluator::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + // pfDeepBoostedJetTagInfos + edm::ParameterSetDescription desc; + desc.add("jet_radius", 0.8); + desc.add("min_jet_pt", 150); + desc.add("max_jet_eta", 99); + desc.add("min_jet_eta", 0.0); + desc.add("min_pt_for_track_properties", -1); + desc.add("min_pt_for_pfcandidates", -1); + desc.add("min_pt_for_losttrack", 1); + desc.add("max_dr_for_losttrack", 0.4); + desc.add("min_pt_for_taus",20.); + desc.add("max_eta_for_taus",2.5); + desc.add("use_puppiP4", false); + desc.add("include_neutrals", true); + desc.add("min_puppi_wgt", -1.); + desc.add("vertices", edm::InputTag("offlineSlimmedPrimaryVertices")); + desc.add("secondary_vertices", edm::InputTag("slimmedSecondaryVertices")); + desc.add("pf_candidates", edm::InputTag("packedPFCandidates")); + desc.add("losttracks", edm::InputTag("lostTracks")); + desc.add("jets", edm::InputTag("slimmedJetsAK8")); + desc.add("muons", edm::InputTag("slimmedMuons")); + desc.add("taus", edm::InputTag("slimmedTaus")); + desc.add("electrons", edm::InputTag("slimmedElectrons")); + desc.add("photons", edm::InputTag("slimmedPhotons")); + descriptions.add("ParticleNetFeatureEvaluator", desc); +} + +void ParticleNetFeatureEvaluator::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { + + // output collection + auto output_tag_infos = std::make_unique>(); + // 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 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 (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 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(&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)); +} + +bool ParticleNetFeatureEvaluator::useTrackProperties(const pat::PackedCandidate* cand) { + const auto *track = cand->bestTrack(); + return track != nullptr and track->pt() > min_pt_for_track_properties_; +}; + +void ParticleNetFeatureEvaluator::fillParticleFeatures(DeepBoostedJetFeatures & fts, + const reco::Jet & jet, + const std::vector & tau_pfcandidates, + const pat::MuonCollection & muons, + const pat::ElectronCollection & electrons, + const pat::PhotonCollection & photons + ) { + // 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 daughters; + for (const auto &dau : jet.daughterPtrVector()) { + // remove particles w/ extremely low puppi weights + const pat::PackedCandidate* cand = dynamic_cast(&(*dau)); + if(not cand) + throw edm::Exception(edm::errors::InvalidReference) + << "Cannot convert to either pat::PackedCandidate"; + if(cand->puppiWeight() < min_puppi_wgt_) continue; + // 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 Puppi-weighted pt + if (use_puppiP4_) + std::sort(daughters.begin(), daughters.end(), [&](const pat::PackedCandidate* a, const pat::PackedCandidate* b) { + return a->puppiWeight() * a->pt() > b->puppiWeight() * b->pt(); + }); + // sort by original pt (not Puppi-weighted) + else + 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 = use_puppiP4_ ? cand->puppiWeight() * cand->p4() : cand->p4(); + auto candP3 = use_puppiP4_ ? cand->puppiWeight() * cand->momentum() : 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 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); + + } +} + +void ParticleNetFeatureEvaluator::fillSVFeatures(DeepBoostedJetFeatures &fts, + const reco::Jet & jet) { + + // secondary vertexes matching jet + std::vector 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())); + + } +} + +void ParticleNetFeatureEvaluator::fillLostTrackFeatures(DeepBoostedJetFeatures &fts, + const reco::Jet & jet + ) { + + // 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 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); + + } +} + +// define this as a plug-in +DEFINE_FWK_MODULE(ParticleNetFeatureEvaluator); + diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py new file mode 100644 index 0000000000000..f185d5846b648 --- /dev/null +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py @@ -0,0 +1,82 @@ +import FWCore.ParameterSet.Config as cms + +from RecoBTag.FeatureTools.pfDeepBoostedJetTagInfos_cfi import pfDeepBoostedJetTagInfos +from RecoBTag.ONNXRuntime.boostedJetONNXJetTagsProducer_cfi import boostedJetONNXJetTagsProducer +#from RecoBTag.ONNXRuntime.pfParticleNetAK4DiscriminatorsJetTags_cfi import pfParticleNetAK4DiscriminatorsJetTags +from RecoBTag.FeatureTools.ParticleNetFeatureEvaluator_cfi import ParticleNetFeatureEvaluator + +pfParticleNetFromMiniAODAK4CHSCentralTagInfos = ParticleNetFeatureEvaluator.clone( + jets = "slimmedJets", + jet_radius = 0.4, + min_jet_pt = 15, + min_jet_eta = 0., + max_jet_eta = 2.5, +) + +pfParticleNetFromMiniAODAK4CHSForwardTagInfos = ParticleNetFeatureEvaluator.clone( + jets = "slimmedJets", + jet_radius = 0.4, + min_jet_pt = 15, + min_jet_eta = 2.5, + max_jet_eta = 4.7, +) + +pfParticleNetFromMiniAODAK4PuppiCentralTagInfos = ParticleNetFeatureEvaluator.clone( + jets = "slimmedJetsPuppi", + jet_radius = 0.4, + min_jet_pt = 15, + min_jet_eta = 0., + max_jet_eta = 2.5, +) + +pfParticleNetFromMiniAODAK4PuppiForwardTagInfos = ParticleNetFeatureEvaluator.clone( + jets = "slimmedJetsPuppi", + jet_radius = 0.4, + min_jet_pt = 15, + min_jet_eta = 2.5, + max_jet_eta = 4.7, +) + + +pfParticleNetFromMiniAODAK4CHSCentralJetTags = boostedJetONNXJetTagsProducer.clone( + src = 'pfParticleNetFromMiniAODAK4CHSCentralTagInfos', + preprocess_json = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/CHS/Central/preprocess.json', + model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/CHS/Central/modelfile/model.onnx', + flav_names = ['probmu','probele','probtaup1h0p','probtaup1h1p','probtaup1h2p','probtaup3h0p','probtaup3h1p','probtaum1h0p','probtaum1h1p','probtaum1h2p','probtaum3h0p','probtaum3h1p','probb','probc','probuds','probg','ptcorr','ptreshigh','ptreslow','ptnu'], +) + +pfParticleNetFromMiniAODAK4CHSForwardJetTags = boostedJetONNXJetTagsProducer.clone( + src = 'pfParticleNetFromMiniAODAK4CHSForwardTagInfos', + preprocess_json = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/CHS/Forward/preprocess.json', + model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/CHS/Forward/modelfile/model.onnx', + flav_names = ['probq','probg','ptcorr','ptreshigh','ptreslow','ptnu'], +) + +pfParticleNetFromMiniAODAK4PuppiCentralJetTags = boostedJetONNXJetTagsProducer.clone( + src = 'pfParticleNetFromMiniAODAK4PuppiCentralTagInfos', + preprocess_json = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/PUPPI/Central/preprocess.json', + model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/PUPPI/Central/modelfile/model.onnx', + flav_names = ['probmu','probele','probtaup1h0p','probtaup1h1p','probtaup1h2p','probtaup3h0p','probtaup3h1p','probtaum1h0p','probtaum1h1p','probtaum1h2p','probtaum3h0p','probtaum3h1p','probb','probc','probuds','probg','ptcorr','ptreshigh','ptreslow','ptnu'], +) + +pfParticleNetFromMiniAODAK4PuppiForwardJetTags = boostedJetONNXJetTagsProducer.clone( + src = 'pfParticleNetFromMiniAODAK4PuppiForwardTagInfos', + preprocess_json = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/PUPPI/Forward/preprocess.json', + model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/PUPPI/Forward/modelfile/model.onnx', + flav_names = ['probq','probg','ptcorr','ptreshigh','ptreslow','ptnu'], +) + +pfParticleNetFromMiniAODAK4CHSTask = cms.Task( pfParticleNetFromMiniAODAK4CHSCentralTagInfos, pfParticleNetFromMiniAODAK4CHSForwardTagInfos, pfParticleNetFromMiniAODAK4CHSCentralJetTags, pfParticleNetFromMiniAODAK4CHSForwardJetTags) +pfParticleNetFromMiniAODAK4PuppiTask = cms.Task( pfParticleNetFromMiniAODAK4PuppiCentralTagInfos, pfParticleNetFromMiniAODAK4PuppiForwardTagInfos, pfParticleNetFromMiniAODAK4PuppiCentralJetTags, pfParticleNetFromMiniAODAK4PuppiForwardJetTags) + +# declare all the discriminators +# probs +_pfParticleNetFromMiniAODAK4CHSCentralJetTagsProbs = ['pfParticleNetFromMiniAODAK4CHSCentralJetTags:' + flav_name + for flav_name in pfParticleNetFromMiniAODAK4CHSCentralJetTags.flav_names] +_pfParticleNetFromMiniAODAK4CHSForwardJetTagsProbs = ['pfParticleNetFromMiniAODAK4CHSForwardJetTags:' + flav_name + for flav_name in pfParticleNetFromMiniAODAK4CHSForwardJetTags.flav_names] +_pfParticleNetFromMiniAODAK4PuppiCentralJetTagsProbs = ['pfParticleNetFromMiniAODAK4PuppiCentralJetTags:' + flav_name + for flav_name in pfParticleNetFromMiniAODAK4PuppiCentralJetTags.flav_names] +_pfParticleNetFromMiniAODAK4PuppiForwardJetTagsProbs = ['pfParticleNetFromMiniAODAK4PuppiForwardJetTags:' + flav_name + for flav_name in pfParticleNetFromMiniAODAK4PuppiForwardJetTags.flav_names] + diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAOD_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAOD_cff.py new file mode 100644 index 0000000000000..b16b438370b4d --- /dev/null +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAOD_cff.py @@ -0,0 +1,31 @@ +import FWCore.ParameterSet.Config as cms + +from RecoBTag.FeatureTools.pfDeepBoostedJetTagInfos_cfi import pfDeepBoostedJetTagInfos +from RecoBTag.ONNXRuntime.boostedJetONNXJetTagsProducer_cfi import boostedJetONNXJetTagsProducer +#from RecoBTag.ONNXRuntime.pfParticleNetAK4DiscriminatorsJetTags_cfi import pfParticleNetAK4DiscriminatorsJetTags +from RecoBTag.FeatureTools.ParticleNetFeatureEvaluator_cfi import ParticleNetFeatureEvaluator + +pfParticleNetFromMiniAODAK8TagInfos = ParticleNetFeatureEvaluator.clone( + jets = "slimmedJetsAK8", + jet_radius = 0.8, + min_jet_pt = 200, + min_jet_eta = 0., + max_jet_eta = 2.5, + min_pt_for_track_properties = 0.95, +) + + +pfParticleNetFromMiniAODAK8JetTags = boostedJetONNXJetTagsProducer.clone( + src = 'pfParticleNetFromMiniAODAK8TagInfos', + preprocess_json = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK8/preprocess.json', + model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK8/modelfile/model.onnx', + flav_names = ['probHtt','probHtm','probHte','probHbb', 'probHcc', 'probHqq', 'probHgg','probQCD2hf','probQCD1hf','probQCD0hf','masscorr'], +) + + +pfParticleNetFromMiniAODAK8Task = cms.Task( pfParticleNetFromMiniAODAK8TagInfos, pfParticleNetFromMiniAODAK8JetTags) + +# declare all the discriminators +# probs +_pfParticleNetFromMiniAODAK8JetTagsProbs = ['pfParticleNetFromMiniAODAK8JetTags:' + flav_name + for flav_name in pfParticleNetFromMiniAODAK8JetTags.flav_names] From 30c3043f16335d562493946d1f04316988e39a0e Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Fri, 10 Feb 2023 14:40:25 +0100 Subject: [PATCH 02/24] a few fixes after runtime testing --- .../ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py | 8 ++++---- ...mMiniAOD_cff.py => pfParticleNetFromMiniAODAK8_cff.py} | 5 ++--- 2 files changed, 6 insertions(+), 7 deletions(-) rename RecoBTag/ONNXRuntime/python/{pfParticleNetFromMiniAOD_cff.py => pfParticleNetFromMiniAODAK8_cff.py} (94%) diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py index f185d5846b648..20eb27475db6b 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py @@ -41,28 +41,28 @@ pfParticleNetFromMiniAODAK4CHSCentralJetTags = boostedJetONNXJetTagsProducer.clone( src = 'pfParticleNetFromMiniAODAK4CHSCentralTagInfos', preprocess_json = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/CHS/Central/preprocess.json', - model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/CHS/Central/modelfile/model.onnx', + model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/CHS/Central/particle-net.onnx', flav_names = ['probmu','probele','probtaup1h0p','probtaup1h1p','probtaup1h2p','probtaup3h0p','probtaup3h1p','probtaum1h0p','probtaum1h1p','probtaum1h2p','probtaum3h0p','probtaum3h1p','probb','probc','probuds','probg','ptcorr','ptreshigh','ptreslow','ptnu'], ) pfParticleNetFromMiniAODAK4CHSForwardJetTags = boostedJetONNXJetTagsProducer.clone( src = 'pfParticleNetFromMiniAODAK4CHSForwardTagInfos', preprocess_json = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/CHS/Forward/preprocess.json', - model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/CHS/Forward/modelfile/model.onnx', + model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/CHS/Forward/particle-net.onnx', flav_names = ['probq','probg','ptcorr','ptreshigh','ptreslow','ptnu'], ) pfParticleNetFromMiniAODAK4PuppiCentralJetTags = boostedJetONNXJetTagsProducer.clone( src = 'pfParticleNetFromMiniAODAK4PuppiCentralTagInfos', preprocess_json = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/PUPPI/Central/preprocess.json', - model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/PUPPI/Central/modelfile/model.onnx', + model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/PUPPI/Central/particle-net.onnx', flav_names = ['probmu','probele','probtaup1h0p','probtaup1h1p','probtaup1h2p','probtaup3h0p','probtaup3h1p','probtaum1h0p','probtaum1h1p','probtaum1h2p','probtaum3h0p','probtaum3h1p','probb','probc','probuds','probg','ptcorr','ptreshigh','ptreslow','ptnu'], ) pfParticleNetFromMiniAODAK4PuppiForwardJetTags = boostedJetONNXJetTagsProducer.clone( src = 'pfParticleNetFromMiniAODAK4PuppiForwardTagInfos', preprocess_json = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/PUPPI/Forward/preprocess.json', - model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/PUPPI/Forward/modelfile/model.onnx', + model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK4/PUPPI/Forward/particle-net.onnx', flav_names = ['probq','probg','ptcorr','ptreshigh','ptreslow','ptnu'], ) diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAOD_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py similarity index 94% rename from RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAOD_cff.py rename to RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py index b16b438370b4d..2a7708eccc615 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAOD_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py @@ -8,17 +8,16 @@ pfParticleNetFromMiniAODAK8TagInfos = ParticleNetFeatureEvaluator.clone( jets = "slimmedJetsAK8", jet_radius = 0.8, - min_jet_pt = 200, + min_jet_pt = 180, min_jet_eta = 0., max_jet_eta = 2.5, - min_pt_for_track_properties = 0.95, ) pfParticleNetFromMiniAODAK8JetTags = boostedJetONNXJetTagsProducer.clone( src = 'pfParticleNetFromMiniAODAK8TagInfos', preprocess_json = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK8/preprocess.json', - model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK8/modelfile/model.onnx', + model_path = 'RecoBTag/Combined/data/ParticleNetFromMiniAODAK8/particle-net.onnx', flav_names = ['probHtt','probHtm','probHte','probHbb', 'probHcc', 'probHqq', 'probHgg','probQCD2hf','probQCD1hf','probQCD0hf','masscorr'], ) From 419dc21225a9ee70db9f8363b53152cf1e0b8282 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Fri, 10 Feb 2023 14:42:21 +0100 Subject: [PATCH 03/24] remove commented line --- RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py | 1 - RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py | 1 - 2 files changed, 2 deletions(-) diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py index 20eb27475db6b..b3ea9b90caff9 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py @@ -2,7 +2,6 @@ from RecoBTag.FeatureTools.pfDeepBoostedJetTagInfos_cfi import pfDeepBoostedJetTagInfos from RecoBTag.ONNXRuntime.boostedJetONNXJetTagsProducer_cfi import boostedJetONNXJetTagsProducer -#from RecoBTag.ONNXRuntime.pfParticleNetAK4DiscriminatorsJetTags_cfi import pfParticleNetAK4DiscriminatorsJetTags from RecoBTag.FeatureTools.ParticleNetFeatureEvaluator_cfi import ParticleNetFeatureEvaluator pfParticleNetFromMiniAODAK4CHSCentralTagInfos = ParticleNetFeatureEvaluator.clone( diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py index 2a7708eccc615..045c6962c5534 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py @@ -2,7 +2,6 @@ from RecoBTag.FeatureTools.pfDeepBoostedJetTagInfos_cfi import pfDeepBoostedJetTagInfos from RecoBTag.ONNXRuntime.boostedJetONNXJetTagsProducer_cfi import boostedJetONNXJetTagsProducer -#from RecoBTag.ONNXRuntime.pfParticleNetAK4DiscriminatorsJetTags_cfi import pfParticleNetAK4DiscriminatorsJetTags from RecoBTag.FeatureTools.ParticleNetFeatureEvaluator_cfi import ParticleNetFeatureEvaluator pfParticleNetFromMiniAODAK8TagInfos = ParticleNetFeatureEvaluator.clone( From 5c0afbdbc8febb24029ad4541407b04209dc8e9c Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Tue, 14 Feb 2023 16:03:23 +0100 Subject: [PATCH 04/24] reformat new code --- .../plugins/ParticleNetFeatureEvaluator.cc | 685 ++++++++++-------- 1 file changed, 390 insertions(+), 295 deletions(-) diff --git a/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc b/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc index c4217bf3ff0aa..d6163b2b2592b 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc @@ -39,22 +39,18 @@ class ParticleNetFeatureEvaluator : public edm::stream::EDProducer<> { static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); private: - void beginStream(edm::StreamID) override {} void produce(edm::Event &, const edm::EventSetup &) override; void endStream() override {} - void fillParticleFeatures(DeepBoostedJetFeatures & fts, - const reco::Jet & jet, - const std::vector & tau_pfcandidates, - const pat::MuonCollection & muons, - const pat::ElectronCollection & electrons, - const pat::PhotonCollection & photons - ); - void fillSVFeatures(DeepBoostedJetFeatures & fts, - const reco::Jet & jet); - void fillLostTrackFeatures(DeepBoostedJetFeatures & fts, - const reco::Jet & jet); - bool useTrackProperties(const pat::PackedCandidate* cand); + void fillParticleFeatures(DeepBoostedJetFeatures &fts, + const reco::Jet &jet, + const std::vector &tau_pfcandidates, + const pat::MuonCollection &muons, + const pat::ElectronCollection &electrons, + const pat::PhotonCollection &photons); + void fillSVFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet); + void fillLostTrackFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet); + bool useTrackProperties(const pat::PackedCandidate *cand); const double jet_radius_; const double min_jet_pt_; @@ -66,25 +62,25 @@ class ParticleNetFeatureEvaluator : public edm::stream::EDProducer<> { const double max_dr_for_losttrack_; const double min_pt_for_taus_; const double max_eta_for_taus_; - const bool use_puppiP4_; + const bool use_puppiP4_; const double min_puppi_wgt_; - const bool include_neutrals_; - - edm::EDGetTokenT muon_token_; - edm::EDGetTokenT electron_token_; - edm::EDGetTokenT photon_token_; - edm::EDGetTokenT tau_token_; - edm::EDGetTokenT > jet_token_; - edm::EDGetTokenT losttrack_token_; + const bool include_neutrals_; + + edm::EDGetTokenT muon_token_; + edm::EDGetTokenT electron_token_; + edm::EDGetTokenT photon_token_; + edm::EDGetTokenT tau_token_; + edm::EDGetTokenT> jet_token_; + edm::EDGetTokenT losttrack_token_; edm::EDGetTokenT vtx_token_; edm::EDGetTokenT sv_token_; - edm::EDGetTokenT > pfcand_token_; + edm::EDGetTokenT> pfcand_token_; edm::ESGetToken track_builder_token_; - + edm::Handle vtxs_; edm::Handle svs_; - edm::Handle > pfcands_; - edm::Handle losttracks_; + edm::Handle> pfcands_; + edm::Handle losttracks_; edm::ESHandle track_builder_; const static std::vector particle_features_; @@ -92,7 +88,7 @@ class ParticleNetFeatureEvaluator : public edm::stream::EDProducer<> { const static std::vector losttrack_features_; const reco::Vertex *pv_ = nullptr; - TTree* tree; + TTree *tree; unsigned int event; float jet_pt; float jet_pt_raw; @@ -104,7 +100,7 @@ class ParticleNetFeatureEvaluator : public edm::stream::EDProducer<> { std::vector jet_pfcand_energy_log; std::vector jet_pfcand_deta; std::vector jet_pfcand_dphi; - std::vector jet_pfcand_eta ; + std::vector jet_pfcand_eta; std::vector jet_pfcand_charge; std::vector jet_pfcand_frompv; std::vector jet_pfcand_nlostinnerhits; @@ -172,43 +168,116 @@ class ParticleNetFeatureEvaluator : public edm::stream::EDProducer<> { std::vector jet_losttrack_trackjet_dist; std::vector jet_losttrack_trackjet_decayL; std::vector jet_losttrack_npixhits; - std::vector jet_losttrack_nstriphits; - + std::vector jet_losttrack_nstriphits; }; -const std::vector ParticleNetFeatureEvaluator::particle_features_{ "jet_pfcand_pt_log", "jet_pfcand_energy_log", "jet_pfcand_deta", "jet_pfcand_dphi", "jet_pfcand_eta", "jet_pfcand_charge", "jet_pfcand_frompv", "jet_pfcand_nlostinnerhits", "jet_pfcand_track_chi2", "jet_pfcand_track_qual", "jet_pfcand_dz", "jet_pfcand_dzsig", "jet_pfcand_dxy", "jet_pfcand_dxysig", "jet_pfcand_etarel", "jet_pfcand_pperp_ratio", "jet_pfcand_ppara_ratio", "jet_pfcand_trackjet_d3d", "jet_pfcand_trackjet_d3dsig", "jet_pfcand_trackjet_dist", "jet_pfcand_nhits", "jet_pfcand_npixhits", "jet_pfcand_nstriphits", "jet_pfcand_trackjet_decayL", "jet_pfcand_id", "jet_pfcand_calofraction", "jet_pfcand_hcalfraction", "jet_pfcand_puppiw", "jet_pfcand_muon_id", "jet_pfcand_muon_isglobal", "jet_pfcand_muon_segcomp", "jet_pfcand_muon_chi2", "jet_pfcand_muon_nvalidhit", "jet_pfcand_muon_nstation", "jet_pfcand_electron_detaIn", "jet_pfcand_electron_dphiIn", "jet_pfcand_electron_sigIetaIeta", "jet_pfcand_electron_sigIphiIphi", "jet_pfcand_electron_r9", "jet_pfcand_electron_convProb", "jet_pfcand_photon_sigIetaIeta", "jet_pfcand_photon_r9", "jet_pfcand_photon_eVeto", "jet_pfcand_tau_signal", "pfcand_mask"}; - -const std::vector ParticleNetFeatureEvaluator::sv_features_{"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"}; - -const std::vector ParticleNetFeatureEvaluator::losttrack_features_{"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"}; - -ParticleNetFeatureEvaluator::ParticleNetFeatureEvaluator(const edm::ParameterSet &iConfig): - jet_radius_(iConfig.getParameter("jet_radius")), - min_jet_pt_(iConfig.getParameter("min_jet_pt")), - max_jet_eta_(iConfig.getParameter("max_jet_eta")), - min_jet_eta_(iConfig.getParameter("min_jet_eta")), - min_pt_for_track_properties_(iConfig.getParameter("min_pt_for_track_properties")), - min_pt_for_pfcandidates_(iConfig.getParameter("min_pt_for_pfcandidates")), - min_pt_for_losttrack_(iConfig.getParameter("min_pt_for_losttrack")), - max_dr_for_losttrack_(iConfig.getParameter("max_dr_for_losttrack")), - min_pt_for_taus_(iConfig.getParameter("min_pt_for_taus")), - max_eta_for_taus_(iConfig.getParameter("max_eta_for_taus")), - use_puppiP4_(iConfig.getParameter("use_puppiP4")), - min_puppi_wgt_(iConfig.getParameter("min_puppi_wgt")), - include_neutrals_(iConfig.getParameter("include_neutrals")), - muon_token_(consumes(iConfig.getParameter("muons"))), - electron_token_(consumes(iConfig.getParameter("electrons"))), - photon_token_(consumes(iConfig.getParameter("photons"))), - tau_token_(consumes(iConfig.getParameter("taus"))), - jet_token_(consumes >(iConfig.getParameter("jets"))), - losttrack_token_(consumes(iConfig.getParameter("losttracks"))), - vtx_token_(consumes(iConfig.getParameter("vertices"))), - sv_token_(consumes(iConfig.getParameter("secondary_vertices"))), - pfcand_token_(consumes >(iConfig.getParameter("pf_candidates"))), - track_builder_token_(esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))) { - +const std::vector ParticleNetFeatureEvaluator::particle_features_{"jet_pfcand_pt_log", + "jet_pfcand_energy_log", + "jet_pfcand_deta", + "jet_pfcand_dphi", + "jet_pfcand_eta", + "jet_pfcand_charge", + "jet_pfcand_frompv", + "jet_pfcand_nlostinnerhits", + "jet_pfcand_track_chi2", + "jet_pfcand_track_qual", + "jet_pfcand_dz", + "jet_pfcand_dzsig", + "jet_pfcand_dxy", + "jet_pfcand_dxysig", + "jet_pfcand_etarel", + "jet_pfcand_pperp_ratio", + "jet_pfcand_ppara_ratio", + "jet_pfcand_trackjet_d3d", + "jet_pfcand_trackjet_d3dsig", + "jet_pfcand_trackjet_dist", + "jet_pfcand_nhits", + "jet_pfcand_npixhits", + "jet_pfcand_nstriphits", + "jet_pfcand_trackjet_decayL", + "jet_pfcand_id", + "jet_pfcand_calofraction", + "jet_pfcand_hcalfraction", + "jet_pfcand_puppiw", + "jet_pfcand_muon_id", + "jet_pfcand_muon_isglobal", + "jet_pfcand_muon_segcomp", + "jet_pfcand_muon_chi2", + "jet_pfcand_muon_nvalidhit", + "jet_pfcand_muon_nstation", + "jet_pfcand_electron_detaIn", + "jet_pfcand_electron_dphiIn", + "jet_pfcand_electron_sigIetaIeta", + "jet_pfcand_electron_sigIphiIphi", + "jet_pfcand_electron_r9", + "jet_pfcand_electron_convProb", + "jet_pfcand_photon_sigIetaIeta", + "jet_pfcand_photon_r9", + "jet_pfcand_photon_eVeto", + "jet_pfcand_tau_signal", + "pfcand_mask"}; + +const std::vector ParticleNetFeatureEvaluator::sv_features_{"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"}; + +const std::vector ParticleNetFeatureEvaluator::losttrack_features_{"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"}; + +ParticleNetFeatureEvaluator::ParticleNetFeatureEvaluator(const edm::ParameterSet &iConfig) + : jet_radius_(iConfig.getParameter("jet_radius")), + min_jet_pt_(iConfig.getParameter("min_jet_pt")), + max_jet_eta_(iConfig.getParameter("max_jet_eta")), + min_jet_eta_(iConfig.getParameter("min_jet_eta")), + min_pt_for_track_properties_(iConfig.getParameter("min_pt_for_track_properties")), + min_pt_for_pfcandidates_(iConfig.getParameter("min_pt_for_pfcandidates")), + min_pt_for_losttrack_(iConfig.getParameter("min_pt_for_losttrack")), + max_dr_for_losttrack_(iConfig.getParameter("max_dr_for_losttrack")), + min_pt_for_taus_(iConfig.getParameter("min_pt_for_taus")), + max_eta_for_taus_(iConfig.getParameter("max_eta_for_taus")), + use_puppiP4_(iConfig.getParameter("use_puppiP4")), + min_puppi_wgt_(iConfig.getParameter("min_puppi_wgt")), + include_neutrals_(iConfig.getParameter("include_neutrals")), + muon_token_(consumes(iConfig.getParameter("muons"))), + electron_token_(consumes(iConfig.getParameter("electrons"))), + photon_token_(consumes(iConfig.getParameter("photons"))), + tau_token_(consumes(iConfig.getParameter("taus"))), + jet_token_(consumes>(iConfig.getParameter("jets"))), + losttrack_token_(consumes(iConfig.getParameter("losttracks"))), + vtx_token_(consumes(iConfig.getParameter("vertices"))), + sv_token_(consumes( + iConfig.getParameter("secondary_vertices"))), + pfcand_token_(consumes>(iConfig.getParameter("pf_candidates"))), + track_builder_token_( + esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))) { produces>(); - } ParticleNetFeatureEvaluator::~ParticleNetFeatureEvaluator() {} @@ -224,8 +293,8 @@ void ParticleNetFeatureEvaluator::fillDescriptions(edm::ConfigurationDescription desc.add("min_pt_for_pfcandidates", -1); desc.add("min_pt_for_losttrack", 1); desc.add("max_dr_for_losttrack", 0.4); - desc.add("min_pt_for_taus",20.); - desc.add("max_eta_for_taus",2.5); + desc.add("min_pt_for_taus", 20.); + desc.add("max_eta_for_taus", 2.5); desc.add("use_puppiP4", false); desc.add("include_neutrals", true); desc.add("min_puppi_wgt", -1.); @@ -242,15 +311,14 @@ void ParticleNetFeatureEvaluator::fillDescriptions(edm::ConfigurationDescription } void ParticleNetFeatureEvaluator::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { - // output collection auto output_tag_infos = std::make_unique>(); // Input jets auto jets = iEvent.getHandle(jet_token_); // Input muons - auto muons = iEvent.getHandle(muon_token_); + auto muons = iEvent.getHandle(muon_token_); // Input taus - auto taus = iEvent.getHandle(tau_token_); + auto taus = iEvent.getHandle(tau_token_); // Input electrons auto electrons = iEvent.getHandle(electron_token_); // Input photons @@ -276,32 +344,34 @@ void ParticleNetFeatureEvaluator::produce(edm::Event &iEvent, const edm::EventSe // tau signal candidates std::vector 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 (taus->at(itau).signalCands()[ipart].get()); + 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(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]; + const auto &jet = (*jets)[jet_n]; edm::RefToBase jet_ref(jets, jet_n); // create jet features DeepBoostedJetFeatures features; - for (const auto &name : particle_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(&jet)->correctedJet("Uncorrected").pt() < min_jet_pt_) or - std::abs(jet.eta()) > max_jet_eta_ or - std::abs(jet.eta()) < min_jet_eta_ ) + if ((jet.pt() < min_jet_pt_ and + dynamic_cast(&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; @@ -318,92 +388,99 @@ void ParticleNetFeatureEvaluator::produce(edm::Event &iEvent, const edm::EventSe // 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)); } -bool ParticleNetFeatureEvaluator::useTrackProperties(const pat::PackedCandidate* cand) { +bool ParticleNetFeatureEvaluator::useTrackProperties(const pat::PackedCandidate *cand) { const auto *track = cand->bestTrack(); return track != nullptr and track->pt() > min_pt_for_track_properties_; }; -void ParticleNetFeatureEvaluator::fillParticleFeatures(DeepBoostedJetFeatures & fts, - const reco::Jet & jet, - const std::vector & tau_pfcandidates, - const pat::MuonCollection & muons, - const pat::ElectronCollection & electrons, - const pat::PhotonCollection & photons - ) { +void ParticleNetFeatureEvaluator::fillParticleFeatures(DeepBoostedJetFeatures &fts, + const reco::Jet &jet, + const std::vector &tau_pfcandidates, + const pat::MuonCollection &muons, + const pat::ElectronCollection &electrons, + const pat::PhotonCollection &photons) { // 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()); + 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_); + TrackInfoBuilder trackinfo(track_builder_); // make list of pf-candidates to be considered - std::vector daughters; + std::vector daughters; for (const auto &dau : jet.daughterPtrVector()) { - // remove particles w/ extremely low puppi weights - const pat::PackedCandidate* cand = dynamic_cast(&(*dau)); - if(not cand) - throw edm::Exception(edm::errors::InvalidReference) - << "Cannot convert to either pat::PackedCandidate"; - if(cand->puppiWeight() < min_puppi_wgt_) continue; + // remove particles w/ extremely low puppi weights + const pat::PackedCandidate *cand = dynamic_cast(&(*dau)); + if (not cand) + throw edm::Exception(edm::errors::InvalidReference) << "Cannot convert to either pat::PackedCandidate"; + if (cand->puppiWeight() < min_puppi_wgt_) + continue; // base requirements on PF candidates - if (cand->pt() < min_pt_for_pfcandidates_) continue; + 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; + if (!include_neutrals_ and (cand->charge() == 0 or cand->pt() < min_pt_for_track_properties_)) + continue; // filling daughters daughters.push_back(cand); } // sort by Puppi-weighted pt if (use_puppiP4_) - std::sort(daughters.begin(), daughters.end(), [&](const pat::PackedCandidate* a, const pat::PackedCandidate* b) { - return a->puppiWeight() * a->pt() > b->puppiWeight() * b->pt(); - }); + std::sort(daughters.begin(), daughters.end(), [&](const pat::PackedCandidate *a, const pat::PackedCandidate *b) { + return a->puppiWeight() * a->pt() > b->puppiWeight() * b->pt(); + }); // sort by original pt (not Puppi-weighted) else - std::sort(daughters.begin(), daughters.end(), [](const auto &a, const auto &b) { return a->pt() > b->pt();}); - + 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; - + if (!include_neutrals_ and !useTrackProperties(cand)) + continue; + // input particle is a packed PF candidate auto candP4 = use_puppiP4_ ? cand->puppiWeight() * cand->p4() : cand->p4(); auto candP3 = use_puppiP4_ ? cand->puppiWeight() * cand->momentum() : cand->momentum(); - + // candidate track const reco::Track *track = nullptr; - if(useTrackProperties(cand)) + 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(); + 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_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)); @@ -413,45 +490,51 @@ void ParticleNetFeatureEvaluator::fillParticleFeatures(DeepBoostedJetFeatures & 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); + 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_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("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_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_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; + 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_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_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); @@ -463,129 +546,139 @@ void ParticleNetFeatureEvaluator::fillParticleFeatures(DeepBoostedJetFeatures & } // muons specific - if(abs(cand->pdgId()) == 13){ + if (abs(cand->pdgId()) == 13) { std::vector 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])); + 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); + } } - 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); + 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); } - 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; + 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()); + if (electrons[i].isPF()) { + for (const auto &element : electrons[i].associatedPackedPFCandidates()) { + if (abs(element->pdgId()) == 11 and element->p4() == candP4) + ipos = i; + } + } } - 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); + 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); + } 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; + 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()); + for (const auto &element : photons[i].associatedPackedPFCandidates()) { + if (abs(element->pdgId()) == 22 and element->p4() == candP4) + ipos = i; + } } - else{ - fts.fill("jet_pfcand_photon_sigIetaIeta",0); - fts.fill("jet_pfcand_photon_r9",0); - fts.fill("jet_pfcand_photon_eVeto",0); + 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); } - 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); + // 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); } } -void ParticleNetFeatureEvaluator::fillSVFeatures(DeepBoostedJetFeatures &fts, - const reco::Jet & jet) { - +void ParticleNetFeatureEvaluator::fillSVFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet) { // secondary vertexes matching jet - std::vector jetSVs; + std::vector jetSVs; for (const auto &sv : *svs_) { if (reco::deltaR2(sv, jet) < jet_radius_ * jet_radius_) { jetSVs.push_back(&sv); @@ -595,17 +688,16 @@ void ParticleNetFeatureEvaluator::fillSVFeatures(DeepBoostedJetFeatures &fts, // sort by dxy significance std::sort(jetSVs.begin(), jetSVs.end(), - [&](const reco::VertexCompositePtrCandidate *sva, - const reco::VertexCompositePtrCandidate *svb) { + [&](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())); @@ -615,98 +707,101 @@ void ParticleNetFeatureEvaluator::fillSVFeatures(DeepBoostedJetFeatures &fts, 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())); - } } -void ParticleNetFeatureEvaluator::fillLostTrackFeatures(DeepBoostedJetFeatures &fts, - const reco::Jet & jet - ) { - +void ParticleNetFeatureEvaluator::fillLostTrackFeatures(DeepBoostedJetFeatures &fts, const reco::Jet &jet) { // 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()); + 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 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_ ){ + 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();}); + 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()); + math::XYZPoint pv_ass_pos = pv_ass->position(); + + for (auto const <rack : 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_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; + 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_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_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); - + fts.fill("lt_mask", 1); } } // define this as a plug-in DEFINE_FWK_MODULE(ParticleNetFeatureEvaluator); - From 06594450b583ccd9cb53ba6bea136e8ecc638bb9 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Thu, 16 Feb 2023 15:05:57 +0100 Subject: [PATCH 05/24] add test cfgs for ParticleNetFromMiniAOD --- .../test_particle_from_miniaod_ak4chs_cfg.py | 95 +++++++++++++++++++ ...test_particle_from_miniaod_ak4puppi_cfg.py | 95 +++++++++++++++++++ .../test_particle_from_miniaod_ak8_cfg.py | 78 +++++++++++++++ 3 files changed, 268 insertions(+) create mode 100644 RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4chs_cfg.py create mode 100644 RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4puppi_cfg.py create mode 100644 RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak8_cfg.py diff --git a/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4chs_cfg.py b/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4chs_cfg.py new file mode 100644 index 0000000000000..8d18f274b372c --- /dev/null +++ b/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4chs_cfg.py @@ -0,0 +1,95 @@ +### CMSSW command line parameter parser +import FWCore.ParameterSet.Config as cms + + +process = cms.Process("test") + +# Message Logger settings +process.load("FWCore.MessageService.MessageLogger_cfi") +process.MessageLogger.cerr.FwkReport.reportEvery = 250 +process.load("RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff") + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(100) +) + +process.options = cms.untracked.PSet( + allowUnscheduled = cms.untracked.bool(True), + wantSummary = cms.untracked.bool(True), + numberOfThreads = cms.untracked.uint32(8), + numberOfStreams = cms.untracked.uint32(0) +) + +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring("/store/mc/RunIISummer20UL18MiniAODv2/TTToSemiLeptonic_TuneCP5_13TeV-powheg-pythia8/MINIAODSIM/106X_upgrade2018_realistic_v16_L1v1-v2/130000/25BF763A-BF41-E242-86A2-5E0BE8EF605C.root") +) + +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +process.load('Configuration.StandardSequences.GeometryDB_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('TrackingTools.TransientTrack.TransientTrackBuilder_cfi') + +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase1_2018_realistic', '') + + +from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cfi import updatedPatJets +process.slimmedJetsUpdated = updatedPatJets.clone( + jetSource = "slimmedJets", + addJetCorrFactors = False, + discriminatorSources = cms.VInputTag( + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probb"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probc"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probuds"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probg"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probmu"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probele"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probtaup1h0p"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probtaup1h1p"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probtaup1h2p"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probtaup3h0p"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probtaup3h1p"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probtaum1h0p"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probtaum1h1p"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probtaum1h2p"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probtaum3h0p"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:probtaum3h1p"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptcorr"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptnu"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptreshigh"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptreslow"), + + cms.InputTag("pfParticleNetFromMiniAODAK4CHSForwardJetTags:probq"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSForwardJetTags:probg"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptcorr"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptnu"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptreshigh"), + cms.InputTag("pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptreslow"), + + ) +) + + +process.path = cms.Path( + process.slimmedJetsUpdated,process.pfParticleNetFromMiniAODAK4CHSTask +) + +process.output = cms.OutputModule( "PoolOutputModule", + fileName = cms.untracked.string( "test.root" ), + compressionAlgorithm = cms.untracked.string('LZMA'), + compressionLevel = cms.untracked.int32(4), + eventAutoFlushCompressedSize = cms.untracked.int32(31457280), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string( 'RECO' ), + filterName = cms.untracked.string( '' ) + ), + overrideBranchesSplitLevel = cms.untracked.VPSet(), + outputCommands = cms.untracked.vstring( + 'drop *', + 'keep *_*slimmedJetsUpdated*_*_*', + ) +) + +process.endpath = cms.EndPath(process.output); +process.schedule = cms.Schedule(process.path,process.endpath); + diff --git a/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4puppi_cfg.py b/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4puppi_cfg.py new file mode 100644 index 0000000000000..844113f2973db --- /dev/null +++ b/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4puppi_cfg.py @@ -0,0 +1,95 @@ +### CMSSW command line parameter parser +import FWCore.ParameterSet.Config as cms + + +process = cms.Process("test") + +# Message Logger settings +process.load("FWCore.MessageService.MessageLogger_cfi") +process.MessageLogger.cerr.FwkReport.reportEvery = 250 +process.load("RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff") + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(100) +) + +process.options = cms.untracked.PSet( + allowUnscheduled = cms.untracked.bool(True), + wantSummary = cms.untracked.bool(True), + numberOfThreads = cms.untracked.uint32(8), + numberOfStreams = cms.untracked.uint32(0) +) + +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring("/store/mc/RunIISummer20UL18MiniAODv2/TTToSemiLeptonic_TuneCP5_13TeV-powheg-pythia8/MINIAODSIM/106X_upgrade2018_realistic_v16_L1v1-v2/130000/25BF763A-BF41-E242-86A2-5E0BE8EF605C.root") +) + +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +process.load('Configuration.StandardSequences.GeometryDB_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('TrackingTools.TransientTrack.TransientTrackBuilder_cfi') + +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase1_2018_realistic', '') + + +from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cfi import updatedPatJets +process.slimmedJetsUpdated = updatedPatJets.clone( + jetSource = "slimmedJetsPuppi", + addJetCorrFactors = False, + discriminatorSources = cms.VInputTag( + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probb"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probc"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probuds"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probg"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probmu"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probele"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probtaup1h0p"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probtaup1h1p"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probtaup1h2p"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probtaup3h0p"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probtaup3h1p"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probtaum1h0p"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probtaum1h1p"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probtaum1h2p"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probtaum3h0p"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probtaum3h1p"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptcorr"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptnu"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptreshigh"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptreslow"), + + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiForwardJetTags:probq"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiForwardJetTags:probg"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptcorr"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptnu"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptreshigh"), + cms.InputTag("pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptreslow"), + + ) +) + + +process.path = cms.Path( + process.slimmedJetsUpdated,process.pfParticleNetFromMiniAODAK4PuppiTask +) + +process.output = cms.OutputModule( "PoolOutputModule", + fileName = cms.untracked.string( "test.root" ), + compressionAlgorithm = cms.untracked.string('LZMA'), + compressionLevel = cms.untracked.int32(4), + eventAutoFlushCompressedSize = cms.untracked.int32(31457280), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string( 'RECO' ), + filterName = cms.untracked.string( '' ) + ), + overrideBranchesSplitLevel = cms.untracked.VPSet(), + outputCommands = cms.untracked.vstring( + 'drop *', + 'keep *_*slimmedJetsUpdated*_*_*', + ) +) + +process.endpath = cms.EndPath(process.output); +process.schedule = cms.Schedule(process.path,process.endpath); + diff --git a/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak8_cfg.py b/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak8_cfg.py new file mode 100644 index 0000000000000..230ce0d042a6d --- /dev/null +++ b/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak8_cfg.py @@ -0,0 +1,78 @@ +### CMSSW command line parameter parser +import FWCore.ParameterSet.Config as cms + + +process = cms.Process("test") + +# Message Logger settings +process.load("FWCore.MessageService.MessageLogger_cfi") +process.MessageLogger.cerr.FwkReport.reportEvery = 250 +process.load("RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK8_cff") + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(100) +) + +process.options = cms.untracked.PSet( + allowUnscheduled = cms.untracked.bool(True), + wantSummary = cms.untracked.bool(True), + numberOfThreads = cms.untracked.uint32(8), + numberOfStreams = cms.untracked.uint32(0) +) + +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring("/store/mc/RunIISummer20UL18MiniAODv2/TTToSemiLeptonic_TuneCP5_13TeV-powheg-pythia8/MINIAODSIM/106X_upgrade2018_realistic_v16_L1v1-v2/130000/25BF763A-BF41-E242-86A2-5E0BE8EF605C.root") +) + +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +process.load('Configuration.StandardSequences.GeometryDB_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('TrackingTools.TransientTrack.TransientTrackBuilder_cfi') + +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase1_2018_realistic', '') + + +from PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cfi import updatedPatJets +process.slimmedJetsUpdated = updatedPatJets.clone( + jetSource = "slimmedJetsAK8", + addJetCorrFactors = False, + discriminatorSources = cms.VInputTag( + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:probHtt"), + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:probHtm"), + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:probHte"), + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:probHbb"), + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:probHcc"), + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:probHqq"), + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:probHgg"), + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:probQCD2hf"), + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:probQCD1hf"), + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:probQCD0hf"), + cms.InputTag("pfParticleNetFromMiniAODAK8JetTags:masscorr"), + ) +) + + +process.path = cms.Path( + process.slimmedJetsUpdated,process.pfParticleNetFromMiniAODAK8Task +) + +process.output = cms.OutputModule( "PoolOutputModule", + fileName = cms.untracked.string( "test.root" ), + compressionAlgorithm = cms.untracked.string('LZMA'), + compressionLevel = cms.untracked.int32(4), + eventAutoFlushCompressedSize = cms.untracked.int32(31457280), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string( 'RECO' ), + filterName = cms.untracked.string( '' ) + ), + overrideBranchesSplitLevel = cms.untracked.VPSet(), + outputCommands = cms.untracked.vstring( + 'drop *', + 'keep *_*slimmedJetsUpdated*_*_*', + ) +) + +process.endpath = cms.EndPath(process.output); +process.schedule = cms.Schedule(process.path,process.endpath); + From 17457a557bd75ab479dfb78013edf9e551ecd6b7 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Wed, 1 Mar 2023 17:03:49 +0100 Subject: [PATCH 06/24] first implementation of new extended ParticleNet networks in miniAOD and nanoAOD --- .../NanoAOD/python/jetsAK4_CHS_cff.py | 7 + .../NanoAOD/python/jetsAK4_Puppi_cff.py | 7 + PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 26 +- .../python/recoLayer0/bTagging_cff.py | 32 ++ .../python/slimming/applyDeepBtagging_cff.py | 30 +- .../PatAlgos/python/tools/jetTools.py | 230 ++++++++++++- ...FromMiniAODAK4DiscriminatorsJetTags_cfi.py | 313 ++++++++++++++++++ .../python/pfParticleNetFromMiniAODAK4_cff.py | 14 + ...FromMiniAODAK8DiscriminatorsJetTags_cfi.py | 71 ++++ .../python/pfParticleNetFromMiniAODAK8_cff.py | 5 + ...st_particlenet_from_miniaod_ak4chs_cfg.py} | 0 ..._particlenet_from_miniaod_ak4puppi_cfg.py} | 0 ... test_particlenet_from_miniaod_ak8_cfg.py} | 0 13 files changed, 717 insertions(+), 18 deletions(-) create mode 100644 RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4DiscriminatorsJetTags_cfi.py create mode 100644 RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8DiscriminatorsJetTags_cfi.py rename RecoBTag/ONNXRuntime/test/{test_particle_from_miniaod_ak4chs_cfg.py => test_particlenet_from_miniaod_ak4chs_cfg.py} (100%) rename RecoBTag/ONNXRuntime/test/{test_particle_from_miniaod_ak4puppi_cfg.py => test_particlenet_from_miniaod_ak4puppi_cfg.py} (100%) rename RecoBTag/ONNXRuntime/test/{test_particle_from_miniaod_ak8_cfg.py => test_particlenet_from_miniaod_ak8_cfg.py} (100%) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 414a011c9140b..4cb80962f4354 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -129,6 +129,13 @@ btagDeepFlavCvL = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg')):-1",float,doc="DeepJet c vs uds+g discriminator",precision=10), btagDeepFlavCvB = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), btagDeepFlavQG = Var("?(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), + btagPNetB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="ParticleNet b vs. udscg"), + btagPNetCvL = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsL')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsL'):-1",float,precision=10,doc="ParticleNet c vs. udsg"), + btagPNetCvB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="ParticleNet c vs. b"), + btagPNetQvG = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:QvsG'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardDiscriminatorsJetTags:QvsG')",float,precision=10,doc="ParticleNet q (udsbc) vs. g"), + btagPNetTauVJet = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:TauVsJet')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:TauVsJet'):-1",float,precision=10,doc="ParticleNet tau vs. jet"), + PNetRegPtRawCorr = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptcorr'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptcorr')",float,precision=10,doc="ParticleNet universal flavor-aware pT regression, correction relative to raw jet pT"), + PNetRegPtRawRes = Var("?abs(eta())<2.5?0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptreslow')):0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptreslow'))",float,precision=10,doc="ParticleNet universal flavor-aware jet pT resolution estimator, (q84 - q16)/2"), puIdDisc = Var("userFloat('puIdNanoDisc')", float,doc="Pileup ID discriminant with 106X (2018) training",precision=10), puId = Var("userInt('puIdNanoId')", "uint8", doc="Pileup ID flags with 106X (2018) training"), jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", "uint8", doc="Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"), diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index b83575526acf3..9ee07d2cc1669 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -87,6 +87,13 @@ btagDeepFlavCvL = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg')):-1",float,doc="DeepJet c vs uds+g discriminator",precision=10), btagDeepFlavCvB = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), btagDeepFlavQG = Var("?(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), + btagPNetB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="ParticleNet b vs. udscg"), + btagPNetCvL = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsL')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsL'):-1",float,precision=10,doc="ParticleNet c vs. udsg"), + btagPNetCvB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="ParticleNet c vs. b"), + btagPNetQvG = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:QvsG'):bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardDiscriminatorsJetTags:QvsG')",float,precision=10,doc="ParticleNet q (udsbc) vs. g"), + btagPNetTauVJet = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:TauVsJet')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:TauVsJet'):-1",float,precision=10,doc="ParticleNet tau vs. jet"), + PNetRegPtRawCorr = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptcorr'):bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptcorr')",float,precision=10,doc="ParticleNet universal flavor-aware pT regression, correction relative to raw jet pT"), + PNetRegPtRawRes = Var("?abs(eta())<2.5?0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptreslow')):0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptreslow'))",float,precision=10,doc="ParticleNet universal flavor-aware jet pT resolution estimator, (q84 - q16)/2"), jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", "uint8",doc="Jet ID flag: bit2 is tight, bit3 is tightLepVeto"), hfsigmaEtaEta = Var("userFloat('hfsigmaEtaEta')",float,doc="sigmaEtaEta for HF jets (noise discriminating variable)",precision=10), hfsigmaPhiPhi = Var("userFloat('hfsigmaPhiPhi')",float,doc="sigmaPhiPhi for HF jets (noise discriminating variable)",precision=10), diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index 8206049eff8e5..43a3ef11ef3c6 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -112,18 +112,20 @@ deepTagMD_H4qvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:H4qvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger H->4q vs QCD discriminator",precision=10), deepTagMD_bbvsLight = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:bbvsLight')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->bb vs light flavour discriminator",precision=10), deepTagMD_ccvsLight = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ccvsLight')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->cc vs light flavour discriminator",precision=10), - particleNet_TvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:TvsQCD')",float,doc="ParticleNet tagger top vs QCD discriminator",precision=10), - particleNet_WvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:WvsQCD')",float,doc="ParticleNet tagger W vs QCD discriminator",precision=10), - particleNet_ZvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZvsQCD')",float,doc="ParticleNet tagger Z vs QCD discriminator",precision=10), - particleNet_HbbvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HbbvsQCD')",float,doc="ParticleNet tagger H(->bb) vs QCD discriminator",precision=10), - particleNet_HccvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HccvsQCD')",float,doc="ParticleNet tagger H(->cc) vs QCD discriminator",precision=10), - particleNet_H4qvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:H4qvsQCD')",float,doc="ParticleNet tagger H(->VV->qqqq) vs QCD discriminator",precision=10), - particleNet_QCD = Var("bDiscriminator('pfParticleNetJetTags:probQCDbb')+bDiscriminator('pfParticleNetJetTags:probQCDcc')+bDiscriminator('pfParticleNetJetTags:probQCDb')+bDiscriminator('pfParticleNetJetTags:probQCDc')+bDiscriminator('pfParticleNetJetTags:probQCDothers')",float,doc="ParticleNet tagger QCD(bb,cc,b,c,others) sum",precision=10), - particleNet_mass = Var("bDiscriminator('pfParticleNetMassRegressionJetTags:mass')",float,doc="ParticleNet mass regression",precision=10), - particleNetMD_Xbb = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probXbb')",float,doc="Mass-decorrelated ParticleNet tagger raw X->bb score. For X->bb vs QCD tagging, use Xbb/(Xbb+QCD)",precision=10), - particleNetMD_Xcc = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probXcc')",float,doc="Mass-decorrelated ParticleNet tagger raw X->cc score. For X->cc vs QCD tagging, use Xcc/(Xcc+QCD)",precision=10), - particleNetMD_Xqq = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probXqq')",float,doc="Mass-decorrelated ParticleNet tagger raw X->qq (uds) score. For X->qq vs QCD tagging, use Xqq/(Xqq+QCD). For W vs QCD tagging, use (Xcc+Xqq)/(Xcc+Xqq+QCD)",precision=10), - particleNetMD_QCD = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDbb')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDcc')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDb')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDc')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDothers')",float,doc="Mass-decorrelated ParticleNet tagger raw QCD score",precision=10), + particleNet_TvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:TvsQCD')",float,doc="ParticleNet tagger (w/ mass) top vs QCD discriminator",precision=10), + particleNet_WvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:WvsQCD')",float,doc="ParticleNet tagger (w/ mass) W vs QCD discriminator",precision=10), + particleNet_ZvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZvsQCD')",float,doc="ParticleNet tagger (w/ mass) Z vs QCD discriminator",precision=10), + particleNet_XbbvsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HbbvsQCD')",float,doc="ParticleNet tagger X(->bb) vs QCD discriminator",precision=10), + particleNet_XccvsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HccvsQCD')",float,doc="ParticleNet tagger X(->cc) vs QCD discriminator",precision=10), + particleNet_XttvsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HttvsQCD')",float,doc="ParticleNet tagger X(->tau_h tau_x) vs QCD discriminator",precision=10), + particleNet_H4qvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:H4qvsQCD')",float,doc="ParticleNet tagger (w/ mass) H(->VV->qqqq) vs QCD discriminator",precision=10), + particleNet_QCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD2hf')+bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD1hf')+bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD0hf')",float,doc="ParticleNet tagger QCD(0+1+2HF) sum",precision=10), + particleNet_QCDHF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD2hf')+bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD1hf')",float,doc="ParticleNet tagger QCD 1 or 2 HF (b/c) vs. 0HF score",precision=10), + particleNet_mass = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:masscorr')",float,doc="ParticleNet mass regression",precision=10), + particleNet_Xbb = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHbb')",float,doc="ParticleNet tagger raw X->bb score. For X->bb vs QCD tagging, use Xbb/(Xbb+QCD)",precision=10), + particleNet_Xcc = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHcc')",float,doc="ParticleNet tagger raw X->cc score. For X->cc vs QCD tagging, use Xcc/(Xcc+QCD)",precision=10), + particleNet_Xqq = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHqq')",float,doc="ParticleNet tagger raw X->qq (uds) score. For X->qq vs QCD tagging, use Xqq/(Xqq+QCD). For W vs QCD tagging, use (Xcc+Xqq)/(Xcc+Xqq+QCD)",precision=10), + particleNet_Xgg = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHgg')",float,doc="ParticleNet tagger raw X->gg score. For X->gg vs QCD tagging, use Xgg/(Xgg+QCD)",precision=10), subJetIdx1 = Var("?nSubjetCollections()>0 && subjets('SoftDropPuppi').size()>0?subjets('SoftDropPuppi')[0].key():-1", "int16", doc="index of first subjet"), subJetIdx2 = Var("?nSubjetCollections()>0 && subjets('SoftDropPuppi').size()>1?subjets('SoftDropPuppi')[1].key():-1", "int16", diff --git a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py index 7231fb8196915..c31f7f94d2bad 100644 --- a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py +++ b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py @@ -54,6 +54,12 @@ , 'pixelClusterTagInfos' # HiggsInteractionNet tag infos , 'pfHiggsInteractionNetTagInfos' + , 'pfParticleNetFromMiniAODAK4PuppiCentralTagInfos' + , 'pfParticleNetFromMiniAODAK4PuppiForwardTagInfos' + , 'pfParticleNetFromMiniAODAK4CHSCentralTagInfos' + , 'pfParticleNetFromMiniAODAK4CHSForwardTagInfos' + , 'pfParticleNetFromMiniAODAK8TagInfos' + ] # extend for "internal use" in PAT/MINIAOD (renaming) supportedBtagInfos.append( 'caTopTagInfosPAT' ) @@ -279,6 +285,32 @@ for disc in _pfNegativeParticleNetAK4JetTagsProbs: supportedBtagDiscr[disc] = [["pfNegativeParticleNetAK4TagInfos"]] # ----------------------------------- +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4PuppiCentralJetTagsProbs,_pfParticleNetFromMiniAODAK4PuppiCentralJetTagsMetaDiscr +for disc in _pfParticleNetFromMiniAODAK4PuppiCentralJetTagsProbs: + supportedBtagDiscr[disc] = [["pfParticleNetFromMiniAODAK4PuppiCentralTagInfos"]] +for disc in _pfParticleNetFromMiniAODAK4PuppiCentralJetTagsMetaDiscr: + supportedMetaDiscr[disc] = _pfParticleNetFromMiniAODAK4PuppiCentralJetTagsProbs +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4PuppiForwardJetTagsProbs,_pfParticleNetFromMiniAODAK4PuppiForwardJetTagsMetaDiscr +for disc in _pfParticleNetFromMiniAODAK4PuppiForwardJetTagsProbs: + supportedBtagDiscr[disc] = [["pfParticleNetFromMiniAODAK4PuppiForwardTagInfos"]] +for disc in _pfParticleNetFromMiniAODAK4PuppiForwardJetTagsMetaDiscr: + supportedMetaDiscr[disc] = _pfParticleNetFromMiniAODAK4PuppiForwardJetTagsProbs +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSCentralJetTagsProbs,_pfParticleNetFromMiniAODAK4CHSCentralJetTagsMetaDiscr +for disc in _pfParticleNetFromMiniAODAK4CHSCentralJetTagsProbs: + supportedBtagDiscr[disc] = [["pfParticleNetFromMiniAODAK4CHSCentralTagInfos"]] +for disc in _pfParticleNetFromMiniAODAK4CHSCentralJetTagsMetaDiscr: + supportedMetaDiscr[disc] = _pfParticleNetFromMiniAODAK4CHSCentralJetTagsProbs +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsProbs,_pfParticleNetFromMiniAODAK4CHSForwardJetTagsMetaDiscr +for disc in _pfParticleNetFromMiniAODAK4CHSForwardJetTagsProbs: + supportedBtagDiscr[disc] = [["pfParticleNetFromMiniAODAK4CHSForwardTagInfos"]] +for disc in _pfParticleNetFromMiniAODAK4CHSForwardJetTagsMetaDiscr: + supportedMetaDiscr[disc] = _pfParticleNetFromMiniAODAK4CHSForwardJetTagsProbs +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK8_cff import _pfParticleNetFromMiniAODAK8JetTagsProbs,_pfParticleNetFromMiniAODAK8JetTagsMetaDiscr +for disc in _pfParticleNetFromMiniAODAK8JetTagsProbs: + supportedBtagDiscr[disc] = [["pfParticleNetFromMiniAODAK8TagInfos"]] +for disc in _pfParticleNetFromMiniAODAK8JetTagsMetaDiscr: + supportedMetaDiscr[disc] = _pfParticleNetFromMiniAODAK8JetTagsProbs + # ----------------------------------- # setup HiggsInteractionNet diff --git a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py index 937e910a87797..f43a31dbf7c25 100644 --- a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py @@ -10,6 +10,10 @@ def applyDeepBtagging(process, postfix=""): from PhysicsTools.PatAlgos.slimming.slimmedJets_cfi import slimmedJets, slimmedJetsAK8 from RecoBTag.ONNXRuntime.pfParticleNetAK4_cff import _pfParticleNetAK4JetTagsAll as pfParticleNetAK4JetTagsAll + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll as pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll as pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll as pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll as pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll # update slimmed jets to include DeepFlavour (keep same name) # make clone for DeepFlavour-less slimmed jets, so output name is preserved @@ -22,6 +26,8 @@ def applyDeepBtagging(process, postfix=""): 'pfDeepFlavourJetTags:probc', 'pfDeepFlavourJetTags:probuds', 'pfDeepFlavourJetTags:probg') + + pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll + + pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll ) updateJetCollection( process, @@ -55,8 +61,12 @@ def applyDeepBtagging(process, postfix=""): 'pfDeepFlavourJetTags:problepb', 'pfDeepFlavourJetTags:probc', 'pfDeepFlavourJetTags:probuds', - 'pfDeepFlavourJetTags:probg') + pfParticleNetAK4JetTagsAll + 'pfDeepFlavourJetTags:probg', + 'pfParticleNetAK4JetTags:probpu') + pfParticleNetAK4JetTagsAll + + pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll + + pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll ) + updateJetCollection( process, jetSource = cms.InputTag('slimmedJetsPuppiNoDeepTags'), @@ -80,6 +90,7 @@ def applyDeepBtagging(process, postfix=""): from RecoBTag.ONNXRuntime.pfHiggsInteractionNet_cff import _pfHiggsInteractionNetTagsProbs as pfHiggsInteractionNetTagsProbs from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetJetTagsAll as pfParticleNetJetTagsAll from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetMassRegressionOutputs + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK8_cff import _pfParticleNetFromMiniAODAK8JetTagsAll as pfParticleNetFromMiniAODAK8JetTagsAll # update slimmed jets to include particle-based deep taggers (keep same name) # make clone for DeepTags-less slimmed AK8 jets, so output name is preserved @@ -91,7 +102,22 @@ def applyDeepBtagging(process, postfix=""): 'pfMassIndependentDeepDoubleCvLV2JetTags:probHcc', 'pfMassIndependentDeepDoubleCvBV2JetTags:probHbb', 'pfMassIndependentDeepDoubleCvBV2JetTags:probHcc', - ) + pfDeepBoostedJetTagsAll + pfParticleNetJetTagsAll + pfHiggsInteractionNetTagsProbs + _pfParticleNetMassRegressionOutputs) + 'pfParticleNetDiscriminatorsJetTags:TvsQCD', + 'pfParticleNetDiscriminatorsJetTags:WvsQCD', + 'pfParticleNetDiscriminatorsJetTags:H4qvsQCD', + 'pfParticleNetJetTags:probTbcq', + 'pfParticleNetJetTags:probTbqq', + 'pfParticleNetJetTags:probTbc', + 'pfParticleNetJetTags:probTbq', + 'pfParticleNetJetTags:probTbel', + 'pfParticleNetJetTags:probTbmu', + 'pfParticleNetJetTags:probTbta', + 'pfParticleNetJetTags:probWcq', + 'pfParticleNetJetTags:probWqq', + 'pfParticleNetJetTags:probHqqqq', + ) + pfDeepBoostedJetTagsAll + pfHiggsInteractionNetTagsProbs + pfParticleNetFromMiniAODAK8JetTagsAll) + #) + pfDeepBoostedJetTagsAll + pfParticleNetJetTagsAll + pfHiggsInteractionNetTagsProbs + _pfParticleNetMassRegressionOutputs + # + pfParticleNetFromMiniAODAK8JetTagsAll) updateJetCollection( process, jetSource = cms.InputTag('slimmedJetsAK8NoDeepTags'), diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index c217ce6eb9b3c..086976a204d08 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -7,6 +7,11 @@ from PhysicsTools.PatAlgos.recoLayer0.bTagging_cff import * import sys from FWCore.ParameterSet.MassReplace import MassSearchReplaceAnyInputTagVisitor +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import pfParticleNetFromMiniAODAK4PuppiCentralTagInfos,pfParticleNetFromMiniAODAK4PuppiCentralJetTags,pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import pfParticleNetFromMiniAODAK4PuppiForwardTagInfos,pfParticleNetFromMiniAODAK4PuppiForwardJetTags,pfParticleNetFromMiniAODAK4PuppiForwardDiscriminatorsJetTags +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import pfParticleNetFromMiniAODAK4CHSCentralTagInfos,pfParticleNetFromMiniAODAK4CHSCentralJetTags,pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import pfParticleNetFromMiniAODAK4CHSForwardTagInfos,pfParticleNetFromMiniAODAK4CHSForwardJetTags,pfParticleNetFromMiniAODAK4CHSForwardDiscriminatorsJetTags +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK8_cff import pfParticleNetFromMiniAODAK8TagInfos,pfParticleNetFromMiniAODAK8JetTags,pfParticleNetFromMiniAODAK8DiscriminatorsJetTags ## dictionary with supported jet clustering algorithms supportedJetAlgos = { @@ -755,15 +760,80 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou acceptedTagInfos.append(btagInfo) elif hasattr(toptag, btagInfo) : acceptedTagInfos.append(btagInfo) + elif btagInfo == 'pfParticleNetFromMiniAODAK4PuppiCentralTagInfos': + # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround + if pfCandidates.value() != 'packedPFCandidates': + raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) + addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, + pfParticleNetFromMiniAODAK4PuppiCentralTagInfos.clone( + jets = jetSource, + vertices = pvSource, + secondary_vertices = svSource, + pf_candidates = pfCandidates, + ), + process, task) + acceptedTagInfos.append(btagInfo) + elif btagInfo == 'pfParticleNetFromMiniAODAK4PuppiForwardTagInfos': + # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround + if pfCandidates.value() != 'packedPFCandidates': + raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) + addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, + pfParticleNetFromMiniAODAK4PuppiForwardTagInfos.clone( + jets = jetSource, + vertices = pvSource, + secondary_vertices = svSource, + pf_candidates = pfCandidates, + ), + process, task) + acceptedTagInfos.append(btagInfo) + elif btagInfo == 'pfParticleNetFromMiniAODAK4CHSCentralTagInfos': + # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround + if pfCandidates.value() != 'packedPFCandidates': + raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) + addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, + pfParticleNetFromMiniAODAK4CHSCentralTagInfos.clone( + jets = jetSource, + vertices = pvSource, + secondary_vertices = svSource, + pf_candidates = pfCandidates, + ), + process, task) + acceptedTagInfos.append(btagInfo) + elif btagInfo == 'pfParticleNetFromMiniAODAK4CHSForwardTagInfos': + # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround + if pfCandidates.value() != 'packedPFCandidates': + raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) + addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, + pfParticleNetFromMiniAODAK4CHSForwardTagInfos.clone( + jets = jetSource, + vertices = pvSource, + secondary_vertices = svSource, + pf_candidates = pfCandidates, + ), + process, task) + acceptedTagInfos.append(btagInfo) + elif btagInfo == 'pfParticleNetFromMiniAODAK8TagInfos': + # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround + if pfCandidates.value() != 'packedPFCandidates': + raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) + addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, + pfParticleNetFromMiniAODAK8TagInfos.clone( + jets = jetSource, + vertices = pvSource, + secondary_vertices = svSource, + pf_candidates = pfCandidates, + ), + process, task) + acceptedTagInfos.append(btagInfo) else: print(' --> %s ignored, since not available via RecoBTag.Configuration.RecoBTag_cff!'%(btagInfo)) - ## setup all required btagDiscriminators + # setup all required btagDiscriminators acceptedBtagDiscriminators = list() for discriminator_name in btagDiscriminators : btagDiscr = discriminator_name.split(':')[0] #split input tag to get the producer label #print discriminator_name, '-->', btagDiscr + newDiscr = btagPrefix+btagDiscr+labelName+postfix #new discriminator name if hasattr(btag,btagDiscr): - newDiscr = btagPrefix+btagDiscr+labelName+postfix #new discriminator name if hasattr(process, newDiscr): pass elif hasattr(getattr(btag, btagDiscr), 'tagInfos'): @@ -790,14 +860,75 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou else: raise ValueError('I do not know how to update %s it does not have neither "tagInfos" nor "src" attributes' % btagDiscr) acceptedBtagDiscriminators.append(discriminator_name) + elif btagDiscr=='pfParticleNetFromMiniAODAK4PuppiCentralJetTags': + if hasattr(process, newDiscr): + pass + addToProcessAndTask( + newDiscr, + pfParticleNetFromMiniAODAK4PuppiCentralJetTags.clone( + src = cms.InputTag(btagPrefix+supportedBtagDiscr[discriminator_name][0][0]+labelName+postfix) + ), + process, + task + ) + acceptedBtagDiscriminators.append(discriminator_name) + elif btagDiscr=='pfParticleNetFromMiniAODAK4PuppiForwardJetTags': + if hasattr(process, newDiscr): + pass + addToProcessAndTask( + newDiscr, + pfParticleNetFromMiniAODAK4PuppiForwardJetTags.clone( + src = cms.InputTag(btagPrefix+supportedBtagDiscr[discriminator_name][0][0]+labelName+postfix) + ), + process, + task + ) + acceptedBtagDiscriminators.append(discriminator_name) + elif btagDiscr=='pfParticleNetFromMiniAODAK4CHSCentralJetTags': + if hasattr(process, newDiscr): + pass + addToProcessAndTask( + newDiscr, + pfParticleNetFromMiniAODAK4CHSCentralJetTags.clone( + src = cms.InputTag(btagPrefix+supportedBtagDiscr[discriminator_name][0][0]+labelName+postfix) + ), + process, + task + ) + acceptedBtagDiscriminators.append(discriminator_name) + elif btagDiscr=='pfParticleNetFromMiniAODAK4CHSForwardJetTags': + if hasattr(process, newDiscr): + pass + addToProcessAndTask( + newDiscr, + pfParticleNetFromMiniAODAK4CHSForwardJetTags.clone( + src = cms.InputTag(btagPrefix+supportedBtagDiscr[discriminator_name][0][0]+labelName+postfix) + ), + process, + task + ) + acceptedBtagDiscriminators.append(discriminator_name) + elif btagDiscr=='pfParticleNetFromMiniAODAK8JetTags': + if hasattr(process, newDiscr): + pass + addToProcessAndTask( + newDiscr, + pfParticleNetFromMiniAODAK8JetTags.clone( + src = cms.InputTag(btagPrefix+supportedBtagDiscr[discriminator_name][0][0]+labelName+postfix) + ), + process, + task + ) + acceptedBtagDiscriminators.append(discriminator_name) else: print(' --> %s ignored, since not available via RecoBTag.Configuration.RecoBTag_cff!'%(btagDiscr)) + #update meta-taggers, if any for meta_tagger in present_meta: btagDiscr = meta_tagger.split(':')[0] #split input tag to get the producer label #print discriminator_name, '-->', btagDiscr + newDiscr = btagPrefix+btagDiscr+labelName+postfix #new discriminator name if hasattr(btag,btagDiscr): - newDiscr = btagPrefix+btagDiscr+labelName+postfix #new discriminator name if hasattr(process, newDiscr): pass else: @@ -814,7 +945,98 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou new_dep = btagPrefix+dependency+labelName+postfix replace = MassSearchReplaceAnyInputTagVisitor(dependency, new_dep) replace.doIt(getattr(process, newDiscr), newDiscr) - acceptedBtagDiscriminators.append(meta_tagger) + acceptedBtagDiscriminators.append(meta_tagger) + elif btagDiscr=='pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags': + if hasattr(process, newDiscr): + pass + else: + addToProcessAndTask( + newDiscr, + pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags.clone(), + process, + task + ) + for dependency in supportedMetaDiscr[meta_tagger]: + if ':' in dependency: + new_dep = btagPrefix+dependency.split(':')[0]+labelName+postfix+':'+dependency.split(':')[1] + else: + new_dep = btagPrefix+dependency+labelName+postfix + replace = MassSearchReplaceAnyInputTagVisitor(dependency, new_dep) + replace.doIt(getattr(process, newDiscr), newDiscr) + acceptedBtagDiscriminators.append(meta_tagger) + elif btagDiscr=='pfParticleNetFromMiniAODAK4PuppiForwardDiscriminatorsJetTags': + if hasattr(process, newDiscr): + pass + else: + addToProcessAndTask( + newDiscr, + pfParticleNetFromMiniAODAK4PuppiForwardDiscriminatorsJetTags.clone(), + process, + task + ) + for dependency in supportedMetaDiscr[meta_tagger]: + if ':' in dependency: + new_dep = btagPrefix+dependency.split(':')[0]+labelName+postfix+':'+dependency.split(':')[1] + else: + new_dep = btagPrefix+dependency+labelName+postfix + replace = MassSearchReplaceAnyInputTagVisitor(dependency, new_dep) + replace.doIt(getattr(process, newDiscr), newDiscr) + acceptedBtagDiscriminators.append(meta_tagger) + elif btagDiscr=='pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags': + if hasattr(process, newDiscr): + pass + else: + addToProcessAndTask( + newDiscr, + pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags.clone(), + process, + task + ) + for dependency in supportedMetaDiscr[meta_tagger]: + if ':' in dependency: + new_dep = btagPrefix+dependency.split(':')[0]+labelName+postfix+':'+dependency.split(':')[1] + else: + new_dep = btagPrefix+dependency+labelName+postfix + replace = MassSearchReplaceAnyInputTagVisitor(dependency, new_dep) + replace.doIt(getattr(process, newDiscr), newDiscr) + acceptedBtagDiscriminators.append(meta_tagger) + elif btagDiscr=='pfParticleNetFromMiniAODAK4CHSForwardDiscriminatorsJetTags': + if hasattr(process, newDiscr): + pass + else: + addToProcessAndTask( + newDiscr, + pfParticleNetFromMiniAODAK4CHSForwardDiscriminatorsJetTags.clone(), + process, + task + ) + for dependency in supportedMetaDiscr[meta_tagger]: + if ':' in dependency: + new_dep = btagPrefix+dependency.split(':')[0]+labelName+postfix+':'+dependency.split(':')[1] + else: + new_dep = btagPrefix+dependency+labelName+postfix + replace = MassSearchReplaceAnyInputTagVisitor(dependency, new_dep) + replace.doIt(getattr(process, newDiscr), newDiscr) + acceptedBtagDiscriminators.append(meta_tagger) + elif btagDiscr=='pfParticleNetFromMiniAODAK8DiscriminatorsJetTags': + if hasattr(process, newDiscr): + pass + else: + addToProcessAndTask( + newDiscr, + pfParticleNetFromMiniAODAK8DiscriminatorsJetTags.clone(), + process, + task + ) + for dependency in supportedMetaDiscr[meta_tagger]: + if ':' in dependency: + new_dep = btagPrefix+dependency.split(':')[0]+labelName+postfix+':'+dependency.split(':')[1] + else: + new_dep = btagPrefix+dependency+labelName+postfix + replace = MassSearchReplaceAnyInputTagVisitor(dependency, new_dep) + replace.doIt(getattr(process, newDiscr), newDiscr) + acceptedBtagDiscriminators.append(meta_tagger) + else: print(' --> %s ignored, since not available via RecoBTag.Configuration.RecoBTag_cff!'%(btagDiscr)) diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4DiscriminatorsJetTags_cfi.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4DiscriminatorsJetTags_cfi.py new file mode 100644 index 0000000000000..9e68cb1727c58 --- /dev/null +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4DiscriminatorsJetTags_cfi.py @@ -0,0 +1,313 @@ +import FWCore.ParameterSet.Config as cms + +pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('BvsAll'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probb'), + ), + denominator=cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probb'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probc'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probuds'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('CvsL'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probb'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probc'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probuds'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('CvsB'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probc'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probb'), + ), + ), + cms.PSet( + name = cms.string('QvsG'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probuds'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probuds'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('TauVsJet'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h1p'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probb'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probc'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probuds'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probg'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h1p'), + ), + ), + cms.PSet( + name = cms.string('TauVsEle'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h1p'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probele'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h1p'), + ), + ), + + cms.PSet( + name = cms.string('TauVsMu'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h1p'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probmu'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probtaum3h1p'), + ), + ), + + ) + ) + +pfParticleNetFromMiniAODAK4PuppiForwardDiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('QvsG'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiForwardJetTags', 'probq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiForwardJetTags', 'probq'), + cms.InputTag('pfParticleNetFromMiniAODAK4PuppiForwardJetTags', 'probg'), + ), + ), + + ) + ) + +pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('BvsAll'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probb'), + ), + denominator=cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probb'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probc'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probuds'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('CvsL'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probb'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probc'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probuds'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('CvsB'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probc'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probb'), + ), + ), + cms.PSet( + name = cms.string('QvsG'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probuds'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probuds'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('TauVsJet'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h1p'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probb'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probc'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probuds'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probg'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h1p'), + ), + ), + cms.PSet( + name = cms.string('TauVsEle'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h1p'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probele'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h1p'), + ), + ), + + cms.PSet( + name = cms.string('TauVsMu'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h1p'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probmu'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaup3h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h1p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum1h2p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h0p'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probtaum3h1p'), + ), + ), + + ) + ) + +pfParticleNetFromMiniAODAK4CHSForwardDiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('QvsG'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSForwardJetTags', 'probq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK4CHSForwardJetTags', 'probq'), + cms.InputTag('pfParticleNetFromMiniAODAK4CHSForwardJetTags', 'probg'), + ), + ), + + ) + ) diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py index b3ea9b90caff9..82356764f3818 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4_cff.py @@ -3,6 +3,7 @@ from RecoBTag.FeatureTools.pfDeepBoostedJetTagInfos_cfi import pfDeepBoostedJetTagInfos from RecoBTag.ONNXRuntime.boostedJetONNXJetTagsProducer_cfi import boostedJetONNXJetTagsProducer from RecoBTag.FeatureTools.ParticleNetFeatureEvaluator_cfi import ParticleNetFeatureEvaluator +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4DiscriminatorsJetTags_cfi import * pfParticleNetFromMiniAODAK4CHSCentralTagInfos = ParticleNetFeatureEvaluator.clone( jets = "slimmedJets", @@ -79,3 +80,16 @@ _pfParticleNetFromMiniAODAK4PuppiForwardJetTagsProbs = ['pfParticleNetFromMiniAODAK4PuppiForwardJetTags:' + flav_name for flav_name in pfParticleNetFromMiniAODAK4PuppiForwardJetTags.flav_names] +_pfParticleNetFromMiniAODAK4CHSCentralJetTagsMetaDiscr = ['pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:' + disc.name.value() + for disc in pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags.discriminators] +_pfParticleNetFromMiniAODAK4CHSForwardJetTagsMetaDiscr = ['pfParticleNetFromMiniAODAK4CHSForwardDiscriminatorsJetTags:' + disc.name.value() + for disc in pfParticleNetFromMiniAODAK4CHSForwardDiscriminatorsJetTags.discriminators] +_pfParticleNetFromMiniAODAK4PuppiCentralJetTagsMetaDiscr = ['pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:' + disc.name.value() + for disc in pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags.discriminators] +_pfParticleNetFromMiniAODAK4PuppiForwardJetTagsMetaDiscr = ['pfParticleNetFromMiniAODAK4PuppiForwardDiscriminatorsJetTags:' + disc.name.value() + for disc in pfParticleNetFromMiniAODAK4PuppiForwardDiscriminatorsJetTags.discriminators] + +_pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll = _pfParticleNetFromMiniAODAK4CHSCentralJetTagsProbs + _pfParticleNetFromMiniAODAK4CHSCentralJetTagsMetaDiscr +_pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll = _pfParticleNetFromMiniAODAK4CHSForwardJetTagsProbs + _pfParticleNetFromMiniAODAK4CHSForwardJetTagsMetaDiscr +_pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll = _pfParticleNetFromMiniAODAK4PuppiCentralJetTagsProbs + _pfParticleNetFromMiniAODAK4PuppiCentralJetTagsMetaDiscr +_pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll = _pfParticleNetFromMiniAODAK4PuppiForwardJetTagsProbs + _pfParticleNetFromMiniAODAK4PuppiForwardJetTagsMetaDiscr diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8DiscriminatorsJetTags_cfi.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8DiscriminatorsJetTags_cfi.py new file mode 100644 index 0000000000000..a755317a383c8 --- /dev/null +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8DiscriminatorsJetTags_cfi.py @@ -0,0 +1,71 @@ +import FWCore.ParameterSet.Config as cms + +pfParticleNetFromMiniAODAK8DiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('HbbvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHbb'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHbb'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD2hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD1hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD0hf'), + ), + ), + cms.PSet( + name = cms.string('HccvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHcc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHcc'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD2hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD1hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD0hf'), + ), + ), + cms.PSet( + name = cms.string('HttvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHtt'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHtm'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHte'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHtt'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHtm'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHte'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD2hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD1hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD0hf'), + ), + ), + cms.PSet( + name = cms.string('HqqvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHqq'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD2hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD1hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD0hf'), + ), + ), + cms.PSet( + name = cms.string('HggvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHgg'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHgg'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD2hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD1hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD0hf'), + ), + ), + ) + ) diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py index 045c6962c5534..2c9e3c62e4c94 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8_cff.py @@ -3,6 +3,7 @@ from RecoBTag.FeatureTools.pfDeepBoostedJetTagInfos_cfi import pfDeepBoostedJetTagInfos from RecoBTag.ONNXRuntime.boostedJetONNXJetTagsProducer_cfi import boostedJetONNXJetTagsProducer from RecoBTag.FeatureTools.ParticleNetFeatureEvaluator_cfi import ParticleNetFeatureEvaluator +from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK8DiscriminatorsJetTags_cfi import pfParticleNetFromMiniAODAK8DiscriminatorsJetTags pfParticleNetFromMiniAODAK8TagInfos = ParticleNetFeatureEvaluator.clone( jets = "slimmedJetsAK8", @@ -27,3 +28,7 @@ # probs _pfParticleNetFromMiniAODAK8JetTagsProbs = ['pfParticleNetFromMiniAODAK8JetTags:' + flav_name for flav_name in pfParticleNetFromMiniAODAK8JetTags.flav_names] +_pfParticleNetFromMiniAODAK8JetTagsMetaDiscr = ['pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:' + disc.name.value() + for disc in pfParticleNetFromMiniAODAK8DiscriminatorsJetTags.discriminators] + +_pfParticleNetFromMiniAODAK8JetTagsAll = _pfParticleNetFromMiniAODAK8JetTagsProbs + _pfParticleNetFromMiniAODAK8JetTagsMetaDiscr diff --git a/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4chs_cfg.py b/RecoBTag/ONNXRuntime/test/test_particlenet_from_miniaod_ak4chs_cfg.py similarity index 100% rename from RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4chs_cfg.py rename to RecoBTag/ONNXRuntime/test/test_particlenet_from_miniaod_ak4chs_cfg.py diff --git a/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4puppi_cfg.py b/RecoBTag/ONNXRuntime/test/test_particlenet_from_miniaod_ak4puppi_cfg.py similarity index 100% rename from RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak4puppi_cfg.py rename to RecoBTag/ONNXRuntime/test/test_particlenet_from_miniaod_ak4puppi_cfg.py diff --git a/RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak8_cfg.py b/RecoBTag/ONNXRuntime/test/test_particlenet_from_miniaod_ak8_cfg.py similarity index 100% rename from RecoBTag/ONNXRuntime/test/test_particle_from_miniaod_ak8_cfg.py rename to RecoBTag/ONNXRuntime/test/test_particlenet_from_miniaod_ak8_cfg.py From 06e01817aabb5ff789e8663ec2a654d832771c7b Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Thu, 2 Mar 2023 10:10:11 +0100 Subject: [PATCH 07/24] clean up saved output nodes --- PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 11 ++++++----- .../PatAlgos/python/slimming/applyDeepBtagging_cff.py | 3 +-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index 43a3ef11ef3c6..04b105da099ec 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -114,18 +114,19 @@ deepTagMD_ccvsLight = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ccvsLight')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->cc vs light flavour discriminator",precision=10), particleNet_TvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:TvsQCD')",float,doc="ParticleNet tagger (w/ mass) top vs QCD discriminator",precision=10), particleNet_WvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:WvsQCD')",float,doc="ParticleNet tagger (w/ mass) W vs QCD discriminator",precision=10), - particleNet_ZvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZvsQCD')",float,doc="ParticleNet tagger (w/ mass) Z vs QCD discriminator",precision=10), - particleNet_XbbvsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HbbvsQCD')",float,doc="ParticleNet tagger X(->bb) vs QCD discriminator",precision=10), - particleNet_XccvsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HccvsQCD')",float,doc="ParticleNet tagger X(->cc) vs QCD discriminator",precision=10), - particleNet_XttvsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HttvsQCD')",float,doc="ParticleNet tagger X(->tau_h tau_x) vs QCD discriminator",precision=10), particleNet_H4qvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:H4qvsQCD')",float,doc="ParticleNet tagger (w/ mass) H(->VV->qqqq) vs QCD discriminator",precision=10), particleNet_QCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD2hf')+bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD1hf')+bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD0hf')",float,doc="ParticleNet tagger QCD(0+1+2HF) sum",precision=10), - particleNet_QCDHF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD2hf')+bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD1hf')",float,doc="ParticleNet tagger QCD 1 or 2 HF (b/c) vs. 0HF score",precision=10), + particleNet_QCD2HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD2hf')",float,doc="ParticleNet tagger QCD 2 HF (b/c) score",precision=10), + particleNet_QCD1HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD1hf')",float,doc="ParticleNet tagger QCD 1 HF (b/c) score",precision=10), + particleNet_QCD0HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD0hf')",float,doc="ParticleNet tagger QCD 0 HF (b/c) score",precision=10), particleNet_mass = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:masscorr')",float,doc="ParticleNet mass regression",precision=10), particleNet_Xbb = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHbb')",float,doc="ParticleNet tagger raw X->bb score. For X->bb vs QCD tagging, use Xbb/(Xbb+QCD)",precision=10), particleNet_Xcc = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHcc')",float,doc="ParticleNet tagger raw X->cc score. For X->cc vs QCD tagging, use Xcc/(Xcc+QCD)",precision=10), particleNet_Xqq = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHqq')",float,doc="ParticleNet tagger raw X->qq (uds) score. For X->qq vs QCD tagging, use Xqq/(Xqq+QCD). For W vs QCD tagging, use (Xcc+Xqq)/(Xcc+Xqq+QCD)",precision=10), particleNet_Xgg = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHgg')",float,doc="ParticleNet tagger raw X->gg score. For X->gg vs QCD tagging, use Xgg/(Xgg+QCD)",precision=10), + particleNet_Xtt = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHtt')",float,doc="ParticleNet tagger raw X->tau_h tau_h score. For X->tau_h tau_h vs QCD tagging, use Xtt/(Xtt+QCD)",precision=10), + particleNet_Xtm = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHtm')",float,doc="ParticleNet tagger raw X-> mu tau_h score. For X->mu tau_h vs QCD tagging, use Xtm/(Xtm+QCD)",precision=10), + particleNet_Xte = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHte')",float,doc="ParticleNet tagger raw X-> e tau_h score. For X->e tau_h vs QCD tagging, use Xte/(Xte+QCD)",precision=10), subJetIdx1 = Var("?nSubjetCollections()>0 && subjets('SoftDropPuppi').size()>0?subjets('SoftDropPuppi')[0].key():-1", "int16", doc="index of first subjet"), subJetIdx2 = Var("?nSubjetCollections()>0 && subjets('SoftDropPuppi').size()>1?subjets('SoftDropPuppi')[1].key():-1", "int16", diff --git a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py index f43a31dbf7c25..a234d6baeb360 100644 --- a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py @@ -61,8 +61,7 @@ def applyDeepBtagging(process, postfix=""): 'pfDeepFlavourJetTags:problepb', 'pfDeepFlavourJetTags:probc', 'pfDeepFlavourJetTags:probuds', - 'pfDeepFlavourJetTags:probg', - 'pfParticleNetAK4JetTags:probpu') + pfParticleNetAK4JetTagsAll + 'pfDeepFlavourJetTags:probg') + pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll + pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll ) From da0325fa8437e295506579fc5d5d2c7cb49d38fe Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Thu, 2 Mar 2023 11:14:12 +0100 Subject: [PATCH 08/24] fix reference to PNet miniAOD tags --- PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index 04b105da099ec..e8896fb32bce5 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -115,11 +115,11 @@ particleNet_TvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:TvsQCD')",float,doc="ParticleNet tagger (w/ mass) top vs QCD discriminator",precision=10), particleNet_WvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:WvsQCD')",float,doc="ParticleNet tagger (w/ mass) W vs QCD discriminator",precision=10), particleNet_H4qvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:H4qvsQCD')",float,doc="ParticleNet tagger (w/ mass) H(->VV->qqqq) vs QCD discriminator",precision=10), - particleNet_QCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD2hf')+bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD1hf')+bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD0hf')",float,doc="ParticleNet tagger QCD(0+1+2HF) sum",precision=10), - particleNet_QCD2HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD2hf')",float,doc="ParticleNet tagger QCD 2 HF (b/c) score",precision=10), - particleNet_QCD1HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD1hf')",float,doc="ParticleNet tagger QCD 1 HF (b/c) score",precision=10), - particleNet_QCD0HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:QCD0hf')",float,doc="ParticleNet tagger QCD 0 HF (b/c) score",precision=10), - particleNet_mass = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:masscorr')",float,doc="ParticleNet mass regression",precision=10), + particleNet_QCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD2hf')+bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')+bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD0hf')",float,doc="ParticleNet tagger QCD(0+1+2HF) sum",precision=10), + particleNet_QCD2HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD2hf')",float,doc="ParticleNet tagger QCD 2 HF (b/c) score",precision=10), + particleNet_QCD1HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')",float,doc="ParticleNet tagger QCD 1 HF (b/c) score",precision=10), + particleNet_QCD0HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD0hf')",float,doc="ParticleNet tagger QCD 0 HF (b/c) score",precision=10), + particleNet_massCorr = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:masscorr')",float,doc="ParticleNet mass regression, relative correction to JEC-corrected jet mass (no softdrop)",precision=10), particleNet_Xbb = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHbb')",float,doc="ParticleNet tagger raw X->bb score. For X->bb vs QCD tagging, use Xbb/(Xbb+QCD)",precision=10), particleNet_Xcc = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHcc')",float,doc="ParticleNet tagger raw X->cc score. For X->cc vs QCD tagging, use Xcc/(Xcc+QCD)",precision=10), particleNet_Xqq = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHqq')",float,doc="ParticleNet tagger raw X->qq (uds) score. For X->qq vs QCD tagging, use Xqq/(Xqq+QCD). For W vs QCD tagging, use (Xcc+Xqq)/(Xcc+Xqq+QCD)",precision=10), From 7e5767b769e472ac54a43315db255cbd01bdaaf1 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Thu, 2 Mar 2023 15:10:18 +0100 Subject: [PATCH 09/24] remove DeepAK8 from miniAOD and nanoAOD, include full ParticleNet mass correlated outputs --- PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 36 +++++++++---------- .../python/slimming/applyDeepBtagging_cff.py | 32 ++++++++--------- .../pfParticleNetDiscriminatorsJetTags_cfi.py | 14 ++++++++ ...FromMiniAODAK8DiscriminatorsJetTags_cfi.py | 24 +++++++++++-- .../ONNXRuntime/python/pfParticleNet_cff.py | 2 ++ 5 files changed, 70 insertions(+), 38 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index e8896fb32bce5..9a92d66462b68 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -96,25 +96,15 @@ btagDDBvLV2 = Var("bDiscriminator('pfMassIndependentDeepDoubleBvLV2JetTags:probHbb')",float,doc="DeepDoubleX V2(mass-decorrelated) discriminator for H(Z)->bb vs QCD",precision=10), btagDDCvLV2 = Var("bDiscriminator('pfMassIndependentDeepDoubleCvLV2JetTags:probHcc')",float,doc="DeepDoubleX V2 (mass-decorrelated) discriminator for H(Z)->cc vs QCD",precision=10), btagDDCvBV2 = Var("bDiscriminator('pfMassIndependentDeepDoubleCvBV2JetTags:probHcc')",float,doc="DeepDoubleX V2 (mass-decorrelated) discriminator for H(Z)->cc vs H(Z)->bb",precision=10), - deepTag_TvsQCD = Var("bDiscriminator('pfDeepBoostedDiscriminatorsJetTags:TvsQCD')",float,doc="DeepBoostedJet tagger top vs QCD discriminator",precision=10), - deepTag_WvsQCD = Var("bDiscriminator('pfDeepBoostedDiscriminatorsJetTags:WvsQCD')",float,doc="DeepBoostedJet tagger W vs QCD discriminator",precision=10), - deepTag_ZvsQCD = Var("bDiscriminator('pfDeepBoostedDiscriminatorsJetTags:ZvsQCD')",float,doc="DeepBoostedJet tagger Z vs QCD discriminator",precision=10), - deepTag_H = Var("bDiscriminator('pfDeepBoostedJetTags:probHbb')+bDiscriminator('pfDeepBoostedJetTags:probHcc')+bDiscriminator('pfDeepBoostedJetTags:probHqqqq')",float,doc="DeepBoostedJet tagger H(bb,cc,4q) sum",precision=10), - deepTag_QCD = Var("bDiscriminator('pfDeepBoostedJetTags:probQCDbb')+bDiscriminator('pfDeepBoostedJetTags:probQCDcc')+bDiscriminator('pfDeepBoostedJetTags:probQCDb')+bDiscriminator('pfDeepBoostedJetTags:probQCDc')+bDiscriminator('pfDeepBoostedJetTags:probQCDothers')",float,doc="DeepBoostedJet tagger QCD(bb,cc,b,c,others) sum",precision=10), - deepTag_QCDothers = Var("bDiscriminator('pfDeepBoostedJetTags:probQCDothers')",float,doc="DeepBoostedJet tagger QCDothers value",precision=10), - deepTagMD_TvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:TvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger top vs QCD discriminator",precision=10), - deepTagMD_WvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:WvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger W vs QCD discriminator",precision=10), - deepTagMD_ZvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ZvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z vs QCD discriminator",precision=10), - deepTagMD_ZHbbvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ZHbbvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H->bb vs QCD discriminator",precision=10), - deepTagMD_ZbbvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ZbbvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z->bb vs QCD discriminator",precision=10), - deepTagMD_HbbvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:HbbvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger H->bb vs QCD discriminator",precision=10), - deepTagMD_ZHccvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ZHccvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H->cc vs QCD discriminator",precision=10), - deepTagMD_H4qvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:H4qvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger H->4q vs QCD discriminator",precision=10), - deepTagMD_bbvsLight = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:bbvsLight')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->bb vs light flavour discriminator",precision=10), - deepTagMD_ccvsLight = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ccvsLight')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->cc vs light flavour discriminator",precision=10), - particleNet_TvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:TvsQCD')",float,doc="ParticleNet tagger (w/ mass) top vs QCD discriminator",precision=10), - particleNet_WvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:WvsQCD')",float,doc="ParticleNet tagger (w/ mass) W vs QCD discriminator",precision=10), - particleNet_H4qvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:H4qvsQCD')",float,doc="ParticleNet tagger (w/ mass) H(->VV->qqqq) vs QCD discriminator",precision=10), + particleNetMassCorr_QCD = Var("bDiscriminator('pfParticleNetJetTags:probQCDbb')+bDiscriminator('pfParticleNetJetTags:probQCDcc')+bDiscriminator('pfParticleNetJetTags:probQCDb')+bDiscriminator('pfParticleNetJetTags:probQCDc')+bDiscriminator('pfParticleNetJetTags:probQCDothers')",float,doc="ParticleNet tagger QCD(bb,cc,b,c,others) sum",precision=10), + particleNetMassCorr_TvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:TvsQCD')",float,doc="ParticleNet tagger (w/ mass) top vs QCD discriminator",precision=10), + particleNetMassCorr_WvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:WvsQCD')",float,doc="ParticleNet tagger (w/ mass) W vs QCD discriminator",precision=10), + particleNetMassCorr_ZvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZvsQCD')",float,doc="ParticleNet tagger (w/ mass) Z vs QCD discriminator",precision=10), + particleNetMassCorr_H4qvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:H4qvsQCD')",float,doc="ParticleNet tagger (w/ mass) H(->VV->qqqq) vs QCD discriminator",precision=10), + particleNetMassCorr_HbbvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HbbvsQCD')",float,doc="ParticleNet tagger (w/mass) H(->bb) vs QCD discriminator",precision=10), + particleNetMassCorr_HccvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HccvsQCD')",float,doc="ParticleNet tagger (w/mass) H(->cc) vs QCD discriminator",precision=10), + particleNetMassCorr_ZbbvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZbbvsQCD')",float,doc="ParticleNet tagger (w/mass) Z(->bb) vs QCD discriminator",precision=10), + particleNetMassCorr_ZccvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZccvsQCD')",float,doc="ParticleNet tagger (w/mass) Z(->cc) vs QCD discriminator",precision=10), particleNet_QCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD2hf')+bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')+bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD0hf')",float,doc="ParticleNet tagger QCD(0+1+2HF) sum",precision=10), particleNet_QCD2HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD2hf')",float,doc="ParticleNet tagger QCD 2 HF (b/c) score",precision=10), particleNet_QCD1HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')",float,doc="ParticleNet tagger QCD 1 HF (b/c) score",precision=10), @@ -127,6 +117,14 @@ particleNet_Xtt = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHtt')",float,doc="ParticleNet tagger raw X->tau_h tau_h score. For X->tau_h tau_h vs QCD tagging, use Xtt/(Xtt+QCD)",precision=10), particleNet_Xtm = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHtm')",float,doc="ParticleNet tagger raw X-> mu tau_h score. For X->mu tau_h vs QCD tagging, use Xtm/(Xtm+QCD)",precision=10), particleNet_Xte = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHte')",float,doc="ParticleNet tagger raw X-> e tau_h score. For X->e tau_h vs QCD tagging, use Xte/(Xte+QCD)",precision=10), + # explicitly combine tagger vs. QCD scores, for convenience + particleNet_XbbVsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HbbvsQCD')",float,doc="ParticleNet X->bb vs. QCD score: Xbb/(Xbb+QCD)",precision=10), + particleNet_XccVsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HccvsQCD')",float,doc="ParticleNet X->cc vs. QCD score: Xcc/(Xcc+QCD)",precision=10), + particleNet_XqqVsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HqqvsQCD')",float,doc="ParticleNet X->qq (uds) vs. QCD score: Xqq/(Xqq+QCD)",precision=10), + particleNet_XggVsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HggvsQCD')",float,doc="ParticleNet X->gg vs. QCD score: Xgg/(Xgg+QCD)",precision=10), + particleNet_XttVsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HttvsQCD')",float,doc="ParticleNet X->tau_h tau_h vs. QCD score: Xtt/(Xtt+QCD)",precision=10), + particleNet_XtmVsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HtmvsQCD')",float,doc="ParticleNet X->mu tau_h vs. QCD score: Xtm/(Xtm+QCD)",precision=10), + particleNet_XteVsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HtevsQCD')",float,doc="ParticleNet X->e tau_h vs. QCD score: Xte/(Xte+QCD)",precision=10), subJetIdx1 = Var("?nSubjetCollections()>0 && subjets('SoftDropPuppi').size()>0?subjets('SoftDropPuppi')[0].key():-1", "int16", doc="index of first subjet"), subJetIdx2 = Var("?nSubjetCollections()>0 && subjets('SoftDropPuppi').size()>1?subjets('SoftDropPuppi')[1].key():-1", "int16", diff --git a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py index a234d6baeb360..7b1ae50bb45ca 100644 --- a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py @@ -87,7 +87,7 @@ def applyDeepBtagging(process, postfix=""): from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsAll as pfDeepBoostedJetTagsAll from RecoBTag.ONNXRuntime.pfHiggsInteractionNet_cff import _pfHiggsInteractionNetTagsProbs as pfHiggsInteractionNetTagsProbs - from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetJetTagsAll as pfParticleNetJetTagsAll + from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetMassCorrelatedJetTagsAll as pfParticleNetMassCorrelatedJetTagsAll from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetMassRegressionOutputs from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK8_cff import _pfParticleNetFromMiniAODAK8JetTagsAll as pfParticleNetFromMiniAODAK8JetTagsAll @@ -101,22 +101,20 @@ def applyDeepBtagging(process, postfix=""): 'pfMassIndependentDeepDoubleCvLV2JetTags:probHcc', 'pfMassIndependentDeepDoubleCvBV2JetTags:probHbb', 'pfMassIndependentDeepDoubleCvBV2JetTags:probHcc', - 'pfParticleNetDiscriminatorsJetTags:TvsQCD', - 'pfParticleNetDiscriminatorsJetTags:WvsQCD', - 'pfParticleNetDiscriminatorsJetTags:H4qvsQCD', - 'pfParticleNetJetTags:probTbcq', - 'pfParticleNetJetTags:probTbqq', - 'pfParticleNetJetTags:probTbc', - 'pfParticleNetJetTags:probTbq', - 'pfParticleNetJetTags:probTbel', - 'pfParticleNetJetTags:probTbmu', - 'pfParticleNetJetTags:probTbta', - 'pfParticleNetJetTags:probWcq', - 'pfParticleNetJetTags:probWqq', - 'pfParticleNetJetTags:probHqqqq', - ) + pfDeepBoostedJetTagsAll + pfHiggsInteractionNetTagsProbs + pfParticleNetFromMiniAODAK8JetTagsAll) - #) + pfDeepBoostedJetTagsAll + pfParticleNetJetTagsAll + pfHiggsInteractionNetTagsProbs + _pfParticleNetMassRegressionOutputs - # + pfParticleNetFromMiniAODAK8JetTagsAll) + #'pfParticleNetDiscriminatorsJetTags:TvsQCD', + #'pfParticleNetDiscriminatorsJetTags:WvsQCD', + #'pfParticleNetDiscriminatorsJetTags:H4qvsQCD', + #'pfParticleNetJetTags:probTbcq', + #'pfParticleNetJetTags:probTbqq', + #'pfParticleNetJetTags:probTbc', + #'pfParticleNetJetTags:probTbq', + #'pfParticleNetJetTags:probTbel', + #'pfParticleNetJetTags:probTbmu', + #'pfParticleNetJetTags:probTbta', + #'pfParticleNetJetTags:probWcq', + #'pfParticleNetJetTags:probWqq', + #'pfParticleNetJetTags:probHqqqq', + ) + pfParticleNetMassCorrelatedJetTagsAll + pfHiggsInteractionNetTagsProbs + pfParticleNetFromMiniAODAK8JetTagsAll) updateJetCollection( process, jetSource = cms.InputTag('slimmedJetsAK8NoDeepTags'), diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetDiscriminatorsJetTags_cfi.py b/RecoBTag/ONNXRuntime/python/pfParticleNetDiscriminatorsJetTags_cfi.py index b6a57b56cb065..d265136180efa 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNetDiscriminatorsJetTags_cfi.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetDiscriminatorsJetTags_cfi.py @@ -67,6 +67,20 @@ cms.InputTag('pfParticleNetJetTags', 'probQCDothers'), ), ), + cms.PSet( + name = cms.string('ZccvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probZcc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probZcc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDothers'), + ), + ), cms.PSet( name = cms.string('HbbvsQCD'), numerator = cms.VInputTag( diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8DiscriminatorsJetTags_cfi.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8DiscriminatorsJetTags_cfi.py index a755317a383c8..3c478acd7120e 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8DiscriminatorsJetTags_cfi.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK8DiscriminatorsJetTags_cfi.py @@ -31,12 +31,32 @@ name = cms.string('HttvsQCD'), numerator = cms.VInputTag( cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHtt'), - cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHtm'), - cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHte'), ), denominator = cms.VInputTag( cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHtt'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD2hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD1hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD0hf'), + ), + ), + cms.PSet( + name = cms.string('HtmvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHtm'), + ), + denominator = cms.VInputTag( cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHtm'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD2hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD1hf'), + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD0hf'), + ), + ), + cms.PSet( + name = cms.string('HtevsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHte'), + ), + denominator = cms.VInputTag( cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probHte'), cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD2hf'), cms.InputTag('pfParticleNetFromMiniAODAK8JetTags', 'probQCD1hf'), diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNet_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNet_cff.py index cc2b8862db615..cb007ca23fc56 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNet_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNet_cff.py @@ -136,3 +136,5 @@ _pfParticleNetJetTagsAll = _pfParticleNetJetTagsProbs + _pfParticleNetJetTagsMetaDiscrs + \ _pfMassDecorrelatedParticleNetJetTagsProbs + _pfMassDecorrelatedParticleNetJetTagsMetaDiscrs + +_pfParticleNetMassCorrelatedJetTagsAll = _pfParticleNetJetTagsProbs + _pfParticleNetJetTagsMetaDiscrs From 8903fcda762a6e24b398410e63dc17c7275daa38 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Mon, 6 Mar 2023 14:07:18 +0100 Subject: [PATCH 10/24] enable evaluation of new ParticleNet trainings in nanoAOD step --- .../NanoAOD/python/jetsAK4_CHS_cff.py | 9 ++++- .../NanoAOD/python/jetsAK4_Puppi_cff.py | 35 +++++++++++++++++++ PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 16 ++------- PhysicsTools/NanoAOD/python/nano_cff.py | 9 +++-- 4 files changed, 53 insertions(+), 16 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 4cb80962f4354..7af46d26f4667 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -330,7 +330,7 @@ ## - To be used in nanoAOD_customizeCommon() in nano_cff.py ############################################################### from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection -def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour): +def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet): _btagDiscriminators=[] if addDeepBTag: print("Updating process to run DeepCSV btag") @@ -338,6 +338,12 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour): if addDeepFlavour: print("Updating process to run DeepFlavour btag") _btagDiscriminators += ['pfDeepFlavourJetTags:probb','pfDeepFlavourJetTags:probbb','pfDeepFlavourJetTags:problepb','pfDeepFlavourJetTags:probc'] + if addParticleNet: + print("Updating process run ParticleNetAK4") + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll as pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll as pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll + _btagDiscriminators += pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll + _btagDiscriminators += pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll if len(_btagDiscriminators)==0: return process print("Will recalculate the following discriminators: "+", ".join(_btagDiscriminators)) updateJetCollection( @@ -355,6 +361,7 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour): nanoAOD_addDeepInfoAK4CHS_switch = cms.PSet( nanoAOD_addDeepBTag_switch = cms.untracked.bool(False), nanoAOD_addDeepFlavourTag_switch = cms.untracked.bool(False), + nanoAOD_addParticleNet_switch = cms.untracked.bool(False), ) ################################################ diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 9ee07d2cc1669..9aa94a4fa2bb5 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -118,6 +118,41 @@ #jets are not as precise as muons jetPuppiTable.variables.pt.precision=10 +############################################################## +## DeepInfoAK4:Start +## - To be used in nanoAOD_customizeCommon() in nano_cff.py +############################################################### +from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection +def nanoAOD_addDeepInfoAK4(process,addParticleNet): + _btagDiscriminators=[] + if addParticleNet: + print("Updating process run ParticleNetAK4") + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll as pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll as pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll + _btagDiscriminators += pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll + _btagDiscriminators += pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll + if len(_btagDiscriminators)==0: return process + print("Will recalculate the following discriminators: "+", ".join(_btagDiscriminators)) + updateJetCollection( + process, + jetSource = cms.InputTag('slimmedJets'), + jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']), 'None'), + btagDiscriminators = _btagDiscriminators, + postfix = 'WithDeepInfo', + ) + process.load("Configuration.StandardSequences.MagneticField_cff") + process.jetCorrFactorsNano.src="selectedUpdatedPatJetsWithDeepInfo" + process.updatedJets.jetSource="selectedUpdatedPatJetsWithDeepInfo" + return process + +nanoAOD_addDeepInfoAK4_switch = cms.PSet( + nanoAOD_addParticleNet_switch = cms.untracked.bool(False), +) + +################################################ +## DeepInfoAK4CHS:End +################################################# + ################################################################################ # JETS FOR MET type1 ################################################################################ diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index 9a92d66462b68..ddbfc43022a86 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -148,7 +148,7 @@ ## - To be used in nanoAOD_customizeCommon() in nano_cff.py ############################################################### from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection -def nanoAOD_addDeepInfoAK8(process, addDeepBTag, addDeepBoostedJet, addDeepDoubleX, addDeepDoubleXV2, addParticleNet, addParticleNetMass, jecPayload): +def nanoAOD_addDeepInfoAK8(process, addDeepBTag, addDeepBoostedJet, addDeepDoubleX, addDeepDoubleXV2, addParticleNet, jecPayload): _btagDiscriminators=[] if addDeepBTag: print("Updating process to run DeepCSV btag to AK8 jets") @@ -158,12 +158,8 @@ def nanoAOD_addDeepInfoAK8(process, addDeepBTag, addDeepBoostedJet, addDeepDoubl from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsAll as pfDeepBoostedJetTagsAll _btagDiscriminators += pfDeepBoostedJetTagsAll if addParticleNet: - print("Updating process to run ParticleNet before it's included in MiniAOD") - from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetJetTagsAll as pfParticleNetJetTagsAll - _btagDiscriminators += pfParticleNetJetTagsAll - if addParticleNetMass: - from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetMassRegressionOutputs - _btagDiscriminators += _pfParticleNetMassRegressionOutputs + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK8_cff import _pfParticleNetFromMiniAODAK8JetTagsAll as pfParticleNetFromMiniAODAK8JetTagsAll + _btagDiscriminators += pfParticleNetFromMiniAODAK8JetTagsAll if addDeepDoubleX: print("Updating process to run DeepDoubleX on datasets before 104X") _btagDiscriminators += ['pfDeepDoubleBvLJetTags:probHbb', \ @@ -200,15 +196,9 @@ def nanoAOD_addDeepInfoAK8(process, addDeepBTag, addDeepBoostedJet, addDeepDoubl nanoAOD_addDeepDoubleX_switch = cms.untracked.bool(False), nanoAOD_addDeepDoubleXV2_switch = cms.untracked.bool(False), nanoAOD_addParticleNet_switch = cms.untracked.bool(False), - nanoAOD_addParticleNetMass_switch = cms.untracked.bool(False), jecPayload = cms.untracked.string('AK8PFPuppi') ) -# for 106Xv2: only needs to run ParticleNet Mass regression; The rest are already in MiniAOD -run2_nanoAOD_106Xv2.toModify( - nanoAOD_addDeepInfoAK8_switch, - nanoAOD_addParticleNetMass_switch = True, -) ################################################ ## DeepInfoAK8:End ################################################# diff --git a/PhysicsTools/NanoAOD/python/nano_cff.py b/PhysicsTools/NanoAOD/python/nano_cff.py index d10ba5084fe2d..01b40bdf1b7af 100644 --- a/PhysicsTools/NanoAOD/python/nano_cff.py +++ b/PhysicsTools/NanoAOD/python/nano_cff.py @@ -154,11 +154,17 @@ def nanoAOD_activateVID(process): def nanoAOD_customizeCommon(process): process = nanoAOD_activateVID(process) + + # This function is defined in jetsAK4_Puppi_cff.py + process = nanoAOD_addDeepInfoAK4(process, + addParticleNet=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addParticleNet_switch + ) # This function is defined in jetsAK4_CHS_cff.py process = nanoAOD_addDeepInfoAK4CHS(process, addDeepBTag=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addDeepBTag_switch, - addDeepFlavour=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addDeepFlavourTag_switch + addDeepFlavour=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addDeepFlavourTag_switch, + addParticleNet=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addParticleNet_switch ) # This function is defined in jetsAK8_cff.py @@ -168,7 +174,6 @@ def nanoAOD_customizeCommon(process): addDeepDoubleX=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepDoubleX_switch, addDeepDoubleXV2=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepDoubleXV2_switch, addParticleNet=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addParticleNet_switch, - addParticleNetMass=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addParticleNetMass_switch, jecPayload=nanoAOD_addDeepInfoAK8_switch.jecPayload ) From ac075a6553261aa009a787e8eaa167fffe3ca0ba Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Mon, 6 Mar 2023 14:09:36 +0100 Subject: [PATCH 11/24] fix printouts --- PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py | 2 +- PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py | 2 +- PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 1 + 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 7af46d26f4667..090983ac2a092 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -339,7 +339,7 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet) print("Updating process to run DeepFlavour btag") _btagDiscriminators += ['pfDeepFlavourJetTags:probb','pfDeepFlavourJetTags:probbb','pfDeepFlavourJetTags:problepb','pfDeepFlavourJetTags:probc'] if addParticleNet: - print("Updating process run ParticleNetAK4") + print("Updating process to run ParticleNetAK4") from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll as pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll as pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll _btagDiscriminators += pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 9aa94a4fa2bb5..2ff5c6ef0dd9f 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -126,7 +126,7 @@ def nanoAOD_addDeepInfoAK4(process,addParticleNet): _btagDiscriminators=[] if addParticleNet: - print("Updating process run ParticleNetAK4") + print("Updating process to run ParticleNetAK4") from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll as pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll as pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll _btagDiscriminators += pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index ddbfc43022a86..a913544f933c4 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -158,6 +158,7 @@ def nanoAOD_addDeepInfoAK8(process, addDeepBTag, addDeepBoostedJet, addDeepDoubl from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsAll as pfDeepBoostedJetTagsAll _btagDiscriminators += pfDeepBoostedJetTagsAll if addParticleNet: + print("Updating process to run ParticleNet joint classification and mass regression") from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK8_cff import _pfParticleNetFromMiniAODAK8JetTagsAll as pfParticleNetFromMiniAODAK8JetTagsAll _btagDiscriminators += pfParticleNetFromMiniAODAK8JetTagsAll if addDeepDoubleX: From 3bca26d4153b4e2df1c7bf5a3e4e4231aa40a4be Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Mon, 6 Mar 2023 16:06:45 +0100 Subject: [PATCH 12/24] add PNet regression neutrino correction --- PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py | 3 ++- PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 090983ac2a092..23bde64545221 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -134,7 +134,8 @@ btagPNetCvB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="ParticleNet c vs. b"), btagPNetQvG = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:QvsG'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardDiscriminatorsJetTags:QvsG')",float,precision=10,doc="ParticleNet q (udsbc) vs. g"), btagPNetTauVJet = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:TauVsJet')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:TauVsJet'):-1",float,precision=10,doc="ParticleNet tau vs. jet"), - PNetRegPtRawCorr = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptcorr'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptcorr')",float,precision=10,doc="ParticleNet universal flavor-aware pT regression, correction relative to raw jet pT"), + PNetRegPtRawCorr = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptcorr'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptcorr')",float,precision=10,doc="ParticleNet universal flavor-aware visible pT regression (no neutrinos), correction relative to raw jet pT"), + PNetRegPtRawCorrNeutrino = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptnu'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptnu')",float,precision=10,doc="ParticleNet universal flavor-aware pT regression neutrino correction, relative to visible. To apply full regression, multiply raw jet pT by both PNetRegPtRawCorr and PNetRegPtRawCorrNeutrino."), PNetRegPtRawRes = Var("?abs(eta())<2.5?0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptreslow')):0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptreslow'))",float,precision=10,doc="ParticleNet universal flavor-aware jet pT resolution estimator, (q84 - q16)/2"), puIdDisc = Var("userFloat('puIdNanoDisc')", float,doc="Pileup ID discriminant with 106X (2018) training",precision=10), puId = Var("userInt('puIdNanoId')", "uint8", doc="Pileup ID flags with 106X (2018) training"), diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 2ff5c6ef0dd9f..255bbc290b10c 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -92,7 +92,8 @@ btagPNetCvB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="ParticleNet c vs. b"), btagPNetQvG = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:QvsG'):bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardDiscriminatorsJetTags:QvsG')",float,precision=10,doc="ParticleNet q (udsbc) vs. g"), btagPNetTauVJet = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:TauVsJet')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:TauVsJet'):-1",float,precision=10,doc="ParticleNet tau vs. jet"), - PNetRegPtRawCorr = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptcorr'):bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptcorr')",float,precision=10,doc="ParticleNet universal flavor-aware pT regression, correction relative to raw jet pT"), + PNetRegPtRawCorr = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptcorr'):bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptcorr')",float,precision=10,doc="ParticleNet universal flavor-aware visible pT regression (no neutrinos), correction relative to raw jet pT"), + PNetRegPtRawCorrNeutrino = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptnu'):bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptnu')",float,precision=10,doc="ParticleNet universal flavor-aware pT regression neutrino correction, relative to visible. To apply full regression, multiply raw jet pT by both PNetRegPtRawCorr and PNetRegPtRawCorrNeutrino."), PNetRegPtRawRes = Var("?abs(eta())<2.5?0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptreslow')):0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptreslow'))",float,precision=10,doc="ParticleNet universal flavor-aware jet pT resolution estimator, (q84 - q16)/2"), jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", "uint8",doc="Jet ID flag: bit2 is tight, bit3 is tightLepVeto"), hfsigmaEtaEta = Var("userFloat('hfsigmaEtaEta')",float,doc="sigmaEtaEta for HF jets (noise discriminating variable)",precision=10), From 57484c480c61e48172a1c1b33409e46bcf2bf508 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Tue, 7 Mar 2023 17:47:52 +0100 Subject: [PATCH 13/24] fix jet and JEC reference in nanoAOD PNet reevaluation for PUPPI --- PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 255bbc290b10c..0b0d36b89c980 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -136,8 +136,8 @@ def nanoAOD_addDeepInfoAK4(process,addParticleNet): print("Will recalculate the following discriminators: "+", ".join(_btagDiscriminators)) updateJetCollection( process, - jetSource = cms.InputTag('slimmedJets'), - jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']), 'None'), + jetSource = cms.InputTag('slimmedJetsPuppi'), + jetCorrections = ('AK4PFPuppi', cms.vstring(['L2Relative', 'L3Absolute']), 'None'), btagDiscriminators = _btagDiscriminators, postfix = 'WithDeepInfo', ) From 5e7f771eaebb5f4c0349cdee90e9400c9b14de39 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Wed, 8 Mar 2023 18:02:15 +0100 Subject: [PATCH 14/24] remove puppi weight from PNet feature evaluator and fix nano AK4 PUPPI jet config --- .../NanoAOD/python/jetsAK4_Puppi_cff.py | 2 +- .../plugins/ParticleNetFeatureEvaluator.cc | 22 ++++--------------- 2 files changed, 5 insertions(+), 19 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 0b0d36b89c980..8c62ea45a5864 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -142,7 +142,7 @@ def nanoAOD_addDeepInfoAK4(process,addParticleNet): postfix = 'WithDeepInfo', ) process.load("Configuration.StandardSequences.MagneticField_cff") - process.jetCorrFactorsNano.src="selectedUpdatedPatJetsWithDeepInfo" + process.jetPuppiCorrFactorsNano.src="selectedUpdatedPatJetsWithDeepInfo" process.updatedJets.jetSource="selectedUpdatedPatJetsWithDeepInfo" return process diff --git a/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc b/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc index d6163b2b2592b..747bb0e0dc108 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc @@ -62,8 +62,6 @@ class ParticleNetFeatureEvaluator : public edm::stream::EDProducer<> { const double max_dr_for_losttrack_; const double min_pt_for_taus_; const double max_eta_for_taus_; - const bool use_puppiP4_; - const double min_puppi_wgt_; const bool include_neutrals_; edm::EDGetTokenT muon_token_; @@ -262,8 +260,6 @@ ParticleNetFeatureEvaluator::ParticleNetFeatureEvaluator(const edm::ParameterSet max_dr_for_losttrack_(iConfig.getParameter("max_dr_for_losttrack")), min_pt_for_taus_(iConfig.getParameter("min_pt_for_taus")), max_eta_for_taus_(iConfig.getParameter("max_eta_for_taus")), - use_puppiP4_(iConfig.getParameter("use_puppiP4")), - min_puppi_wgt_(iConfig.getParameter("min_puppi_wgt")), include_neutrals_(iConfig.getParameter("include_neutrals")), muon_token_(consumes(iConfig.getParameter("muons"))), electron_token_(consumes(iConfig.getParameter("electrons"))), @@ -295,9 +291,7 @@ void ParticleNetFeatureEvaluator::fillDescriptions(edm::ConfigurationDescription desc.add("max_dr_for_losttrack", 0.4); desc.add("min_pt_for_taus", 20.); desc.add("max_eta_for_taus", 2.5); - desc.add("use_puppiP4", false); desc.add("include_neutrals", true); - desc.add("min_puppi_wgt", -1.); desc.add("vertices", edm::InputTag("offlineSlimmedPrimaryVertices")); desc.add("secondary_vertices", edm::InputTag("slimmedSecondaryVertices")); desc.add("pf_candidates", edm::InputTag("packedPFCandidates")); @@ -371,7 +365,7 @@ void ParticleNetFeatureEvaluator::produce(edm::Event &iEvent, const edm::EventSe bool fill_vars = true; if ((jet.pt() < min_jet_pt_ and dynamic_cast(&jet)->correctedJet("Uncorrected").pt() < min_jet_pt_) or - std::abs(jet.eta()) > max_jet_eta_ or std::abs(jet.eta()) < min_jet_eta_) + 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; @@ -420,8 +414,6 @@ void ParticleNetFeatureEvaluator::fillParticleFeatures(DeepBoostedJetFeatures &f const pat::PackedCandidate *cand = dynamic_cast(&(*dau)); if (not cand) throw edm::Exception(edm::errors::InvalidReference) << "Cannot convert to either pat::PackedCandidate"; - if (cand->puppiWeight() < min_puppi_wgt_) - continue; // base requirements on PF candidates if (cand->pt() < min_pt_for_pfcandidates_) continue; @@ -432,14 +424,8 @@ void ParticleNetFeatureEvaluator::fillParticleFeatures(DeepBoostedJetFeatures &f daughters.push_back(cand); } - // sort by Puppi-weighted pt - if (use_puppiP4_) - std::sort(daughters.begin(), daughters.end(), [&](const pat::PackedCandidate *a, const pat::PackedCandidate *b) { - return a->puppiWeight() * a->pt() > b->puppiWeight() * b->pt(); - }); // sort by original pt (not Puppi-weighted) - else - std::sort(daughters.begin(), daughters.end(), [](const auto &a, const auto &b) { return a->pt() > b->pt(); }); + 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_) @@ -451,8 +437,8 @@ void ParticleNetFeatureEvaluator::fillParticleFeatures(DeepBoostedJetFeatures &f continue; // input particle is a packed PF candidate - auto candP4 = use_puppiP4_ ? cand->puppiWeight() * cand->p4() : cand->p4(); - auto candP3 = use_puppiP4_ ? cand->puppiWeight() * cand->momentum() : cand->momentum(); + auto candP4 = cand->p4(); + auto candP3 = cand->momentum(); // candidate track const reco::Track *track = nullptr; From 69a2c39ba09e8c131e816f66ab87c25893a533ab Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Thu, 9 Mar 2023 10:30:49 +0100 Subject: [PATCH 15/24] fix CvsL definition --- RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc | 4 ++-- .../pfParticleNetFromMiniAODAK4DiscriminatorsJetTags_cfi.py | 2 -- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc b/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc index 747bb0e0dc108..7f820b6fe4fcf 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleNetFeatureEvaluator.cc @@ -437,8 +437,8 @@ void ParticleNetFeatureEvaluator::fillParticleFeatures(DeepBoostedJetFeatures &f continue; // input particle is a packed PF candidate - auto candP4 = cand->p4(); - auto candP3 = cand->momentum(); + auto candP4 = cand->p4(); + auto candP3 = cand->momentum(); // candidate track const reco::Track *track = nullptr; diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4DiscriminatorsJetTags_cfi.py b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4DiscriminatorsJetTags_cfi.py index 9e68cb1727c58..b09fabc5e9632 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4DiscriminatorsJetTags_cfi.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetFromMiniAODAK4DiscriminatorsJetTags_cfi.py @@ -21,7 +21,6 @@ cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probc'), ), denominator = cms.VInputTag( - cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probb'), cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probc'), cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probuds'), cms.InputTag('pfParticleNetFromMiniAODAK4PuppiCentralJetTags', 'probg'), @@ -177,7 +176,6 @@ cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probc'), ), denominator = cms.VInputTag( - cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probb'), cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probc'), cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probuds'), cms.InputTag('pfParticleNetFromMiniAODAK4CHSCentralJetTags', 'probg'), From acbdc841d730aebde87a0f4dc2659f24dbd204fc Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Thu, 9 Mar 2023 11:12:53 +0100 Subject: [PATCH 16/24] add PNet to NanoAOD DQM and change name of mass-correlated tagger nodes --- PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 18 ++++---- PhysicsTools/NanoAOD/python/nanoDQM_cfi.py | 52 +++++++++++++++------- 2 files changed, 45 insertions(+), 25 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index a913544f933c4..2a9ee5c8a49ee 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -96,15 +96,15 @@ btagDDBvLV2 = Var("bDiscriminator('pfMassIndependentDeepDoubleBvLV2JetTags:probHbb')",float,doc="DeepDoubleX V2(mass-decorrelated) discriminator for H(Z)->bb vs QCD",precision=10), btagDDCvLV2 = Var("bDiscriminator('pfMassIndependentDeepDoubleCvLV2JetTags:probHcc')",float,doc="DeepDoubleX V2 (mass-decorrelated) discriminator for H(Z)->cc vs QCD",precision=10), btagDDCvBV2 = Var("bDiscriminator('pfMassIndependentDeepDoubleCvBV2JetTags:probHcc')",float,doc="DeepDoubleX V2 (mass-decorrelated) discriminator for H(Z)->cc vs H(Z)->bb",precision=10), - particleNetMassCorr_QCD = Var("bDiscriminator('pfParticleNetJetTags:probQCDbb')+bDiscriminator('pfParticleNetJetTags:probQCDcc')+bDiscriminator('pfParticleNetJetTags:probQCDb')+bDiscriminator('pfParticleNetJetTags:probQCDc')+bDiscriminator('pfParticleNetJetTags:probQCDothers')",float,doc="ParticleNet tagger QCD(bb,cc,b,c,others) sum",precision=10), - particleNetMassCorr_TvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:TvsQCD')",float,doc="ParticleNet tagger (w/ mass) top vs QCD discriminator",precision=10), - particleNetMassCorr_WvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:WvsQCD')",float,doc="ParticleNet tagger (w/ mass) W vs QCD discriminator",precision=10), - particleNetMassCorr_ZvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZvsQCD')",float,doc="ParticleNet tagger (w/ mass) Z vs QCD discriminator",precision=10), - particleNetMassCorr_H4qvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:H4qvsQCD')",float,doc="ParticleNet tagger (w/ mass) H(->VV->qqqq) vs QCD discriminator",precision=10), - particleNetMassCorr_HbbvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HbbvsQCD')",float,doc="ParticleNet tagger (w/mass) H(->bb) vs QCD discriminator",precision=10), - particleNetMassCorr_HccvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HccvsQCD')",float,doc="ParticleNet tagger (w/mass) H(->cc) vs QCD discriminator",precision=10), - particleNetMassCorr_ZbbvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZbbvsQCD')",float,doc="ParticleNet tagger (w/mass) Z(->bb) vs QCD discriminator",precision=10), - particleNetMassCorr_ZccvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZccvsQCD')",float,doc="ParticleNet tagger (w/mass) Z(->cc) vs QCD discriminator",precision=10), + particleNetWithMass_QCD = Var("bDiscriminator('pfParticleNetJetTags:probQCDbb')+bDiscriminator('pfParticleNetJetTags:probQCDcc')+bDiscriminator('pfParticleNetJetTags:probQCDb')+bDiscriminator('pfParticleNetJetTags:probQCDc')+bDiscriminator('pfParticleNetJetTags:probQCDothers')",float,doc="ParticleNet tagger (w/ mass) QCD(bb,cc,b,c,others) sum",precision=10), + particleNetWithMass_TvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:TvsQCD')",float,doc="ParticleNet tagger (w/ mass) top vs QCD discriminator",precision=10), + particleNetWithMass_WvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:WvsQCD')",float,doc="ParticleNet tagger (w/ mass) W vs QCD discriminator",precision=10), + particleNetWithMass_ZvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZvsQCD')",float,doc="ParticleNet tagger (w/ mass) Z vs QCD discriminator",precision=10), + particleNetWithMass_H4qvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:H4qvsQCD')",float,doc="ParticleNet tagger (w/ mass) H(->VV->qqqq) vs QCD discriminator",precision=10), + particleNetWithMass_HbbvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HbbvsQCD')",float,doc="ParticleNet tagger (w/mass) H(->bb) vs QCD discriminator",precision=10), + particleNetWithMass_HccvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HccvsQCD')",float,doc="ParticleNet tagger (w/mass) H(->cc) vs QCD discriminator",precision=10), + particleNetWithMass_ZbbvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZbbvsQCD')",float,doc="ParticleNet tagger (w/mass) Z(->bb) vs QCD discriminator",precision=10), + particleNetWithMass_ZccvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZccvsQCD')",float,doc="ParticleNet tagger (w/mass) Z(->cc) vs QCD discriminator",precision=10), particleNet_QCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD2hf')+bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')+bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD0hf')",float,doc="ParticleNet tagger QCD(0+1+2HF) sum",precision=10), particleNet_QCD2HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD2hf')",float,doc="ParticleNet tagger QCD 2 HF (b/c) score",precision=10), particleNet_QCD1HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')",float,doc="ParticleNet tagger QCD 1 HF (b/c) score",precision=10), diff --git a/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py b/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py index f10a05ebe642c..38940605248f0 100644 --- a/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py +++ b/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py @@ -182,23 +182,35 @@ Plot1D('btagDDCvLV2', 'btagDDCvLV2', 20, 0, 1, 'DeepDoubleX V2 (mass-decorrelated) discriminator for H(Z)->cc vs QCD'), Plot1D('btagDDCvL_noMD', 'btagDDCvL_noMD', 20, 0, 1, 'DeepDoubleX discriminator (no mass-decorrelation) for H(Z)->cc vs QCD'), Plot1D('btagDeepB', 'btagDeepB', 20, -1, 1, 'Deep B+BB btag discriminator'), + Plot1D('particleNetWithMass_QCD', 'particleNetWithMass_QCD', 20, -1, 1, 'ParticleNet (mass-correlated) QCD score'), + Plot1D('particleNetWithMass_TvsQCD', 'particleNetWithMass_TvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) top vs. QCD score'), + Plot1D('particleNetWithMass_WvsQCD', 'particleNetWithMass_WvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) W vs. QCD score'), + Plot1D('particleNetWithMass_ZvsQCD', 'particleNetWithMass_ZvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) Z vs. QCD score'), + Plot1D('particleNetWithMass_H4qvsQCD', 'particleNetWithMass_H4qvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) H(->VV->qqqq) vs. QCD score'), + Plot1D('particleNetWithMass_HbbvsQCD', 'particleNetWithMass_HbbvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) H->bb vs. QCD score'), + Plot1D('particleNetWithMass_HccvsQCD', 'particleNetWithMass_HccvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) H->cc vs. QCD score'), + Plot1D('particleNetWithMass_ZbbvsQCD', 'particleNetWithMass_ZbbvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) Z->bb vs. QCD score'), + Plot1D('particleNetWithMass_ZccvsQCD', 'particleNetWithMass_HccvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) H->cc vs. QCD score'), + Plot1D('particleNet_QCD', 'particleNet_QCD', 20, 0, 1, 'ParticleNet QCD score'), + Plot1D('particleNet_QCD2HF', 'particleNet_QCD2HF', 20, 0, 1, 'ParticleNet QCD 2HF (b,c) score'), + Plot1D('particleNet_QCD1HF', 'particleNet_QCD1HF', 20, 0, 1, 'ParticleNet QCD 1HF (b,c) score'), + Plot1D('particleNet_QCD0HF', 'particleNet_QCD0HF', 20, 0, 1, 'ParticleNet QCD 0HF (b,c) score'), + Plot1D('particleNet_Xbb', 'particleNet_Xbb', 20, 0, 1, 'ParticleNet X->bb score'), + Plot1D('particleNet_Xcc', 'particleNet_Xcc', 20, 0, 1, 'ParticleNet X->cc score'), + Plot1D('particleNet_Xqq', 'particleNet_Xqq', 20, 0, 1, 'ParticleNet X->qq (uds) score'), + Plot1D('particleNet_Xgg', 'particleNet_Xgg', 20, 0, 1, 'ParticleNet X->gg score'), + Plot1D('particleNet_Xtt', 'particleNet_Xtt', 20, 0, 1, 'ParticleNet X->tautau score'), + Plot1D('particleNet_Xtm', 'particleNet_Xtm', 20, 0, 1, 'ParticleNet X->mutau score'), + Plot1D('particleNet_Xte', 'particleNet_Xte', 20, 0, 1, 'ParticleNet X->etau score'), + Plot1D('particleNet_massCorr', 'particleNet_massCorr', 20, 0, 2, 'ParticleNet mass regression, correction relative to jet mass'), + Plot1D('particleNet_XbbVsQCD', 'particleNet_XbbVsQCD', 20, 0, 1, 'ParticleNet X->bb vs. QCD score'), + Plot1D('particleNet_XccVsQCD', 'particleNet_XccVsQCD', 20, 0, 1, 'ParticleNet X->cc vs. QCD score'), + Plot1D('particleNet_XqqVsQCD', 'particleNet_XqqVsQCD', 20, 0, 1, 'ParticleNet X->qq (uds) vs. QCD score'), + Plot1D('particleNet_XggVsQCD', 'particleNet_XggVsQCD', 20, 0, 1, 'ParticleNet X->gg vs. QCD score'), + Plot1D('particleNet_XttVsQCD', 'particleNet_XttVsQCD', 20, 0, 1, 'ParticleNet X->tautau vs. QCD score'), + Plot1D('particleNet_XtmVsQCD', 'particleNet_XtmVsQCD', 20, 0, 1, 'ParticleNet X->mutau vs. QCD score'), + Plot1D('particleNet_XteVsQCD', 'particleNet_XteVsQCD', 20, 0, 1, 'ParticleNet X->etau vs. QCD score'), Plot1D('btagHbb', 'btagHbb', 20, -1, 1, 'Higgs to BB tagger discriminator'), - Plot1D('deepTagMD_H4qvsQCD', 'deepTagMD_H4qvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger H->4q vs QCD discriminator'), - Plot1D('deepTagMD_HbbvsQCD', 'deepTagMD_HbbvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger H->bb vs QCD discriminator'), - Plot1D('deepTagMD_TvsQCD', 'deepTagMD_TvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger top vs QCD discriminator'), - Plot1D('deepTagMD_WvsQCD', 'deepTagMD_WvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger W vs QCD discriminator'), - Plot1D('deepTagMD_ZHbbvsQCD', 'deepTagMD_ZHbbvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z/H->bb vs QCD discriminator'), - Plot1D('deepTagMD_ZHccvsQCD', 'deepTagMD_ZHccvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z/H->cc vs QCD discriminator'), - Plot1D('deepTagMD_ZbbvsQCD', 'deepTagMD_ZbbvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z->bb vs QCD discriminator'), - Plot1D('deepTagMD_ZvsQCD', 'deepTagMD_ZvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z vs QCD discriminator'), - Plot1D('deepTagMD_bbvsLight', 'deepTagMD_bbvsLight', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->bb vs light flavour discriminator'), - Plot1D('deepTagMD_ccvsLight', 'deepTagMD_ccvsLight', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->cc vs light flavour discriminator'), - Plot1D('deepTag_H', 'deepTag_H', 20, 0, 1, 'DeepBoostedJet tagger H(bb,cc,4q) sum'), - Plot1D('deepTag_QCD', 'deepTag_QCD', 20, 0, 1, 'DeepBoostedJet tagger QCD(bb,cc,b,c,others) sum'), - Plot1D('deepTag_QCDothers', 'deepTag_QCDothers', 20, 0, 1, 'DeepBoostedJet tagger QCDothers value'), - Plot1D('deepTag_TvsQCD', 'deepTag_TvsQCD', 20, 0, 1, 'DeepBoostedJet tagger top vs QCD discriminator'), - Plot1D('deepTag_WvsQCD', 'deepTag_WvsQCD', 20, 0, 1, 'DeepBoostedJet tagger W vs QCD discriminator'), - Plot1D('deepTag_ZvsQCD', 'deepTag_ZvsQCD', 20, 0, 1, 'DeepBoostedJet tagger Z vs QCD discriminator'), NoPlot('electronIdx3SJ'), Plot1D('eta', 'eta', 20, -4, 4, 'eta'), NoPlot('genJetAK8Idx'), @@ -414,6 +426,14 @@ Plot1D('btagDeepFlavQG', 'btagDeepFlavQG', 20, -1, 1, 'DeepJet g vs uds discriminator'), Plot1D('cRegCorr', 'cRegCorr', 20, 0.6, 2, 'pt correction for c-jet energy regression'), Plot1D('cRegRes', 'cRegRes', 20, 0.05, 0.4, 'res on pt corrected with c-jet regression'), + Plot1D('btagPNetB', 'btagPNetB', 20, 0, 1, 'ParticleNet b tag discriminator'), + Plot1D('btagPNetCvL', 'btagPNetCvL', 20, 0, 1, 'ParticleNet c vs. light (udsg) discriminator'), + Plot1D('btagPNetCvB', 'btagPNetCvB', 20, 0, 1, 'ParticleNet c vs. b discriminator'), + Plot1D('btagPNetQvG', 'btagPNetQvG', 20, 0, 1, 'ParticleNet quark (udsbc) vs. gluon discriminator'), + Plot1D('btagPNetTauVJet', 'btagPNetTauVJet', 20, 0, 1, 'ParticleNet tau vs. jet discriminator'), + Plot1D('PNetRegPtRawCorr', 'PNetRegPtRawCorr', 20, 0, 2, 'ParticleNet visible pT regression, correction relative to raw pT'), + Plot1D('PNetRegPtRawCorrNeutrino', 'PNetRegPtRawCorrNeutrino', 20, 0, 2, 'ParticleNet neutrino pT correction, relative to regressed visible pT'), + Plot1D('PNetRegPtRawRes', 'PNetRegPtRawRes', 20, 0, 0.5, 'ParticleNet per-jet resolution estimator: (q84 - q16)/2'), Plot1D('chEmEF', 'chEmEF', 20, 0, 1, 'charged Electromagnetic Energy Fraction'), Plot1D('chFPV0EF', 'chFPV0EF', 20, 0, 2, 'charged fromPV==0 Energy Fraction (energy excluded from CHS jets). Previously called betastar.'), Plot1D('chHEF', 'chHEF', 20, 0, 2, 'charged Hadron Energy Fraction'), From 1ecd5da77549aad482bb4c12e3fd18ea3fc8e258 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Wed, 15 Mar 2023 17:00:22 +0100 Subject: [PATCH 17/24] save decommissioned taggers for older Nano eras and infer new PNet nodes for Run-2 UL --- .../NanoAOD/python/jetsAK4_CHS_cff.py | 14 ++++- .../NanoAOD/python/jetsAK4_Puppi_cff.py | 2 +- PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 53 ++++++++++++++++--- PhysicsTools/NanoAOD/python/nano_cff.py | 12 +++++ 4 files changed, 71 insertions(+), 10 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 23bde64545221..9acfe2b28254c 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -181,6 +181,19 @@ btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10) ) +(run3_nanoAOD_122 | run3_nanoAOD_124).toModify( + # New ParticleNet trainings are not available in MiniAOD until Run3 13X + jetTable.variables, + btagPNetB = None, + btagPNetCvL = None, + btagPNetCvB = None, + btagPNetQvG = None, + btagPNetTauVJet = None, + PNetRegPtRawCorr = None, + PNetRegPtRawCorrNeutrino = None, + PNetRegPtRawRes = None +) + bjetNN = cms.EDProducer("BJetEnergyRegressionMVA", backend = cms.string("ONNX"), batch_eval = cms.bool(True), @@ -325,7 +338,6 @@ pileupJetIdNano, algos = _chsalgos_106X_UL16APV ) - ############################################################## ## DeepInfoAK4CHS:Start ## - To be used in nanoAOD_customizeCommon() in nano_cff.py diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 8c62ea45a5864..b9fa94a5d7c66 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -110,7 +110,7 @@ ) ) -from PhysicsTools.NanoAOD.nano_eras_cff import run2_nanoAOD_ANY +from PhysicsTools.NanoAOD.nano_eras_cff import run2_nanoAOD_ANY,run3_nanoAOD_122,run3_nanoAOD_124 run2_nanoAOD_ANY.toModify( jetPuppiTable.variables, btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10) diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index 2a9ee5c8a49ee..0c9b8e4e91e04 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -110,14 +110,6 @@ particleNet_QCD1HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')",float,doc="ParticleNet tagger QCD 1 HF (b/c) score",precision=10), particleNet_QCD0HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD0hf')",float,doc="ParticleNet tagger QCD 0 HF (b/c) score",precision=10), particleNet_massCorr = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:masscorr')",float,doc="ParticleNet mass regression, relative correction to JEC-corrected jet mass (no softdrop)",precision=10), - particleNet_Xbb = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHbb')",float,doc="ParticleNet tagger raw X->bb score. For X->bb vs QCD tagging, use Xbb/(Xbb+QCD)",precision=10), - particleNet_Xcc = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHcc')",float,doc="ParticleNet tagger raw X->cc score. For X->cc vs QCD tagging, use Xcc/(Xcc+QCD)",precision=10), - particleNet_Xqq = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHqq')",float,doc="ParticleNet tagger raw X->qq (uds) score. For X->qq vs QCD tagging, use Xqq/(Xqq+QCD). For W vs QCD tagging, use (Xcc+Xqq)/(Xcc+Xqq+QCD)",precision=10), - particleNet_Xgg = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHgg')",float,doc="ParticleNet tagger raw X->gg score. For X->gg vs QCD tagging, use Xgg/(Xgg+QCD)",precision=10), - particleNet_Xtt = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHtt')",float,doc="ParticleNet tagger raw X->tau_h tau_h score. For X->tau_h tau_h vs QCD tagging, use Xtt/(Xtt+QCD)",precision=10), - particleNet_Xtm = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHtm')",float,doc="ParticleNet tagger raw X-> mu tau_h score. For X->mu tau_h vs QCD tagging, use Xtm/(Xtm+QCD)",precision=10), - particleNet_Xte = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probHte')",float,doc="ParticleNet tagger raw X-> e tau_h score. For X->e tau_h vs QCD tagging, use Xte/(Xte+QCD)",precision=10), - # explicitly combine tagger vs. QCD scores, for convenience particleNet_XbbVsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HbbvsQCD')",float,doc="ParticleNet X->bb vs. QCD score: Xbb/(Xbb+QCD)",precision=10), particleNet_XccVsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HccvsQCD')",float,doc="ParticleNet X->cc vs. QCD score: Xcc/(Xcc+QCD)",precision=10), particleNet_XqqVsQCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8DiscriminatorsJetTags:HqqvsQCD')",float,doc="ParticleNet X->qq (uds) vs. QCD score: Xqq/(Xqq+QCD)",precision=10), @@ -142,6 +134,51 @@ fatJetTable.variables, btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10) ) +(run3_nanoAOD_122 | run3_nanoAOD_124).toModify( + # New ParticleNet trainings are not available in MiniAOD until Run3 13X + fatJetTable.variables, + particleNet_QCD = None, + particleNet_QCD2HF = None, + particleNet_QCD1HF = None, + particleNet_QCD0HF = None, + particleNet_massCorr = None, + particleNet_XbbVsQCD = None, + particleNet_XccVsQCD = None, + particleNet_XqqVsQCD = None, + particleNet_XggVsQCD = None, + particleNet_XttVsQCD = None, + particleNet_XtmVsQCD = None, + particleNet_XteVsQCD = None, +) + +(run2_nanoAOD_106Xv2 | run3_nanoAOD_122 | run3_nanoAOD_124).toModify( + fatJetTable.variables, + + # Restore taggers that were decommisionned for Run-3 + deepTag_TvsQCD = Var("bDiscriminator('pfDeepBoostedDiscriminatorsJetTags:TvsQCD')",float,doc="DeepBoostedJet tagger top vs QCD discriminator",precision=10), + deepTag_WvsQCD = Var("bDiscriminator('pfDeepBoostedDiscriminatorsJetTags:WvsQCD')",float,doc="DeepBoostedJet tagger W vs QCD discriminator",precision=10), + deepTag_ZvsQCD = Var("bDiscriminator('pfDeepBoostedDiscriminatorsJetTags:ZvsQCD')",float,doc="DeepBoostedJet tagger Z vs QCD discriminator",precision=10), + deepTag_H = Var("bDiscriminator('pfDeepBoostedJetTags:probHbb')+bDiscriminator('pfDeepBoostedJetTags:probHcc')+bDiscriminator('pfDeepBoostedJetTags:probHqqqq')",float,doc="DeepBoostedJet tagger H(bb,cc,4q) sum",precision=10), + deepTag_QCD = Var("bDiscriminator('pfDeepBoostedJetTags:probQCDbb')+bDiscriminator('pfDeepBoostedJetTags:probQCDcc')+bDiscriminator('pfDeepBoostedJetTags:probQCDb')+bDiscriminator('pfDeepBoostedJetTags:probQCDc')+bDiscriminator('pfDeepBoostedJetTags:probQCDothers')",float,doc="DeepBoostedJet tagger QCD(bb,cc,b,c,others) sum",precision=10), + deepTag_QCDothers = Var("bDiscriminator('pfDeepBoostedJetTags:probQCDothers')",float,doc="DeepBoostedJet tagger QCDothers value",precision=10), + deepTagMD_TvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:TvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger top vs QCD discriminator",precision=10), + deepTagMD_WvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:WvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger W vs QCD discriminator",precision=10), + deepTagMD_ZvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ZvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z vs QCD discriminator",precision=10), + deepTagMD_ZHbbvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ZHbbvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H->bb vs QCD discriminator",precision=10), + deepTagMD_ZbbvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ZbbvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z->bb vs QCD discriminator",precision=10), + deepTagMD_HbbvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:HbbvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger H->bb vs QCD discriminator",precision=10), + deepTagMD_ZHccvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ZHccvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H->cc vs QCD discriminator",precision=10), + deepTagMD_H4qvsQCD = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:H4qvsQCD')",float,doc="Mass-decorrelated DeepBoostedJet tagger H->4q vs QCD discriminator",precision=10), + deepTagMD_bbvsLight = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:bbvsLight')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->bb vs light flavour discriminator",precision=10), + deepTagMD_ccvsLight = Var("bDiscriminator('pfMassDecorrelatedDeepBoostedDiscriminatorsJetTags:ccvsLight')",float,doc="Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->cc vs light flavour discriminator",precision=10), + particleNetLegacy_mass = Var("bDiscriminator('pfParticleNetMassRegressionJetTags:mass')",float,doc="ParticleNet Legacy Run-2 mass regression",precision=10), + particleNetLegacy_Xbb = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probXbb')",float,doc="Mass-decorrelated ParticleNet Legacy Run-2 tagger raw X->bb score. For X->bb vs QCD tagging, use Xbb/(Xbb+QCD)",precision=10), + particleNetLegacy_Xcc = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probXcc')",float,doc="Mass-decorrelated ParticleNet Legacy Run-2 tagger raw X->cc score. For X->cc vs QCD tagging, use Xcc/(Xcc+QCD)",precision=10), + particleNetLegacy_Xqq = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probXqq')",float,doc="Mass-decorrelated ParticleNet Legacy Run-2 tagger raw X->qq (uds) score. For X->qq vs QCD tagging, use Xqq/(Xqq+QCD). For W vs QCD tagging, use (Xcc+Xqq)/(Xcc+Xqq+QCD)",precision=10), + particleNetLegacy_QCD = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDbb')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDcc')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDb')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDc')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDothers')",float,doc="Mass-decorrelated ParticleNet Legacy Run-2 tagger raw QCD score",precision=10), + + +) ############################################################## ## DeepInfoAK8:Start diff --git a/PhysicsTools/NanoAOD/python/nano_cff.py b/PhysicsTools/NanoAOD/python/nano_cff.py index 01b40bdf1b7af..3a6ffa17fb1aa 100644 --- a/PhysicsTools/NanoAOD/python/nano_cff.py +++ b/PhysicsTools/NanoAOD/python/nano_cff.py @@ -155,6 +155,17 @@ def nanoAOD_customizeCommon(process): process = nanoAOD_activateVID(process) + # Include new ParticleNet trainings for Run-2 UL + run2_nanoAOD_106Xv2.toModify( + nanoAOD_addDeepInfoAK4CHS_switch, nanoAOD_addParticleNet_switch=True, + ) + run2_nanoAOD_106Xv2.toModify( + nanoAOD_addDeepInfoAK4_switch, nanoAOD_addParticleNet_switch=True, + ) + run2_nanoAOD_106Xv2.toModify( + nanoAOD_addDeepInfoAK8_switch, nanoAOD_addParticleNet_switch=True + ) + # This function is defined in jetsAK4_Puppi_cff.py process = nanoAOD_addDeepInfoAK4(process, addParticleNet=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addParticleNet_switch @@ -177,6 +188,7 @@ def nanoAOD_customizeCommon(process): jecPayload=nanoAOD_addDeepInfoAK8_switch.jecPayload ) + nanoAOD_tau_switch = cms.PSet( idsToAdd = cms.vstring() ) From 71d3b02b69a650bfe8395c2cc4c368013a2678b3 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Wed, 15 Mar 2023 17:03:12 +0100 Subject: [PATCH 18/24] also remove new PNet AK4 nodes for PUPPI jets eras 12_2/4 --- PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index b9fa94a5d7c66..c4834f088113b 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -116,6 +116,19 @@ btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10) ) +(run3_nanoAOD_122 | run3_nanoAOD_124).toModify( + # New ParticleNet trainings are not available in MiniAOD until Run3 13X + jetPuppiTable.variables, + btagPNetB = None, + btagPNetCvL = None, + btagPNetCvB = None, + btagPNetQvG = None, + btagPNetTauVJet = None, + PNetRegPtRawCorr = None, + PNetRegPtRawCorrNeutrino = None, + PNetRegPtRawRes = None +) + #jets are not as precise as muons jetPuppiTable.variables.pt.precision=10 From 4ceeb26b42de073d49fc70ebbd0f63cba6b34ef0 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Wed, 15 Mar 2023 17:07:38 +0100 Subject: [PATCH 19/24] remove extra space --- PhysicsTools/NanoAOD/python/nano_cff.py | 1 - 1 file changed, 1 deletion(-) diff --git a/PhysicsTools/NanoAOD/python/nano_cff.py b/PhysicsTools/NanoAOD/python/nano_cff.py index 3a6ffa17fb1aa..328ec10831de7 100644 --- a/PhysicsTools/NanoAOD/python/nano_cff.py +++ b/PhysicsTools/NanoAOD/python/nano_cff.py @@ -188,7 +188,6 @@ def nanoAOD_customizeCommon(process): jecPayload=nanoAOD_addDeepInfoAK8_switch.jecPayload ) - nanoAOD_tau_switch = cms.PSet( idsToAdd = cms.vstring() ) From 525aadc59fcf231ea004c75a2b2569fe0b343438 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Fri, 17 Mar 2023 11:13:33 +0100 Subject: [PATCH 20/24] update DQM plots --- .../NanoAOD/python/jetsAK4_CHS_cff.py | 9 ++++- .../NanoAOD/python/jetsAK4_Puppi_cff.py | 11 ++++-- PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 15 +++++++- PhysicsTools/NanoAOD/python/nanoDQM_cff.py | 34 +++++++++++++++++++ PhysicsTools/NanoAOD/python/nano_cff.py | 12 +------ 5 files changed, 66 insertions(+), 15 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 9acfe2b28254c..2d4113339fa7a 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -374,7 +374,14 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet) nanoAOD_addDeepInfoAK4CHS_switch = cms.PSet( nanoAOD_addDeepBTag_switch = cms.untracked.bool(False), nanoAOD_addDeepFlavourTag_switch = cms.untracked.bool(False), - nanoAOD_addParticleNet_switch = cms.untracked.bool(False), + nanoAOD_addParticleNet_switch = cms.untracked.bool(False) +) + +# Add new ParticleNet nodes to 106Xv2 MINIAOD +# (b/c tagging, q vs. g, flavor-aware jet pT regression, tau ID + reco.) +run2_nanoAOD_106Xv2.toModify( + nanoAOD_addDeepInfoAK4CHS_switch, + nanoAOD_addParticleNet_switch = True ) ################################################ diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index c4834f088113b..fc1f244e407a0 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -1,6 +1,7 @@ import FWCore.ParameterSet.Config as cms from PhysicsTools.NanoAOD.common_cff import * +from PhysicsTools.NanoAOD.nano_eras_cff import * from PhysicsTools.NanoAOD.simpleCandidateFlatTableProducer_cfi import simpleCandidateFlatTableProducer ##################### User floats producers, selectors ########################## @@ -110,7 +111,6 @@ ) ) -from PhysicsTools.NanoAOD.nano_eras_cff import run2_nanoAOD_ANY,run3_nanoAOD_122,run3_nanoAOD_124 run2_nanoAOD_ANY.toModify( jetPuppiTable.variables, btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10) @@ -160,7 +160,14 @@ def nanoAOD_addDeepInfoAK4(process,addParticleNet): return process nanoAOD_addDeepInfoAK4_switch = cms.PSet( - nanoAOD_addParticleNet_switch = cms.untracked.bool(False), + nanoAOD_addParticleNet_switch = cms.untracked.bool(False) +) + +# Add new ParticleNet nodes to 106Xv2 MINIAOD +# (b/c tagging, q vs. g, flavor-aware jet pT regression, tau ID + reco.) +run2_nanoAOD_106Xv2.toModify( + nanoAOD_addDeepInfoAK4_switch, + nanoAOD_addParticleNet_switch = True ) ################################################ diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index 0c9b8e4e91e04..1853578af98f3 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -185,7 +185,7 @@ ## - To be used in nanoAOD_customizeCommon() in nano_cff.py ############################################################### from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection -def nanoAOD_addDeepInfoAK8(process, addDeepBTag, addDeepBoostedJet, addDeepDoubleX, addDeepDoubleXV2, addParticleNet, jecPayload): +def nanoAOD_addDeepInfoAK8(process, addDeepBTag, addDeepBoostedJet, addDeepDoubleX, addDeepDoubleXV2, addParticleNetMassLegacy, addParticleNet, jecPayload): _btagDiscriminators=[] if addDeepBTag: print("Updating process to run DeepCSV btag to AK8 jets") @@ -198,6 +198,9 @@ def nanoAOD_addDeepInfoAK8(process, addDeepBTag, addDeepBoostedJet, addDeepDoubl print("Updating process to run ParticleNet joint classification and mass regression") from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK8_cff import _pfParticleNetFromMiniAODAK8JetTagsAll as pfParticleNetFromMiniAODAK8JetTagsAll _btagDiscriminators += pfParticleNetFromMiniAODAK8JetTagsAll + if addParticleNetMassLegacy: + from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetMassRegressionOutputs + _btagDiscriminators += _pfParticleNetMassRegressionOutputs if addDeepDoubleX: print("Updating process to run DeepDoubleX on datasets before 104X") _btagDiscriminators += ['pfDeepDoubleBvLJetTags:probHbb', \ @@ -234,9 +237,19 @@ def nanoAOD_addDeepInfoAK8(process, addDeepBTag, addDeepBoostedJet, addDeepDoubl nanoAOD_addDeepDoubleX_switch = cms.untracked.bool(False), nanoAOD_addDeepDoubleXV2_switch = cms.untracked.bool(False), nanoAOD_addParticleNet_switch = cms.untracked.bool(False), + nanoAOD_addParticleNetMassLegacy_switch = cms.untracked.bool(False), jecPayload = cms.untracked.string('AK8PFPuppi') ) + +# ParticleNet legacy jet tagger is already in 106Xv2 MINIAOD, +# add PartlceNet legacy mass regression and new combined tagger + mass regression +run2_nanoAOD_106Xv2.toModify( + nanoAOD_addDeepInfoAK8_switch, + nanoAOD_addParticleNet_switch = True, + nanoAOD_addParticleNetMassLegacy_switch = True +) + ################################################ ## DeepInfoAK8:End ################################################# diff --git a/PhysicsTools/NanoAOD/python/nanoDQM_cff.py b/PhysicsTools/NanoAOD/python/nanoDQM_cff.py index 64bb86ad31a22..fe67de257cc02 100644 --- a/PhysicsTools/NanoAOD/python/nanoDQM_cff.py +++ b/PhysicsTools/NanoAOD/python/nanoDQM_cff.py @@ -62,8 +62,29 @@ def _match(name): _FatJet_Run2_plots.append(plot) _FatJet_Run2_plots.extend([ Plot1D('btagCSVV2', 'btagCSVV2', 20, -1, 1, ' pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)'), + Plot1D('deepTagMD_H4qvsQCD', 'deepTagMD_H4qvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger H->4q vs QCD discriminator'), + Plot1D('deepTagMD_HbbvsQCD', 'deepTagMD_HbbvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger H->bb vs QCD discriminator'), + Plot1D('deepTagMD_TvsQCD', 'deepTagMD_TvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger top vs QCD discriminator'), + Plot1D('deepTagMD_WvsQCD', 'deepTagMD_WvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger W vs QCD discriminator'), + Plot1D('deepTagMD_ZHbbvsQCD', 'deepTagMD_ZHbbvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z/H->bb vs QCD discriminator'), + Plot1D('deepTagMD_ZHccvsQCD', 'deepTagMD_ZHccvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z/H->cc vs QCD discriminator'), + Plot1D('deepTagMD_ZbbvsQCD', 'deepTagMD_ZbbvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z->bb vs QCD discriminator'), + Plot1D('deepTagMD_ZvsQCD', 'deepTagMD_ZvsQCD', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z vs QCD discriminator'), + Plot1D('deepTagMD_bbvsLight', 'deepTagMD_bbvsLight', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->bb vs light flavour discriminator'), + Plot1D('deepTagMD_ccvsLight', 'deepTagMD_ccvsLight', 20, 0, 1, 'Mass-decorrelated DeepBoostedJet tagger Z/H/gluon->cc vs light flavour discriminator'), + Plot1D('deepTag_H', 'deepTag_H', 20, 0, 1, 'DeepBoostedJet tagger H(bb,cc,4q) sum'), + Plot1D('deepTag_QCD', 'deepTag_QCD', 20, 0, 1, 'DeepBoostedJet tagger QCD(bb,cc,b,c,others) sum'), + Plot1D('deepTag_QCDothers', 'deepTag_QCDothers', 20, 0, 1, 'DeepBoostedJet tagger QCDothers value'), + Plot1D('deepTag_TvsQCD', 'deepTag_TvsQCD', 20, 0, 1, 'DeepBoostedJet tagger top vs QCD discriminator'), + Plot1D('deepTag_WvsQCD', 'deepTag_WvsQCD', 20, 0, 1, 'DeepBoostedJet tagger W vs QCD discriminator'), + Plot1D('deepTag_ZvsQCD', 'deepTag_ZvsQCD', 20, 0, 1, 'DeepBoostedJet tagger Z vs QCD discriminator'), ]) +_FatJet_EarlyRun3_plots = cms.VPSet() +for plot in _FatJet_Run2_plots: + if 'particleNet_' not in plot.name.value() and 'btagCSVV2' not in plot.name.value(): + _FatJet_EarlyRun3_plots.append(plot) + _Jet_Run2_plots = cms.VPSet() for plot in nanoDQM.vplots.Jet.plots: _Jet_Run2_plots.append(plot) @@ -71,6 +92,11 @@ def _match(name): Plot1D('btagCSVV2', 'btagCSVV2', 20, -1, 1, ' pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)'), ]) +_Jet_EarlyRun3_plots = cms.VPSet() +for plot in nanoDQM.vplots.Jet.plots: + if 'PNet' not in plot.name.value(): + _Jet_EarlyRun3_plots.append(plot) + _SubJet_Run2_plots = cms.VPSet() for plot in nanoDQM.vplots.SubJet.plots: _SubJet_Run2_plots.append(plot) @@ -89,6 +115,14 @@ def _match(name): plots = _SubJet_Run2_plots ) +(run3_nanoAOD_122 | run3_nanoAOD_124).toModify( + nanoDQM.vplots.FatJet, + plots = _FatJet_EarlyRun3_plots +).toModify( + nanoDQM.vplots.Jet, + plots = _Jet_EarlyRun3_plots +) + ## MC nanoDQMMC = nanoDQM.clone() nanoDQMMC.vplots.Electron.sels.Prompt = cms.string("genPartFlav == 1") diff --git a/PhysicsTools/NanoAOD/python/nano_cff.py b/PhysicsTools/NanoAOD/python/nano_cff.py index 328ec10831de7..3d17aba920cc4 100644 --- a/PhysicsTools/NanoAOD/python/nano_cff.py +++ b/PhysicsTools/NanoAOD/python/nano_cff.py @@ -154,17 +154,6 @@ def nanoAOD_activateVID(process): def nanoAOD_customizeCommon(process): process = nanoAOD_activateVID(process) - - # Include new ParticleNet trainings for Run-2 UL - run2_nanoAOD_106Xv2.toModify( - nanoAOD_addDeepInfoAK4CHS_switch, nanoAOD_addParticleNet_switch=True, - ) - run2_nanoAOD_106Xv2.toModify( - nanoAOD_addDeepInfoAK4_switch, nanoAOD_addParticleNet_switch=True, - ) - run2_nanoAOD_106Xv2.toModify( - nanoAOD_addDeepInfoAK8_switch, nanoAOD_addParticleNet_switch=True - ) # This function is defined in jetsAK4_Puppi_cff.py process = nanoAOD_addDeepInfoAK4(process, @@ -184,6 +173,7 @@ def nanoAOD_customizeCommon(process): addDeepBoostedJet=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepBoostedJet_switch, addDeepDoubleX=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepDoubleX_switch, addDeepDoubleXV2=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepDoubleXV2_switch, + addParticleNetMassLegacy=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addParticleNetMassLegacy_switch, addParticleNet=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addParticleNet_switch, jecPayload=nanoAOD_addDeepInfoAK8_switch.jecPayload ) From 61e61f4890315bfac6f28af28a97534282985279 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Fri, 17 Mar 2023 11:33:12 +0100 Subject: [PATCH 21/24] don't run PNet AK4 on PUPPI for Run-2 --- PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py | 7 ------- PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py | 7 ------- PhysicsTools/NanoAOD/python/nano_cff.py | 4 ++++ 3 files changed, 4 insertions(+), 14 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 2d4113339fa7a..68b1d3676daff 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -377,13 +377,6 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet) nanoAOD_addParticleNet_switch = cms.untracked.bool(False) ) -# Add new ParticleNet nodes to 106Xv2 MINIAOD -# (b/c tagging, q vs. g, flavor-aware jet pT regression, tau ID + reco.) -run2_nanoAOD_106Xv2.toModify( - nanoAOD_addDeepInfoAK4CHS_switch, - nanoAOD_addParticleNet_switch = True -) - ################################################ ## DeepInfoAK4CHS:End ################################################# diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index fc1f244e407a0..807cfa6aacd1f 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -163,13 +163,6 @@ def nanoAOD_addDeepInfoAK4(process,addParticleNet): nanoAOD_addParticleNet_switch = cms.untracked.bool(False) ) -# Add new ParticleNet nodes to 106Xv2 MINIAOD -# (b/c tagging, q vs. g, flavor-aware jet pT regression, tau ID + reco.) -run2_nanoAOD_106Xv2.toModify( - nanoAOD_addDeepInfoAK4_switch, - nanoAOD_addParticleNet_switch = True -) - ################################################ ## DeepInfoAK4CHS:End ################################################# diff --git a/PhysicsTools/NanoAOD/python/nano_cff.py b/PhysicsTools/NanoAOD/python/nano_cff.py index 3d17aba920cc4..1cdb74086e498 100644 --- a/PhysicsTools/NanoAOD/python/nano_cff.py +++ b/PhysicsTools/NanoAOD/python/nano_cff.py @@ -155,6 +155,10 @@ def nanoAOD_customizeCommon(process): process = nanoAOD_activateVID(process) + run2_nanoAOD_106Xv2.toModify( + nanoAOD_addDeepInfoAK4CHS_switch, nanoAOD_addParticleNet_switch=True, + ) + # This function is defined in jetsAK4_Puppi_cff.py process = nanoAOD_addDeepInfoAK4(process, addParticleNet=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addParticleNet_switch From 0075526aede3b6c9bdbaaecc2ee8f0a72e2cbac5 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Thu, 23 Mar 2023 10:12:47 +0100 Subject: [PATCH 22/24] fix DQM variables with ParticleNet --- PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 3 +-- PhysicsTools/NanoAOD/python/nanoDQM_cff.py | 5 +++++ PhysicsTools/NanoAOD/python/nanoDQM_cfi.py | 21 ++++++--------------- 3 files changed, 12 insertions(+), 17 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index 1853578af98f3..35c184234074b 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -103,8 +103,7 @@ particleNetWithMass_H4qvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:H4qvsQCD')",float,doc="ParticleNet tagger (w/ mass) H(->VV->qqqq) vs QCD discriminator",precision=10), particleNetWithMass_HbbvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HbbvsQCD')",float,doc="ParticleNet tagger (w/mass) H(->bb) vs QCD discriminator",precision=10), particleNetWithMass_HccvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HccvsQCD')",float,doc="ParticleNet tagger (w/mass) H(->cc) vs QCD discriminator",precision=10), - particleNetWithMass_ZbbvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZbbvsQCD')",float,doc="ParticleNet tagger (w/mass) Z(->bb) vs QCD discriminator",precision=10), - particleNetWithMass_ZccvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZccvsQCD')",float,doc="ParticleNet tagger (w/mass) Z(->cc) vs QCD discriminator",precision=10), + particleNetWithMass_ZvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZvsQCD')",float,doc="ParticleNet tagger (w/mass) Z vs QCD discriminator",precision=10), particleNet_QCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD2hf')+bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')+bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD0hf')",float,doc="ParticleNet tagger QCD(0+1+2HF) sum",precision=10), particleNet_QCD2HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD2hf')",float,doc="ParticleNet tagger QCD 2 HF (b/c) score",precision=10), particleNet_QCD1HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')",float,doc="ParticleNet tagger QCD 1 HF (b/c) score",precision=10), diff --git a/PhysicsTools/NanoAOD/python/nanoDQM_cff.py b/PhysicsTools/NanoAOD/python/nanoDQM_cff.py index fe67de257cc02..7926271dbd2a2 100644 --- a/PhysicsTools/NanoAOD/python/nanoDQM_cff.py +++ b/PhysicsTools/NanoAOD/python/nanoDQM_cff.py @@ -78,6 +78,11 @@ def _match(name): Plot1D('deepTag_TvsQCD', 'deepTag_TvsQCD', 20, 0, 1, 'DeepBoostedJet tagger top vs QCD discriminator'), Plot1D('deepTag_WvsQCD', 'deepTag_WvsQCD', 20, 0, 1, 'DeepBoostedJet tagger W vs QCD discriminator'), Plot1D('deepTag_ZvsQCD', 'deepTag_ZvsQCD', 20, 0, 1, 'DeepBoostedJet tagger Z vs QCD discriminator'), + Plot1D('particleNetLegacy_mass', 'particleNetLegacy_mass', 25, 0, 250, 'ParticleNet Legacy Run-2 mass regression') + Plot1D('particleNetLegacy_Xbb', 'particleNetLegacy_Xbb', 20, 0, 1, 'ParticleNet Legacy Run-2 X->bb score') + Plot1D('particleNetLegacy_Xcc', 'particleNetLegacy_Xcc', 20, 0, 1, 'ParticleNet Legacy Run-2 X->cc score') + Plot1D('particleNetLegacy_Xqq', 'particleNetLegacy_Xqq', 20, 0, 1, 'ParticleNet Legacy Run-2 X->qq (uds) score') + Plot1D('particleNetLegacy_QCD', 'particleNetLegacy_QCD', 20, 0, 1, 'ParticleNet Legacy Run-2 QCD score') ]) _FatJet_EarlyRun3_plots = cms.VPSet() diff --git a/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py b/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py index 38940605248f0..5db1e8d15877b 100644 --- a/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py +++ b/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py @@ -183,25 +183,16 @@ Plot1D('btagDDCvL_noMD', 'btagDDCvL_noMD', 20, 0, 1, 'DeepDoubleX discriminator (no mass-decorrelation) for H(Z)->cc vs QCD'), Plot1D('btagDeepB', 'btagDeepB', 20, -1, 1, 'Deep B+BB btag discriminator'), Plot1D('particleNetWithMass_QCD', 'particleNetWithMass_QCD', 20, -1, 1, 'ParticleNet (mass-correlated) QCD score'), - Plot1D('particleNetWithMass_TvsQCD', 'particleNetWithMass_TvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) top vs. QCD score'), - Plot1D('particleNetWithMass_WvsQCD', 'particleNetWithMass_WvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) W vs. QCD score'), - Plot1D('particleNetWithMass_ZvsQCD', 'particleNetWithMass_ZvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) Z vs. QCD score'), - Plot1D('particleNetWithMass_H4qvsQCD', 'particleNetWithMass_H4qvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) H(->VV->qqqq) vs. QCD score'), - Plot1D('particleNetWithMass_HbbvsQCD', 'particleNetWithMass_HbbvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) H->bb vs. QCD score'), - Plot1D('particleNetWithMass_HccvsQCD', 'particleNetWithMass_HccvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) H->cc vs. QCD score'), - Plot1D('particleNetWithMass_ZbbvsQCD', 'particleNetWithMass_ZbbvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) Z->bb vs. QCD score'), - Plot1D('particleNetWithMass_ZccvsQCD', 'particleNetWithMass_HccvsQCD', 20, -1, 1, 'ParticleNet (mass-correlated) H->cc vs. QCD score'), + Plot1D('particleNetWithMass_TvsQCD', 'particleNetWithMass_TvsQCD', 20, 0, 1, 'ParticleNet (mass-correlated) top vs. QCD score'), + Plot1D('particleNetWithMass_WvsQCD', 'particleNetWithMass_WvsQCD', 20, 0, 1, 'ParticleNet (mass-correlated) W vs. QCD score'), + Plot1D('particleNetWithMass_ZvsQCD', 'particleNetWithMass_ZvsQCD', 20, 0, 1, 'ParticleNet (mass-correlated) Z vs. QCD score'), + Plot1D('particleNetWithMass_H4qvsQCD', 'particleNetWithMass_H4qvsQCD', 20, 0, 1, 'ParticleNet (mass-correlated) H(->VV->qqqq) vs. QCD score'), + Plot1D('particleNetWithMass_HbbvsQCD', 'particleNetWithMass_HbbvsQCD', 20, 0, 1, 'ParticleNet (mass-correlated) H->bb vs. QCD score'), + Plot1D('particleNetWithMass_HccvsQCD', 'particleNetWithMass_HccvsQCD', 20, 0, 1, 'ParticleNet (mass-correlated) H->cc vs. QCD score'), Plot1D('particleNet_QCD', 'particleNet_QCD', 20, 0, 1, 'ParticleNet QCD score'), Plot1D('particleNet_QCD2HF', 'particleNet_QCD2HF', 20, 0, 1, 'ParticleNet QCD 2HF (b,c) score'), Plot1D('particleNet_QCD1HF', 'particleNet_QCD1HF', 20, 0, 1, 'ParticleNet QCD 1HF (b,c) score'), Plot1D('particleNet_QCD0HF', 'particleNet_QCD0HF', 20, 0, 1, 'ParticleNet QCD 0HF (b,c) score'), - Plot1D('particleNet_Xbb', 'particleNet_Xbb', 20, 0, 1, 'ParticleNet X->bb score'), - Plot1D('particleNet_Xcc', 'particleNet_Xcc', 20, 0, 1, 'ParticleNet X->cc score'), - Plot1D('particleNet_Xqq', 'particleNet_Xqq', 20, 0, 1, 'ParticleNet X->qq (uds) score'), - Plot1D('particleNet_Xgg', 'particleNet_Xgg', 20, 0, 1, 'ParticleNet X->gg score'), - Plot1D('particleNet_Xtt', 'particleNet_Xtt', 20, 0, 1, 'ParticleNet X->tautau score'), - Plot1D('particleNet_Xtm', 'particleNet_Xtm', 20, 0, 1, 'ParticleNet X->mutau score'), - Plot1D('particleNet_Xte', 'particleNet_Xte', 20, 0, 1, 'ParticleNet X->etau score'), Plot1D('particleNet_massCorr', 'particleNet_massCorr', 20, 0, 2, 'ParticleNet mass regression, correction relative to jet mass'), Plot1D('particleNet_XbbVsQCD', 'particleNet_XbbVsQCD', 20, 0, 1, 'ParticleNet X->bb vs. QCD score'), Plot1D('particleNet_XccVsQCD', 'particleNet_XccVsQCD', 20, 0, 1, 'ParticleNet X->cc vs. QCD score'), From d524a88a8c734e06352c5448df3326d11a18cd4e Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Thu, 23 Mar 2023 10:14:24 +0100 Subject: [PATCH 23/24] remove duplicate variable --- PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 1 - 1 file changed, 1 deletion(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index 35c184234074b..5bb039b16a037 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -103,7 +103,6 @@ particleNetWithMass_H4qvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:H4qvsQCD')",float,doc="ParticleNet tagger (w/ mass) H(->VV->qqqq) vs QCD discriminator",precision=10), particleNetWithMass_HbbvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HbbvsQCD')",float,doc="ParticleNet tagger (w/mass) H(->bb) vs QCD discriminator",precision=10), particleNetWithMass_HccvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:HccvsQCD')",float,doc="ParticleNet tagger (w/mass) H(->cc) vs QCD discriminator",precision=10), - particleNetWithMass_ZvsQCD = Var("bDiscriminator('pfParticleNetDiscriminatorsJetTags:ZvsQCD')",float,doc="ParticleNet tagger (w/mass) Z vs QCD discriminator",precision=10), particleNet_QCD = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD2hf')+bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')+bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD0hf')",float,doc="ParticleNet tagger QCD(0+1+2HF) sum",precision=10), particleNet_QCD2HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD2hf')",float,doc="ParticleNet tagger QCD 2 HF (b/c) score",precision=10), particleNet_QCD1HF = Var("bDiscriminator('pfParticleNetFromMiniAODAK8JetTags:probQCD1hf')",float,doc="ParticleNet tagger QCD 1 HF (b/c) score",precision=10), From 3c15acd4466d740efc955782a50dd2aebcf45604 Mon Sep 17 00:00:00 2001 From: Stephane Cooperstein Date: Thu, 23 Mar 2023 11:43:21 +0100 Subject: [PATCH 24/24] add missing commas --- PhysicsTools/NanoAOD/python/nanoDQM_cff.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/nanoDQM_cff.py b/PhysicsTools/NanoAOD/python/nanoDQM_cff.py index 7926271dbd2a2..07d91111000af 100644 --- a/PhysicsTools/NanoAOD/python/nanoDQM_cff.py +++ b/PhysicsTools/NanoAOD/python/nanoDQM_cff.py @@ -78,11 +78,11 @@ def _match(name): Plot1D('deepTag_TvsQCD', 'deepTag_TvsQCD', 20, 0, 1, 'DeepBoostedJet tagger top vs QCD discriminator'), Plot1D('deepTag_WvsQCD', 'deepTag_WvsQCD', 20, 0, 1, 'DeepBoostedJet tagger W vs QCD discriminator'), Plot1D('deepTag_ZvsQCD', 'deepTag_ZvsQCD', 20, 0, 1, 'DeepBoostedJet tagger Z vs QCD discriminator'), - Plot1D('particleNetLegacy_mass', 'particleNetLegacy_mass', 25, 0, 250, 'ParticleNet Legacy Run-2 mass regression') - Plot1D('particleNetLegacy_Xbb', 'particleNetLegacy_Xbb', 20, 0, 1, 'ParticleNet Legacy Run-2 X->bb score') - Plot1D('particleNetLegacy_Xcc', 'particleNetLegacy_Xcc', 20, 0, 1, 'ParticleNet Legacy Run-2 X->cc score') - Plot1D('particleNetLegacy_Xqq', 'particleNetLegacy_Xqq', 20, 0, 1, 'ParticleNet Legacy Run-2 X->qq (uds) score') - Plot1D('particleNetLegacy_QCD', 'particleNetLegacy_QCD', 20, 0, 1, 'ParticleNet Legacy Run-2 QCD score') + Plot1D('particleNetLegacy_mass', 'particleNetLegacy_mass', 25, 0, 250, 'ParticleNet Legacy Run-2 mass regression'), + Plot1D('particleNetLegacy_Xbb', 'particleNetLegacy_Xbb', 20, 0, 1, 'ParticleNet Legacy Run-2 X->bb score'), + Plot1D('particleNetLegacy_Xcc', 'particleNetLegacy_Xcc', 20, 0, 1, 'ParticleNet Legacy Run-2 X->cc score'), + Plot1D('particleNetLegacy_Xqq', 'particleNetLegacy_Xqq', 20, 0, 1, 'ParticleNet Legacy Run-2 X->qq (uds) score'), + Plot1D('particleNetLegacy_QCD', 'particleNetLegacy_QCD', 20, 0, 1, 'ParticleNet Legacy Run-2 QCD score'), ]) _FatJet_EarlyRun3_plots = cms.VPSet()