diff --git a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py index 90535a86c5d5b..71f4bec0cdc71 100644 --- a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py +++ b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py @@ -45,6 +45,8 @@ , 'pfDeepDoubleXTagInfos' # DeepBoostedJet tag infos , 'pfDeepBoostedJetTagInfos' + # ParticleNet tag infos + , 'pfParticleNetTagInfos' # Pixel Cluster tag infos , 'pixelClusterTagInfos' ] @@ -231,3 +233,17 @@ for disc in _pfMassDecorrelatedDeepBoostedJetTagsMetaDiscrs: supportedMetaDiscr[disc] = _pfMassDecorrelatedDeepBoostedJetTagsProbs # ----------------------------------- + +# ----------------------------------- +# setup ParticleNet +from RecoBTag.MXNet.pfParticleNet_cff import _pfParticleNetJetTagsProbs, _pfParticleNetJetTagsMetaDiscrs, \ + _pfMassDecorrelatedParticleNetJetTagsProbs, _pfMassDecorrelatedParticleNetJetTagsMetaDiscrs +# update supportedBtagDiscr +for disc in _pfParticleNetJetTagsProbs + _pfMassDecorrelatedParticleNetJetTagsProbs: + supportedBtagDiscr[disc] = [["pfParticleNetTagInfos"]] +# update supportedMetaDiscr +for disc in _pfParticleNetJetTagsMetaDiscrs: + supportedMetaDiscr[disc] = _pfParticleNetJetTagsProbs +for disc in _pfMassDecorrelatedParticleNetJetTagsMetaDiscrs: + supportedMetaDiscr[disc] = _pfMassDecorrelatedParticleNetJetTagsProbs +# ----------------------------------- diff --git a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py index 37dd166d7f2b6..2e09e4703ff07 100644 --- a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py @@ -43,6 +43,7 @@ def applyDeepBtagging( process, postfix="" ) : delattr(process, 'selectedUpdatedPatJetsSlimmedDeepFlavour'+postfix) from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsAll as pfDeepBoostedJetTagsAll + from RecoBTag.MXNet.pfParticleNet_cff import _pfParticleNetJetTagsAll as pfParticleNetJetTagsAll # 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 @@ -60,7 +61,7 @@ def applyDeepBtagging( process, postfix="" ) : 'pfMassIndependentDeepDoubleCvLJetTags:probHcc', 'pfMassIndependentDeepDoubleCvBJetTags:probHbb', 'pfMassIndependentDeepDoubleCvBJetTags:probHcc', - ) + pfDeepBoostedJetTagsAll + ) + pfDeepBoostedJetTagsAll + pfParticleNetJetTagsAll ) updateJetCollection( process, diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index 564219c86ff07..19bf211c46459 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -662,6 +662,29 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou ), process, task) + if btagInfo == 'pfParticleNetTagInfos': + if pfCandidates.value() == 'packedPFCandidates': + # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) + puppi_value_map = "" + vertex_associator = "" + elif pfCandidates.value() == 'particleFlow': + raise ValueError("Running pfDeepBoostedJetTagInfos with reco::PFCandidates is currently not supported.") + # case 2: running on new jet collection whose daughters are PFCandidates (e.g., cluster jets in RECO/AOD) + puppi_value_map = "puppi" + vertex_associator = "primaryVertexAssociation:original" + else: + raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) + addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, + btag.pfParticleNetTagInfos.clone( + jets = jetSource, + vertices = pvSource, + secondary_vertices = svSource, + pf_candidates = pfCandidates, + puppi_value_map = puppi_value_map, + vertex_associator = vertex_associator, + ), + process, task) + acceptedTagInfos.append(btagInfo) elif hasattr(toptag, btagInfo) : acceptedTagInfos.append(btagInfo) diff --git a/RecoBTag/Configuration/python/RecoBTag_cff.py b/RecoBTag/Configuration/python/RecoBTag_cff.py index beced0b4824dc..04a99862421ba 100644 --- a/RecoBTag/Configuration/python/RecoBTag_cff.py +++ b/RecoBTag/Configuration/python/RecoBTag_cff.py @@ -10,6 +10,7 @@ from RecoBTag.ONNXRuntime.pfDeepFlavour_cff import * from RecoBTag.ONNXRuntime.pfDeepDoubleX_cff import * from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import * +from RecoBTag.MXNet.pfParticleNet_cff import * from RecoVertex.AdaptiveVertexFinder.inclusiveVertexing_cff import * from RecoBTag.PixelCluster.pixelClusterTagInfos_cfi import * diff --git a/RecoBTag/FeatureTools/plugins/DeepBoostedJetTagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/DeepBoostedJetTagInfoProducer.cc index 8269ac0fce189..0ac16c7ed8c71 100644 --- a/RecoBTag/FeatureTools/plugins/DeepBoostedJetTagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/DeepBoostedJetTagInfoProducer.cc @@ -46,6 +46,7 @@ class DeepBoostedJetTagInfoProducer : public edm::stream::EDProducer<> { const double jet_radius_; const double min_jet_pt_; const double min_pt_for_track_properties_; + const bool use_puppiP4_; edm::EDGetTokenT> jet_token_; edm::EDGetTokenT vtx_token_; @@ -83,10 +84,13 @@ const std::vector DeepBoostedJetTagInfoProducer::particle_features_ "pfcand_dphidphi", "pfcand_dxydxy", "pfcand_dzdz", "pfcand_dxydz", "pfcand_dphidxy", "pfcand_dlambdadz", "pfcand_btagEtaRel", "pfcand_btagPtRatio", "pfcand_btagPParRatio", "pfcand_btagSip2dVal", "pfcand_btagSip2dSig", "pfcand_btagSip3dVal", - "pfcand_btagSip3dSig", "pfcand_btagJetDistVal", + "pfcand_btagSip3dSig", "pfcand_btagJetDistVal", "pfcand_mask", "pfcand_pt_log_nopuppi", + "pfcand_e_log_nopuppi" + }; const std::vector DeepBoostedJetTagInfoProducer::sv_features_{ + "sv_mask", "sv_phirel", "sv_etarel", "sv_deltaR", @@ -108,6 +112,7 @@ DeepBoostedJetTagInfoProducer::DeepBoostedJetTagInfoProducer(const edm::Paramete : jet_radius_(iConfig.getParameter("jet_radius")), min_jet_pt_(iConfig.getParameter("min_jet_pt")), min_pt_for_track_properties_(iConfig.getParameter("min_pt_for_track_properties")), + use_puppiP4_(iConfig.getParameter("use_puppiP4")), jet_token_(consumes>(iConfig.getParameter("jets"))), vtx_token_(consumes(iConfig.getParameter("vertices"))), sv_token_(consumes(iConfig.getParameter("secondary_vertices"))), @@ -138,6 +143,7 @@ void DeepBoostedJetTagInfoProducer::fillDescriptions(edm::ConfigurationDescripti desc.add("jet_radius", 0.8); desc.add("min_jet_pt", 150); desc.add("min_pt_for_track_properties", -1); + desc.add("use_puppiP4", true); desc.add("vertices", edm::InputTag("offlinePrimaryVertices")); desc.add("secondary_vertices", edm::InputTag("inclusiveCandidateSecondaryVertices")); desc.add("pf_candidates", edm::InputTag("particleFlow")); @@ -150,8 +156,7 @@ void DeepBoostedJetTagInfoProducer::fillDescriptions(edm::ConfigurationDescripti void DeepBoostedJetTagInfoProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { auto output_tag_infos = std::make_unique(); - edm::Handle> jets; - iEvent.getByToken(jet_token_, jets); + auto jets = iEvent.getHandle(jet_token_); iEvent.getByToken(vtx_token_, vtxs_); if (vtxs_->empty()) { @@ -259,11 +264,17 @@ void DeepBoostedJetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures // get the original reco/packed candidate not scaled by the puppi weight daughters.push_back(pfcands_->ptrAt(cand.key())); } - // sort by Puppi-weighted pt - std::sort( - daughters.begin(), daughters.end(), [&puppi_wgt_cache](const reco::CandidatePtr &a, const reco::CandidatePtr &b) { - return puppi_wgt_cache.at(a.key()) * a->pt() > puppi_wgt_cache.at(b.key()) * b->pt(); - }); + if (use_puppiP4_) { + // sort by Puppi-weighted pt + std::sort(daughters.begin(), + daughters.end(), + [&puppi_wgt_cache](const reco::CandidatePtr &a, const reco::CandidatePtr &b) { + return puppi_wgt_cache.at(a.key()) * a->pt() > puppi_wgt_cache.at(b.key()) * b->pt(); + }); + } else { + // sort by original pt (not Puppi-weighted) + std::sort(daughters.begin(), daughters.end(), [](const auto &a, const auto &b) { return a->pt() > b->pt(); }); + } // reserve space for (const auto &name : particle_features_) { @@ -279,7 +290,7 @@ void DeepBoostedJetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures const auto *packed_cand = dynamic_cast(&(*cand)); const auto *reco_cand = dynamic_cast(&(*cand)); - auto puppiP4 = puppi_wgt_cache.at(cand.key()) * cand->p4(); + auto candP4 = use_puppiP4_ ? puppi_wgt_cache.at(cand.key()) * cand->p4() : cand->p4(); if (packed_cand) { float hcal_fraction = 0.; if (packed_cand->pdgId() == 1 || packed_cand->pdgId() == 130) { @@ -343,14 +354,18 @@ void DeepBoostedJetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures // basic kinematics fts.fill("pfcand_puppiw", puppi_wgt_cache.at(cand.key())); - fts.fill("pfcand_phirel", reco::deltaPhi(puppiP4, jet)); - fts.fill("pfcand_etarel", etasign * (puppiP4.eta() - jet.eta())); - fts.fill("pfcand_deltaR", reco::deltaR(puppiP4, jet)); - fts.fill("pfcand_abseta", std::abs(puppiP4.eta())); + fts.fill("pfcand_phirel", reco::deltaPhi(candP4, jet)); + fts.fill("pfcand_etarel", etasign * (candP4.eta() - jet.eta())); + fts.fill("pfcand_deltaR", reco::deltaR(candP4, jet)); + fts.fill("pfcand_abseta", std::abs(candP4.eta())); + + fts.fill("pfcand_ptrel_log", catch_infs(std::log(candP4.pt() / jet.pt()), -99)); + fts.fill("pfcand_erel_log", catch_infs(std::log(candP4.energy() / jet.energy()), -99)); + fts.fill("pfcand_pt_log", catch_infs(std::log(candP4.pt()), -99)); - fts.fill("pfcand_ptrel_log", catch_infs(std::log(puppiP4.pt() / jet.pt()), -99)); - fts.fill("pfcand_erel_log", catch_infs(std::log(puppiP4.energy() / jet.energy()), -99)); - fts.fill("pfcand_pt_log", catch_infs(std::log(puppiP4.pt()), -99)); + fts.fill("pfcand_mask", 1); + fts.fill("pfcand_pt_log_nopuppi", catch_infs(std::log(cand->pt()), -99)); + fts.fill("pfcand_e_log_nopuppi", catch_infs(std::log(cand->energy()), -99)); double minDR = 999; for (const auto &sv : *svs_) { @@ -390,14 +405,14 @@ void DeepBoostedJetTagInfoProducer::fillParticleFeatures(DeepBoostedJetFeatures TrackInfoBuilder trkinfo(track_builder_); trkinfo.buildTrackInfo(&(*cand), jet_dir, jet_ref_track_dir, *pv_); - fts.fill("pfcand_btagEtaRel", trkinfo.getTrackEtaRel()); - fts.fill("pfcand_btagPtRatio", trkinfo.getTrackPtRatio()); - fts.fill("pfcand_btagPParRatio", trkinfo.getTrackPParRatio()); - fts.fill("pfcand_btagSip2dVal", trkinfo.getTrackSip2dVal()); - fts.fill("pfcand_btagSip2dSig", trkinfo.getTrackSip2dSig()); - fts.fill("pfcand_btagSip3dVal", trkinfo.getTrackSip3dVal()); - fts.fill("pfcand_btagSip3dSig", trkinfo.getTrackSip3dSig()); - fts.fill("pfcand_btagJetDistVal", trkinfo.getTrackJetDistVal()); + fts.fill("pfcand_btagEtaRel", catch_infs(trkinfo.getTrackEtaRel())); + fts.fill("pfcand_btagPtRatio", catch_infs(trkinfo.getTrackPtRatio())); + fts.fill("pfcand_btagPParRatio", catch_infs(trkinfo.getTrackPParRatio())); + fts.fill("pfcand_btagSip2dVal", catch_infs(trkinfo.getTrackSip2dVal())); + fts.fill("pfcand_btagSip2dSig", catch_infs(trkinfo.getTrackSip2dSig())); + fts.fill("pfcand_btagSip3dVal", catch_infs(trkinfo.getTrackSip3dVal())); + fts.fill("pfcand_btagSip3dSig", catch_infs(trkinfo.getTrackSip3dSig())); + fts.fill("pfcand_btagJetDistVal", catch_infs(trkinfo.getTrackJetDistVal())); } else { fts.fill("pfcand_normchi2", 999); @@ -445,6 +460,7 @@ void DeepBoostedJetTagInfoProducer::fillSVFeatures(DeepBoostedJetFeatures &fts, for (const auto *sv : jetSVs) { // basic kinematics + fts.fill("sv_mask", 1); fts.fill("sv_phirel", reco::deltaPhi(*sv, jet)); fts.fill("sv_etarel", etasign * (sv->eta() - jet.eta())); fts.fill("sv_deltaR", reco::deltaR(*sv, jet)); diff --git a/RecoBTag/MXNet/plugins/BoostedJetMXNetJetTagsProducer.cc b/RecoBTag/MXNet/plugins/BoostedJetMXNetJetTagsProducer.cc new file mode 100644 index 0000000000000..64d116103c760 --- /dev/null +++ b/RecoBTag/MXNet/plugins/BoostedJetMXNetJetTagsProducer.cc @@ -0,0 +1,286 @@ +#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/Framework/interface/makeRefToBaseProdFrom.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/StreamID.h" + +#include "DataFormats/BTauReco/interface/JetTag.h" + +#include "DataFormats/BTauReco/interface/DeepBoostedJetTagInfo.h" + +#include +#include +#include +#include +#include "PhysicsTools/MXNet/interface/Predictor.h" + +// Hold the mxnet model block (symbol + params) in the edm::GlobalCache. +struct MXBlockCache { + MXBlockCache() : block(nullptr) {} + + std::atomic block; +}; + +// struct to hold preprocessing parameters +struct PreprocessParams { + struct VarInfo { + VarInfo() {} + VarInfo(float median, float norm_factor) : center(median), norm_factor(norm_factor) {} + float center = 0; + float norm_factor = 1; + }; + + unsigned var_length = 0; + std::vector var_names; + std::unordered_map var_info_map; + + VarInfo get_info(const std::string &name) const { + auto item = var_info_map.find(name); + if (item != var_info_map.end()) { + return item->second; + } else { + throw cms::Exception("InvalidArgument") << "Cannot find variable info for " << name; + } + } +}; + +class BoostedJetMXNetJetTagsProducer : public edm::stream::EDProducer> { +public: + explicit BoostedJetMXNetJetTagsProducer(const edm::ParameterSet &, const MXBlockCache *); + ~BoostedJetMXNetJetTagsProducer() override; + + static void fillDescriptions(edm::ConfigurationDescriptions &); + + static std::unique_ptr initializeGlobalCache(const edm::ParameterSet &); + static void globalEndJob(const MXBlockCache *); + +private: + typedef std::vector TagInfoCollection; + typedef reco::JetTagCollection JetTagCollection; + + void produce(edm::Event &, const edm::EventSetup &) override; + + std::vector center_norm_pad(const std::vector &input, + float center, + float scale, + unsigned target_length, + float pad_value = 0, + float min = 0, + float max = -1); + void make_inputs(const reco::DeepBoostedJetTagInfo &taginfo); + + const edm::EDGetTokenT src_; + std::vector flav_names_; // names of the output scores + std::vector input_names_; // names of each input group - the ordering is important! + std::vector> input_shapes_; // shapes of each input group + std::unordered_map prep_info_map_; // preprocessing info for each input group + + std::vector> data_; + std::unique_ptr predictor_; + + bool debug_ = false; +}; + +BoostedJetMXNetJetTagsProducer::BoostedJetMXNetJetTagsProducer(const edm::ParameterSet &iConfig, + const MXBlockCache *cache) + : src_(consumes(iConfig.getParameter("src"))), + flav_names_(iConfig.getParameter>("flav_names")), + debug_(iConfig.getUntrackedParameter("debugMode", false)) { + // load preprocessing info + const auto &prep_pset = iConfig.getParameterSet("preprocessParams"); + input_names_ = prep_pset.getParameter>("input_names"); + for (const auto &group_name : input_names_) { + const auto &group_pset = prep_pset.getParameterSet(group_name); + input_shapes_.push_back(group_pset.getParameter>("input_shape")); + auto &prep_params = prep_info_map_[group_name]; + prep_params.var_length = group_pset.getParameter("var_length"); + prep_params.var_names = group_pset.getParameter>("var_names"); + const auto &var_info_pset = group_pset.getParameterSet("var_infos"); + for (const auto &var_name : prep_params.var_names) { + const auto &var_pset = var_info_pset.getParameterSet(var_name); + double median = var_pset.getParameter("median"); + double norm_factor = var_pset.getParameter("norm_factor"); + prep_params.var_info_map[var_name] = PreprocessParams::VarInfo(median, norm_factor); + } + + // create data storage with a fixed size vector initilized w/ 0 + unsigned len = prep_params.var_length * prep_params.var_names.size(); + data_.emplace_back(len, 0); + } + + if (debug_) { + for (unsigned i = 0; i < input_names_.size(); ++i) { + const auto &group_name = input_names_.at(i); + std::cout << group_name << "\nshapes: "; + for (const auto &x : input_shapes_.at(i)) { + std::cout << x << ", "; + } + std::cout << "\nvariables: "; + for (const auto &x : prep_info_map_.at(group_name).var_names) { + std::cout << x << ", "; + } + std::cout << "\n"; + } + } + + // init MXNetPredictor + predictor_.reset(new mxnet::cpp::Predictor(*cache->block)); + predictor_->set_input_shapes(input_names_, input_shapes_); + + // get output names from flav_names + for (const auto &flav_name : flav_names_) { + produces(flav_name); + } +} + +BoostedJetMXNetJetTagsProducer::~BoostedJetMXNetJetTagsProducer() {} + +void BoostedJetMXNetJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + // pfParticleNetJetTags + edm::ParameterSetDescription desc; + desc.add("src", edm::InputTag("pfParticleNetTagInfos")); + edm::ParameterSetDescription preprocessParams; + preprocessParams.setAllowAnything(); + desc.add("preprocessParams", preprocessParams); + desc.add( + "model_path", edm::FileInPath("RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-symbol.json")); + desc.add( + "param_path", edm::FileInPath("RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-0000.params")); + desc.add>( + "flav_names", + std::vector{ + "probTbcq", "probTbqq", "probTbc", "probTbq", "probTbel", "probTbmu", "probTbta", + "probWcq", "probWqq", "probZbb", "probZcc", "probZqq", "probHbb", "probHcc", + "probHqqqq", "probQCDbb", "probQCDcc", "probQCDb", "probQCDc", "probQCDothers", + }); + desc.addOptionalUntracked("debugMode", false); + + descriptions.addWithDefaultLabel(desc); +} + +std::unique_ptr BoostedJetMXNetJetTagsProducer::initializeGlobalCache(const edm::ParameterSet &iConfig) { + // get the model files + std::string model_file = iConfig.getParameter("model_path").fullPath(); + std::string param_file = iConfig.getParameter("param_path").fullPath(); + + // load the model and params and save it in the cache + MXBlockCache *cache = new MXBlockCache(); + cache->block = new mxnet::cpp::Block(model_file, param_file); + return std::unique_ptr(cache); +} + +void BoostedJetMXNetJetTagsProducer::globalEndJob(const MXBlockCache *cache) { + if (cache->block != nullptr) { + delete cache->block; + } +} + +void BoostedJetMXNetJetTagsProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { + edm::Handle tag_infos; + iEvent.getByToken(src_, tag_infos); + + // initialize output collection + std::vector> output_tags; + if (!tag_infos->empty()) { + auto jet_ref = tag_infos->begin()->jet(); + auto ref2prod = edm::makeRefToBaseProdFrom(jet_ref, iEvent); + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique(ref2prod)); + } + } else { + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique()); + } + } + + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto &taginfo = (*tag_infos)[jet_n]; + std::vector outputs(flav_names_.size(), 0); // init as all zeros + + if (!taginfo.features().empty()) { + // convert inputs + make_inputs(taginfo); + // run prediction and get outputs + outputs = predictor_->predict(data_); + assert(outputs.size() == flav_names_.size()); + } + + const auto &jet_ref = tag_infos->at(jet_n).jet(); + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { + (*(output_tags[flav_n]))[jet_ref] = outputs[flav_n]; + } + } + + if (debug_) { + std::cout << "=== " << iEvent.id().run() << ":" << iEvent.id().luminosityBlock() << ":" << iEvent.id().event() + << " ===" << std::endl; + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto &jet_ref = tag_infos->at(jet_n).jet(); + std::cout << " - Jet #" << jet_n << ", pt=" << jet_ref->pt() << ", eta=" << jet_ref->eta() + << ", phi=" << jet_ref->phi() << std::endl; + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); ++flav_n) { + std::cout << " " << flav_names_.at(flav_n) << " = " << (*(output_tags.at(flav_n)))[jet_ref] << std::endl; + } + } + } + + // put into the event + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); ++flav_n) { + iEvent.put(std::move(output_tags[flav_n]), flav_names_[flav_n]); + } +} + +std::vector BoostedJetMXNetJetTagsProducer::center_norm_pad(const std::vector &input, + float center, + float norm_factor, + unsigned target_length, + float pad_value, + float min, + float max) { + // do variable shifting/scaling/padding/clipping in one go + + assert(min <= pad_value && pad_value <= max); + + std::vector out(target_length, pad_value); + for (unsigned i = 0; i < input.size() && i < target_length; ++i) { + out[i] = std::clamp((input[i] - center) * norm_factor, min, max); + } + return out; +} + +void BoostedJetMXNetJetTagsProducer::make_inputs(const reco::DeepBoostedJetTagInfo &taginfo) { + for (unsigned igroup = 0; igroup < input_names_.size(); ++igroup) { + const auto &group_name = input_names_[igroup]; + auto &group_values = data_[igroup]; + const auto &prep_params = prep_info_map_.at(group_name); + // first reset group_values to 0 + std::fill(group_values.begin(), group_values.end(), 0); + unsigned curr_pos = 0; + // transform/pad + for (const auto &varname : prep_params.var_names) { + const auto &raw_value = taginfo.features().get(varname); + const auto &info = prep_params.get_info(varname); + const float pad = 0; // pad w/ zero + auto val = center_norm_pad(raw_value, info.center, info.norm_factor, prep_params.var_length, pad, -5, 5); + std::copy(val.begin(), val.end(), group_values.begin() + curr_pos); + curr_pos += prep_params.var_length; + + if (debug_) { + std::cout << " -- var=" << varname << ", center=" << info.center << ", scale=" << info.norm_factor + << ", pad=" << pad << std::endl; + std::cout << "values (first 7 and last 3): " << val.at(0) << ", " << val.at(1) << ", " << val.at(2) << ", " + << val.at(3) << ", " << val.at(4) << ", " << val.at(5) << ", " << val.at(6) << " ... " + << val.at(prep_params.var_length - 3) << ", " << val.at(prep_params.var_length - 2) << ", " + << val.at(prep_params.var_length - 1) << std::endl; + } + } + } +} + +//define this as a plug-in +DEFINE_FWK_MODULE(BoostedJetMXNetJetTagsProducer); diff --git a/RecoBTag/MXNet/plugins/BuildFile.xml b/RecoBTag/MXNet/plugins/BuildFile.xml new file mode 100644 index 0000000000000..b6d6eaed37b09 --- /dev/null +++ b/RecoBTag/MXNet/plugins/BuildFile.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py b/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py new file mode 100644 index 0000000000000..7194a0cc2f294 --- /dev/null +++ b/RecoBTag/MXNet/python/Parameters/ParticleNet/V00/pfParticleNetPreprocessParams_cfi.py @@ -0,0 +1,299 @@ +import FWCore.ParameterSet.Config as cms + +pfParticleNetPreprocessParams = cms.PSet( + input_names = cms.vstring( + 'pf_points', + 'pf_features', + 'pf_mask', + 'sv_points', + 'sv_features', + 'sv_mask' + ), + pf_features = cms.PSet( + input_shape = cms.vuint32(1, 25, 100), + var_infos = cms.PSet( + pfcand_VTX_ass = cms.PSet( + median = cms.double(7.0), + norm_factor = cms.double(1.0) + ), + pfcand_abseta = cms.PSet( + median = cms.double(0.570207834244), + norm_factor = cms.double(1.65039794176) + ), + pfcand_btagEtaRel = cms.PSet( + median = cms.double(1.02164459229), + norm_factor = cms.double(0.450494647657) + ), + pfcand_btagJetDistVal = cms.PSet( + median = cms.double(-8.01788191893e-05), + norm_factor = cms.double(172.900234853) + ), + pfcand_btagPParRatio = cms.PSet( + median = cms.double(0.777632951736), + norm_factor = cms.double(1.28595373661) + ), + pfcand_btagPtRatio = cms.PSet( + median = cms.double(0.00793754169717), + norm_factor = cms.double(4.41778965372) + ), + pfcand_btagSip3dSig = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(0.871534329165) + ), + pfcand_btagSip3dVal = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(252.165554148) + ), + pfcand_charge = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_dxy = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(473.799859238) + ), + pfcand_dxysig = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.66318902024) + ), + pfcand_dz = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(297.458232668) + ), + pfcand_dzsig = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.38690098449) + ), + pfcand_e_log_nopuppi = cms.PSet( + median = cms.double(1.42155307531), + norm_factor = cms.double(0.519927136489) + ), + pfcand_etarel = cms.PSet( + median = cms.double(-0.00481873401441), + norm_factor = cms.double(4.44798275517) + ), + pfcand_isChargedHad = cms.PSet( + median = cms.double(1.0), + norm_factor = cms.double(1.0) + ), + pfcand_isEl = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_isGamma = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_isMu = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_isNeutralHad = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ), + pfcand_lostInnerHits = cms.PSet( + median = cms.double(-1.0), + norm_factor = cms.double(1.0) + ), + pfcand_normchi2 = cms.PSet( + median = cms.double(3.0), + norm_factor = cms.double(0.00100401606426) + ), + pfcand_phirel = cms.PSet( + median = cms.double(-0.000108399453893), + norm_factor = cms.double(4.39792304438) + ), + pfcand_pt_log_nopuppi = cms.PSet( + median = cms.double(1.12241530418), + norm_factor = cms.double(0.514354843556) + ), + pfcand_quality = cms.PSet( + median = cms.double(5.0), + norm_factor = cms.double(0.2) + ) + ), + var_length = cms.uint32(100), + var_names = cms.vstring( + 'pfcand_pt_log_nopuppi', + 'pfcand_e_log_nopuppi', + 'pfcand_etarel', + 'pfcand_phirel', + 'pfcand_abseta', + 'pfcand_charge', + 'pfcand_isMu', + 'pfcand_isEl', + 'pfcand_isChargedHad', + 'pfcand_isGamma', + 'pfcand_isNeutralHad', + 'pfcand_VTX_ass', + 'pfcand_lostInnerHits', + 'pfcand_normchi2', + 'pfcand_quality', + 'pfcand_dz', + 'pfcand_dzsig', + 'pfcand_dxy', + 'pfcand_dxysig', + 'pfcand_btagEtaRel', + 'pfcand_btagPtRatio', + 'pfcand_btagPParRatio', + 'pfcand_btagSip3dVal', + 'pfcand_btagSip3dSig', + 'pfcand_btagJetDistVal' + ) + ), + pf_mask = cms.PSet( + input_shape = cms.vuint32(1, 1, 100), + var_infos = cms.PSet( + pfcand_mask = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ) + ), + var_length = cms.uint32(100), + var_names = cms.vstring('pfcand_mask') + ), + pf_points = cms.PSet( + input_shape = cms.vuint32(1, 2, 100), + var_infos = cms.PSet( + pfcand_etarel = cms.PSet( + median = cms.double(-0.00481873401441), + norm_factor = cms.double(4.44798275517) + ), + pfcand_phirel = cms.PSet( + median = cms.double(-0.000108399453893), + norm_factor = cms.double(4.39792304438) + ) + ), + var_length = cms.uint32(100), + var_names = cms.vstring( + 'pfcand_etarel', + 'pfcand_phirel' + ) + ), + sv_features = cms.PSet( + input_shape = cms.vuint32(1, 12, 7), + var_infos = cms.PSet( + sv_abseta = cms.PSet( + median = cms.double(0.549196600914), + norm_factor = cms.double(1.59394768801) + ), + sv_costhetasvpv = cms.PSet( + median = cms.double(0.999762713909), + norm_factor = cms.double(183.233393766) + ), + sv_d3d = cms.PSet( + median = cms.double(0.551342129707), + norm_factor = cms.double(0.223128153806) + ), + sv_d3dsig = cms.PSet( + median = cms.double(8.35655975342), + norm_factor = cms.double(0.0238999954695) + ), + sv_dxy = cms.PSet( + median = cms.double(0.421502441168), + norm_factor = cms.double(0.312218277088) + ), + sv_dxysig = cms.PSet( + median = cms.double(8.34426879883), + norm_factor = cms.double(0.0239017055779) + ), + sv_etarel = cms.PSet( + median = cms.double(-0.00247404468246), + norm_factor = cms.double(8.44460188362) + ), + sv_mass = cms.PSet( + median = cms.double(1.3346953392), + norm_factor = cms.double(0.309230848837) + ), + sv_normchi2 = cms.PSet( + median = cms.double(0.806915462017), + norm_factor = cms.double(0.724496098658) + ), + sv_ntracks = cms.PSet( + median = cms.double(3.0), + norm_factor = cms.double(0.5) + ), + sv_phirel = cms.PSet( + median = cms.double(0.000502154347487), + norm_factor = cms.double(8.73243388771) + ), + sv_pt_log = cms.PSet( + median = cms.double(3.78325366974), + norm_factor = cms.double(0.692538144148) + ) + ), + var_length = cms.uint32(7), + var_names = cms.vstring( + 'sv_pt_log', + 'sv_mass', + 'sv_phirel', + 'sv_etarel', + 'sv_abseta', + 'sv_ntracks', + 'sv_normchi2', + 'sv_dxy', + 'sv_dxysig', + 'sv_d3d', + 'sv_d3dsig', + 'sv_costhetasvpv' + ) + ), + sv_mask = cms.PSet( + input_shape = cms.vuint32(1, 1, 7), + var_infos = cms.PSet( + sv_mask = cms.PSet( + median = cms.double(0.0), + norm_factor = cms.double(1.0) + ) + ), + var_length = cms.uint32(7), + var_names = cms.vstring('sv_mask') + ), + sv_points = cms.PSet( + input_shape = cms.vuint32(1, 2, 7), + var_infos = cms.PSet( + sv_etarel = cms.PSet( + median = cms.double(-0.00247404468246), + norm_factor = cms.double(8.44460188362) + ), + sv_phirel = cms.PSet( + median = cms.double(0.000502154347487), + norm_factor = cms.double(8.73243388771) + ) + ), + var_length = cms.uint32(7), + var_names = cms.vstring( + 'sv_phirel', + 'sv_etarel' + ) + ) +) + +pfMassDecorrelatedParticleNetPreprocessParams = pfParticleNetPreprocessParams.clone( + pf_features = pfParticleNetPreprocessParams.pf_features.clone( + input_shape = [1, 20, 100], + var_names = [ + 'pfcand_pt_log_nopuppi', + 'pfcand_e_log_nopuppi', + 'pfcand_etarel', + 'pfcand_phirel', + 'pfcand_abseta', + 'pfcand_charge', + 'pfcand_VTX_ass', + 'pfcand_lostInnerHits', + 'pfcand_normchi2', + 'pfcand_quality', + 'pfcand_dz', + 'pfcand_dzsig', + 'pfcand_dxy', + 'pfcand_dxysig', + 'pfcand_btagEtaRel', + 'pfcand_btagPtRatio', + 'pfcand_btagPParRatio', + 'pfcand_btagSip3dVal', + 'pfcand_btagSip3dSig', + 'pfcand_btagJetDistVal' + ] + ) +) diff --git a/RecoBTag/MXNet/python/pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi.py b/RecoBTag/MXNet/python/pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi.py new file mode 100644 index 0000000000000..a51a454bac61b --- /dev/null +++ b/RecoBTag/MXNet/python/pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi.py @@ -0,0 +1,50 @@ +import FWCore.ParameterSet.Config as cms + +pfMassDecorrelatedParticleNetDiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('XbbvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXbb'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXbb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDothers'), + ), + ), + cms.PSet( + name = cms.string('XccvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXcc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXcc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDothers'), + ), + ), + cms.PSet( + name = cms.string('XqqvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probXqq'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfMassDecorrelatedParticleNetJetTags', 'probQCDothers'), + ), + ), + + ) + ) diff --git a/RecoBTag/MXNet/python/pfParticleNetDiscriminatorsJetTags_cfi.py b/RecoBTag/MXNet/python/pfParticleNetDiscriminatorsJetTags_cfi.py new file mode 100644 index 0000000000000..9a9554e336707 --- /dev/null +++ b/RecoBTag/MXNet/python/pfParticleNetDiscriminatorsJetTags_cfi.py @@ -0,0 +1,99 @@ +import FWCore.ParameterSet.Config as cms + +pfParticleNetDiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('TvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probTbcq'), + cms.InputTag('pfParticleNetJetTags', 'probTbqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probTbcq'), + cms.InputTag('pfParticleNetJetTags', 'probTbqq'), + 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('WvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probWcq'), + cms.InputTag('pfParticleNetJetTags', 'probWqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probWcq'), + cms.InputTag('pfParticleNetJetTags', 'probWqq'), + 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('ZvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probZbb'), + cms.InputTag('pfParticleNetJetTags', 'probZcc'), + cms.InputTag('pfParticleNetJetTags', 'probZqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probZbb'), + cms.InputTag('pfParticleNetJetTags', 'probZcc'), + cms.InputTag('pfParticleNetJetTags', 'probZqq'), + 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('ZbbvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probZbb'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probZbb'), + 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( + cms.InputTag('pfParticleNetJetTags', 'probHbb'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probHbb'), + 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('H4qvsQCD'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probHqqqq'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleNetJetTags', 'probHqqqq'), + cms.InputTag('pfParticleNetJetTags', 'probQCDbb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDcc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDb'), + cms.InputTag('pfParticleNetJetTags', 'probQCDc'), + cms.InputTag('pfParticleNetJetTags', 'probQCDothers'), + ), + ), + ) + ) diff --git a/RecoBTag/MXNet/python/pfParticleNet_cff.py b/RecoBTag/MXNet/python/pfParticleNet_cff.py new file mode 100644 index 0000000000000..b97d1fb164a02 --- /dev/null +++ b/RecoBTag/MXNet/python/pfParticleNet_cff.py @@ -0,0 +1,49 @@ +import FWCore.ParameterSet.Config as cms + +from RecoBTag.FeatureTools.pfDeepBoostedJetTagInfos_cfi import pfDeepBoostedJetTagInfos +from RecoBTag.MXNet.boostedJetMXNetJetTagsProducer_cfi import boostedJetMXNetJetTagsProducer +from RecoBTag.MXNet.Parameters.ParticleNet.V00.pfParticleNetPreprocessParams_cfi import pfParticleNetPreprocessParams, pfMassDecorrelatedParticleNetPreprocessParams +from RecoBTag.MXNet.pfParticleNetDiscriminatorsJetTags_cfi import pfParticleNetDiscriminatorsJetTags +from RecoBTag.MXNet.pfMassDecorrelatedParticleNetDiscriminatorsJetTags_cfi import pfMassDecorrelatedParticleNetDiscriminatorsJetTags + +pfParticleNetTagInfos = pfDeepBoostedJetTagInfos.clone( + use_puppiP4 = False +) + +pfParticleNetJetTags = boostedJetMXNetJetTagsProducer.clone( + preprocessParams = pfParticleNetPreprocessParams, + model_path = 'RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-symbol.json', + param_path = 'RecoBTag/Combined/data/ParticleNetAK8/General/V00/ParticleNet-0000.params', +) + +pfMassDecorrelatedParticleNetJetTags = boostedJetMXNetJetTagsProducer.clone( + preprocessParams = pfMassDecorrelatedParticleNetPreprocessParams, + model_path = 'RecoBTag/Combined/data/ParticleNetAK8/MD-2prong/V00/ParticleNet-symbol.json', + param_path = 'RecoBTag/Combined/data/ParticleNetAK8/MD-2prong/V00/ParticleNet-0000.params', + flav_names = ["probXbb", "probXcc", "probXqq", "probQCDbb", "probQCDcc", + "probQCDb", "probQCDc", "probQCDothers"], +) + +from CommonTools.PileupAlgos.Puppi_cff import puppi +from PhysicsTools.PatAlgos.slimming.primaryVertexAssociation_cfi import primaryVertexAssociation + +# This task is not used, useful only if we run it from RECO jets (RECO/AOD) +pfParticleNetTask = cms.Task(puppi, primaryVertexAssociation, pfParticleNetTagInfos, + pfParticleNetJetTags, pfMassDecorrelatedParticleNetJetTags, pfParticleNetDiscriminatorsJetTags) + +# declare all the discriminators +# nominal: probs +_pfParticleNetJetTagsProbs = ['pfParticleNetJetTags:' + flav_name + for flav_name in pfParticleNetJetTags.flav_names] +# nominal: meta-taggers +_pfParticleNetJetTagsMetaDiscrs = ['pfParticleNetDiscriminatorsJetTags:' + disc.name.value() + for disc in pfParticleNetDiscriminatorsJetTags.discriminators] +# mass-decorrelated: probs +_pfMassDecorrelatedParticleNetJetTagsProbs = ['pfMassDecorrelatedParticleNetJetTags:' + flav_name + for flav_name in pfMassDecorrelatedParticleNetJetTags.flav_names] +# mass-decorrelated: meta-taggers +_pfMassDecorrelatedParticleNetJetTagsMetaDiscrs = ['pfMassDecorrelatedParticleNetDiscriminatorsJetTags:' + disc.name.value() + for disc in pfMassDecorrelatedParticleNetDiscriminatorsJetTags.discriminators] + +_pfParticleNetJetTagsAll = _pfParticleNetJetTagsProbs + _pfParticleNetJetTagsMetaDiscrs + \ + _pfMassDecorrelatedParticleNetJetTagsProbs + _pfMassDecorrelatedParticleNetJetTagsMetaDiscrs diff --git a/RecoBTag/MXNet/test/test_particle_net_cfg.py b/RecoBTag/MXNet/test/test_particle_net_cfg.py new file mode 100644 index 0000000000000..263c43d4d17cb --- /dev/null +++ b/RecoBTag/MXNet/test/test_particle_net_cfg.py @@ -0,0 +1,70 @@ +import FWCore.ParameterSet.Config as cms +from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask + +from FWCore.ParameterSet.VarParsing import VarParsing +options = VarParsing('analysis') +options.inputFiles = '/store/mc/RunIIFall17MiniAODv2/TTToHadronic_TuneCP5_13TeV-powheg-pythia8/MINIAODSIM/PU2017_12Apr2018_94X_mc2017_realistic_v14-v1/90000/DCFE3F5F-AE42-E811-B6DB-008CFAF72A64.root' +options.maxEvents = 1000 +options.parseArguments() + +process = cms.Process("PATtest") + +## MessageLogger +process.load("FWCore.MessageLogger.MessageLogger_cfi") +process.MessageLogger.cerr.FwkReport.reportEvery = 100 + + +## Options and Output Report +process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) + +## Source +process.source = cms.Source("PoolSource", + fileNames=cms.untracked.vstring(options.inputFiles) +) +## Maximal Number of Events +process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(options.maxEvents)) + +## Geometry and Detector Conditions (needed for a few patTuple production steps) +process.load("Configuration.Geometry.GeometryRecoDB_cff") +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase1_2017_realistic') +process.load("Configuration.StandardSequences.MagneticField_cff") + +## Output Module Configuration (expects a path 'p') +from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning +process.out = cms.OutputModule("PoolOutputModule", + fileName = cms.untracked.string('patTuple.root'), + ## save only events passing the full path + #SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ), + ## save PAT output; you need a '*' to unpack the list of commands + ## 'patEventContent' + outputCommands = cms.untracked.vstring('drop *', *patEventContentNoCleaning ) + ) + +patAlgosToolsTask = getPatAlgosToolsTask(process) +process.outpath = cms.EndPath(process.out, patAlgosToolsTask) + +## and add them to the event content +from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection +from RecoBTag.MXNet.pfParticleNet_cff import _pfParticleNetJetTagsAll as pfParticleNetJetTagsAll + +updateJetCollection( + process, + jetSource = cms.InputTag('slimmedJetsAK8'), + pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), + svSource = cms.InputTag('slimmedSecondaryVertices'), + rParam = 0.8, + jetCorrections = ('AK8PFPuppi', cms.vstring(['L2Relative', 'L3Absolute']), 'None'), + btagDiscriminators = pfParticleNetJetTagsAll + ) + +from Configuration.EventContent.EventContent_cff import MINIAODSIMEventContent +process.out.outputCommands.append('keep *_slimmedJetsAK8*_*_*') +process.out.outputCommands.append('keep *_offlineSlimmedPrimaryVertices*_*_*') +process.out.outputCommands.append('keep *_slimmedSecondaryVertices*_*_*') +process.out.outputCommands.append('keep *_selectedPatJets*_*_*') +process.out.outputCommands.append('keep *_selectedUpdatedPatJets*_*_*') +process.out.outputCommands.append('keep *_updatedPatJets*_*_*') + +process.out.fileName = 'test_particle_net_MINIAODSIM.root'