DeepMETProducer Class Reference

Inheritance diagram for DeepMETProducer:

Public Member Functions
	DeepMETProducer (const edm::ParameterSet &, const DeepMETCache *)
void	produce (edm::Event &event, const edm::EventSetup &setup) override
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DeepMETCache > >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
static void	globalEndJob (DeepMETCache *)
static std::unique_ptr< DeepMETCache >	initializeGlobalCache (const edm::ParameterSet &)

Private Attributes
const bool	ignore_leptons_
tensorflow::Tensor	input_
tensorflow::Tensor	input_cat0_
tensorflow::Tensor	input_cat1_
tensorflow::Tensor	input_cat2_
const unsigned int	max_n_pf_
const float	norm_
const edm::EDGetTokenT< std::vector< pat::PackedCandidate > >	pf_token_
tensorflow::Session *	session_

Static Private Attributes
static const std::unordered_map< int, int32_t >	charge_embedding_ {{-1, 0}, {0, 1}, {1, 2}}
static const std::unordered_map< int, int32_t >	pdg_id_embedding_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DeepMETCache > >
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 15 of file DeepMETProducer.cc.

Constructor & Destructor Documentation

DeepMETProducer()

DeepMETProducer::DeepMETProducer ( const edm::ParameterSet &  cfg, const DeepMETCache *  cache  )

explicit

Definition at line 52 of file DeepMETProducer.cc.

References input_, input_cat0_, input_cat1_, input_cat2_, and max_n_pf_.

    : pf_token_(consumes<std::vector<pat::PackedCandidate> >(cfg.getParameter<edm::InputTag>("pf_src"))),
      norm_(cfg.getParameter<double>("norm_factor")),
      ignore_leptons_(cfg.getParameter<bool>("ignore_leptons")),
      max_n_pf_(cfg.getParameter<unsigned int>("max_n_pf")),
      session_(tensorflow::createSession(cache->graph_def)) {
  produces<pat::METCollection>();

  const tensorflow::TensorShape shape({1, max_n_pf_, 8});
  const tensorflow::TensorShape cat_shape({1, max_n_pf_, 1});

  input_ = tensorflow::Tensor(tensorflow::DT_FLOAT, shape);
  input_cat0_ = tensorflow::Tensor(tensorflow::DT_FLOAT, cat_shape);
  input_cat1_ = tensorflow::Tensor(tensorflow::DT_FLOAT, cat_shape);
  input_cat2_ = tensorflow::Tensor(tensorflow::DT_FLOAT, cat_shape);
}

Member Function Documentation

fillDescriptions()

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

static

Definition at line 151 of file DeepMETProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_2022v12_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                 {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("pf_src", edm::InputTag("packedPFCandidates"));
  desc.add<bool>("ignore_leptons", false);
  desc.add<double>("norm_factor", 50.);
  desc.add<unsigned int>("max_n_pf", 4500);
  desc.add<std::string>("graph_path", "RecoMET/METPUSubtraction/data/deepmet/deepmet_v1_2018.pb");
  descriptions.add("deepMETProducer", desc);
}

globalEndJob()

void DeepMETProducer::globalEndJob ( DeepMETCache *  cache )

static

Definition at line 149 of file DeepMETProducer.cc.

References utilities::cache().

{ delete cache->graph_def; }

initializeGlobalCache()

std::unique_ptr< DeepMETCache > DeepMETProducer::initializeGlobalCache ( const edm::ParameterSet &  params )

static

Definition at line 135 of file DeepMETProducer.cc.

References utilities::cache(), edm::FileInPath::fullPath(), HLT_2022v12_cff::graphPath, tensorflow::loadGraphDef(), submitPVValidationJobs::params, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                {
  // this method is supposed to create, initialize and return a DeepMETCache instance
  std::unique_ptr<DeepMETCache> cache = std::make_unique<DeepMETCache>();

  // load the graph def and save it
  std::string graphPath = params.getParameter<std::string>("graph_path");
  if (!graphPath.empty()) {
    graphPath = edm::FileInPath(graphPath).fullPath();
    cache->graph_def = tensorflow::loadGraphDef(graphPath);
  }

  return cache;
}

produce()

void DeepMETProducer::produce ( edm::Event &  event, const edm::EventSetup &  setup  )

override

Definition at line 69 of file DeepMETProducer.cc.

References funct::abs(), charge_embedding_, dqmMemoryStats::float, ignore_leptons_, input_, input_cat0_, input_cat1_, input_cat2_, max_n_pf_, eostools::move(), norm_, HLT_2022v12_cff::output_names, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, HiggsValidation_cfi::pdg_id, pdg_id_embedding_, packedPFCandidateRefMixer_cfi::pf, pf_token_, multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, tensorflow::run(), L1EGammaClusterEmuProducer_cfi::scale, and session_.

                                                                         {
  auto const& pfs = event.get(pf_token_);

  const tensorflow::NamedTensorList input_list = {
      {"input", input_}, {"input_cat0", input_cat0_}, {"input_cat1", input_cat1_}, {"input_cat2", input_cat2_}};

  // Set all inputs to zero
  input_.flat<float>().setZero();
  input_cat0_.flat<float>().setZero();
  input_cat1_.flat<float>().setZero();
  input_cat2_.flat<float>().setZero();

  size_t i_pf = 0;
  float px_leptons = 0.;
  float py_leptons = 0.;
  const float scale = 1. / norm_;
  for (const auto& pf : pfs) {
    if (ignore_leptons_) {
      int pdg_id = std::abs(pf.pdgId());
      if (pdg_id == 11 || pdg_id == 13) {
        px_leptons += pf.px();
        py_leptons += pf.py();
        continue;
      }
    }

    // fill the tensor
    // PF keys [b'PF_dxy', b'PF_dz', b'PF_eta', b'PF_mass', b'PF_pt', b'PF_puppiWeight', b'PF_px', b'PF_py']
    float* ptr = &input_.tensor<float, 3>()(0, i_pf, 0);
    *ptr = pf.dxy();
    *(++ptr) = pf.dz();
    *(++ptr) = pf.eta();
    *(++ptr) = pf.mass();
    *(++ptr) = scale_and_rm_outlier(pf.pt(), scale);
    *(++ptr) = pf.puppiWeight();
    *(++ptr) = scale_and_rm_outlier(pf.px(), scale);
    *(++ptr) = scale_and_rm_outlier(pf.py(), scale);
    input_cat0_.tensor<float, 3>()(0, i_pf, 0) = charge_embedding_.at(pf.charge());
    input_cat1_.tensor<float, 3>()(0, i_pf, 0) = pdg_id_embedding_.at(pf.pdgId());
    input_cat2_.tensor<float, 3>()(0, i_pf, 0) = pf.fromPV();

    ++i_pf;
    if (i_pf == max_n_pf_) {
      break;  // output a warning?
    }
  }

  std::vector<tensorflow::Tensor> outputs;
  const std::vector<std::string> output_names = {"output/BiasAdd"};

  // run the inference and return met
  tensorflow::run(session_, input_list, output_names, &outputs);

  // The DNN directly estimates the missing px and py, not the recoil
  float px = outputs[0].tensor<float, 2>()(0, 0) * norm_;
  float py = outputs[0].tensor<float, 2>()(0, 1) * norm_;

  px -= px_leptons;
  py -= py_leptons;

  auto pf_mets = std::make_unique<pat::METCollection>();
  const reco::Candidate::LorentzVector p4(px, py, 0., std::hypot(px, py));
  pf_mets->emplace_back(reco::MET(p4, {}));
  event.put(std::move(pf_mets));
}

Member Data Documentation

charge_embedding_

const std::unordered_map<int, int32_t> DeepMETProducer::charge_embedding_ {{-1, 0}, {0, 1}, {1, 2}}

inlinestaticprivate

Definition at line 38 of file DeepMETProducer.cc.

Referenced by produce().

ignore_leptons_

const bool DeepMETProducer::ignore_leptons_

private

Definition at line 28 of file DeepMETProducer.cc.

Referenced by produce().

input_

tensorflow::Tensor DeepMETProducer::input_

private

Definition at line 33 of file DeepMETProducer.cc.

Referenced by DeepMETProducer(), and produce().

input_cat0_

tensorflow::Tensor DeepMETProducer::input_cat0_

private

Definition at line 34 of file DeepMETProducer.cc.

Referenced by DeepMETProducer(), and produce().

input_cat1_

tensorflow::Tensor DeepMETProducer::input_cat1_

private

Definition at line 35 of file DeepMETProducer.cc.

Referenced by DeepMETProducer(), and produce().

input_cat2_

tensorflow::Tensor DeepMETProducer::input_cat2_

private

Definition at line 36 of file DeepMETProducer.cc.

Referenced by DeepMETProducer(), and produce().

max_n_pf_

const unsigned int DeepMETProducer::max_n_pf_

private

Definition at line 29 of file DeepMETProducer.cc.

Referenced by DeepMETProducer(), and produce().

norm_

const float DeepMETProducer::norm_

private

Definition at line 27 of file DeepMETProducer.cc.

Referenced by produce().

pdg_id_embedding_

const std::unordered_map<int, int32_t> DeepMETProducer::pdg_id_embedding_

inlinestaticprivate

Initial value:

{
      {-211, 0}, {-13, 1}, {-11, 2}, {0, 3}, {1, 4}, {2, 5}, {11, 6}, {13, 7}, {22, 8}, {130, 9}, {211, 10}}

Definition at line 39 of file DeepMETProducer.cc.

Referenced by produce().

pf_token_

const edm::EDGetTokenT<std::vector<pat::PackedCandidate> > DeepMETProducer::pf_token_

private

Definition at line 26 of file DeepMETProducer.cc.

Referenced by produce().

session_

tensorflow::Session* DeepMETProducer::session_

private

Definition at line 31 of file DeepMETProducer.cc.

Referenced by produce().