Add L1 NN Taus.

L1Trigger/Configuration/python/SimL1Emulator_cff.py

@@ -143,6 +143,18 @@
 l1PFMetsTask = cms.Task(l1PFMetCalo , l1PFMetPF , l1PFMetPuppi)
 _phase2_siml1emulator_ttrack.add(l1PFMetsTask)
 
+# NNTaus
+# ########################################################################
+from L1Trigger.Phase2L1ParticleFlow.L1NNTauProducer_cff import *
+l1NNTauProducer = L1NNTauProducer.clone(
+  L1PFObjects = cms.InputTag("l1pfCandidates","PF")
+)
+l1NNTauProducerPuppi = L1NNTauProducerPuppi.clone(
+  L1PFObjects = cms.InputTag("l1pfCandidates","Puppi")
+)
+_phase2_siml1emulator_ttrack.add(l1NNTauProducer)
+_phase2_siml1emulator_ttrack.add(l1NNTauProducerPuppi)
+
 # --> add modules
 from Configuration.Eras.Modifier_phase2_trackerV14_cff import phase2_trackerV14
 (phase2_trigger & phase2_trackerV14).toReplaceWith( SimL1EmulatorTask , _phase2_siml1emulator_ttrack)

L1Trigger/Phase2L1ParticleFlow/BuildFile.xml

@@ -9,6 +9,8 @@
 <use   name="L1Trigger/L1THGCal"/>
 <use   name="CommonTools/Utils"/>
 <use   name="CommonTools/MVAUtils"/>
+<use   name="PhysicsTools/TensorFlow"/>
+<use   name="tensorflow"/>
 <use   name="roottmva"/>
 <use   name="hls"/>
 <export>

L1Trigger/Phase2L1ParticleFlow/interface/L1NNTauProducer.hh

@@ -0,0 +1,41 @@
+#ifndef L1TRIGGER_PHASE2L1PARTICLEFLOW_L1NNTAU_H
+#define L1TRIGGER_PHASE2L1PARTICLEFLOW_L1NNTAU_H
+
+#include <iostream>
+#include <vector>
+#include <TLorentzVector.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 "DataFormats/L1TParticleFlow/interface/PFTau.h"
+#include "DataFormats/L1TParticleFlow/interface/PFCandidate.h"
+#include "L1Trigger/Phase2L1ParticleFlow/interface/TauNNId.h"
+
+using namespace l1t;
+
+class L1NNTauProducer : public edm::stream::EDProducer<> {
+public:
+  explicit L1NNTauProducer(const edm::ParameterSet &);
+  ~L1NNTauProducer();
+
+private:
+  TauNNId *fTauNNId;
+  void addTau(l1t::PFCandidate &iCand,
+              const l1t::PFCandidateCollection &iParts,
+              std::unique_ptr<PFTauCollection> &outputTaus);
+  float deltaR(auto iPart1, auto iPart2);
+  virtual void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override;
+
+  double fSeedPt_;
+  double fConeSize_;
+  double fTauSize_;
+  int fMaxTaus_;
+  int fNParticles_;
+  edm::EDGetTokenT<vector<l1t::PFCandidate> > fL1PFToken_;
+};
+
+#endif

L1Trigger/Phase2L1ParticleFlow/interface/TauNNId.h

@@ -0,0 +1,30 @@
+#ifndef L1TRIGGER_PHASE2L1PARTICLEFLOWS_TAUNNID_H
+#define L1TRIGGER_PHASE2L1PARTICLEFLOWS_TAuNNID_H
+
+#include <string>
+#include "PhysicsTools/TensorFlow/interface/TensorFlow.h"
+#include "DataFormats/L1TParticleFlow/interface/PFCandidate.h"
+
+class TauNNId {
+public:
+  TauNNId();
+  ~TauNNId();
+
+  void initialize(const std::string &iName, const std::string &iWeightFile, int iNParticles);
+  void SetNNVectorVar();
+  float EvaluateNN();
+  float compute(l1t::PFCandidate &iSeed, l1t::PFCandidateCollection &iParts);
+
+  std::string fInput_;
+  int fNParticles_;
+  unique_ptr<float> fPt_;
+  unique_ptr<float> fEta_;
+  unique_ptr<float> fPhi_;
+  unique_ptr<float> fId_;
+
+private:
+  tensorflow::Session *session_;
+  tensorflow::GraphDef *graphDef_;
+  std::vector<float> NNvectorVar_;
+};
+#endif

L1Trigger/Phase2L1ParticleFlow/plugins/L1NNTauProducer.cc

@@ -0,0 +1,110 @@
+#include "L1Trigger/Phase2L1ParticleFlow/interface/L1NNTauProducer.hh"
+
+L1NNTauProducer::L1NNTauProducer(const edm::ParameterSet& cfg)
+    : fSeedPt_(cfg.getParameter<double>("seedpt")),
+      fConeSize_(cfg.getParameter<double>("conesize")),
+      fTauSize_(cfg.getParameter<double>("tausize")),
+      fMaxTaus_(cfg.getParameter<int>("maxtaus")),
+      fNParticles_(cfg.getParameter<int>("nparticles")),
+      fL1PFToken_(consumes<vector<l1t::PFCandidate> >(cfg.getParameter<edm::InputTag>("L1PFObjects"))) {
+  std::string lNNFile = cfg.getParameter<std::string>("NNFileName");  //,"L1Trigger/Phase2L1Taus/data/tau_3layer.pb");
+  fTauNNId = new TauNNId();
+  if (lNNFile.find("v0") == std::string::npos)
+    fTauNNId->initialize("input_1:0", lNNFile, fNParticles_);
+  if (lNNFile.find("v0") != std::string::npos)
+    fTauNNId->initialize("dense_1_input:0", lNNFile, fNParticles_);
+  produces<l1t::PFTauCollection>("L1PFTausNN");
+}
+
+void L1NNTauProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
+  edm::Handle<l1t::PFCandidateCollection> l1PFCandidates;
+  iEvent.getByToken(fL1PFToken_, l1PFCandidates);
+
+  l1t::PFCandidateCollection pfChargedHadrons;
+  l1t::PFCandidateCollection pfChargedHadrons_sort;
+  l1t::PFCandidateCollection pfChargedHadrons_seeds;
+  for (auto l1PFCand : *l1PFCandidates)
+    if ((l1PFCand.id() == l1t::PFCandidate::ChargedHadron || l1PFCand.id() == l1t::PFCandidate::Electron) &&
+        fabs(l1PFCand.eta()) < 2.5)
+      pfChargedHadrons_sort.push_back(l1PFCand);
+  std::sort(pfChargedHadrons_sort.begin(), pfChargedHadrons_sort.end(), [](l1t::PFCandidate i, l1t::PFCandidate j) {
+    return (i.pt() > j.pt());
+  });
+  auto lTaus = std::make_unique<l1t::PFTauCollection>();
+  if (pfChargedHadrons_sort.size() == 0) {
+    if (lTaus->size() == 0) {
+      PFTau dummy;
+      lTaus->push_back(dummy);
+    }
+    iEvent.put(std::move(lTaus), "L1PFTausNN");
+    return;
+  }
+  pfChargedHadrons_seeds.push_back(pfChargedHadrons_sort[0]);
+  for (unsigned int i0 = 1; i0 < pfChargedHadrons_sort.size(); i0++) {
+    bool pMatch = false;
+    for (unsigned int i1 = 0; i1 < pfChargedHadrons_seeds.size(); i1++) {
+      if (deltaR(pfChargedHadrons_seeds[i1], pfChargedHadrons_sort[i0]) < 0.4)
+        pMatch = true;
+    }
+    if (pMatch)
+      continue;
+    pfChargedHadrons_seeds.push_back(pfChargedHadrons_sort[i0]);
+    if (int(pfChargedHadrons_seeds.size()) > fMaxTaus_ - 1)
+      break;
+  }
+  for (unsigned int i0 = 0; i0 < pfChargedHadrons_seeds.size(); i0++) {
+    addTau(pfChargedHadrons_seeds[i0], (*l1PFCandidates), lTaus);
+  }
+  if (lTaus->size() == 0) {
+    PFTau dummy;
+    lTaus->push_back(dummy);
+  }
+  std::sort(lTaus->begin(), lTaus->end(), [](l1t::PFTau i, l1t::PFTau j) { return (i.pt() > j.pt()); });
+  iEvent.put(std::move(lTaus), "L1PFTausNN");
+}
+
+// create taus based on grid structure
+void L1NNTauProducer::addTau(l1t::PFCandidate& iCand,
+                             const l1t::PFCandidateCollection& iParts,
+                             std::unique_ptr<l1t::PFTauCollection>& outputTaus) {
+  l1t::PFCandidateCollection pfTauCands;
+  TLorentzVector lTot;
+  lTot.SetPtEtaPhiM(0, 0, 0, 0);
+  TLorentzVector lCand;
+  lCand.SetPtEtaPhiM(0, 0, 0, 0);
+  int lId = 0;
+  for (auto l1PFCand : iParts) {
+    if (deltaR(iCand, l1PFCand) > fConeSize_)
+      continue;
+    TLorentzVector pVec;
+    pVec.SetPtEtaPhiM(l1PFCand.pt(), l1PFCand.eta(), l1PFCand.phi(), 0);
+    lTot += pVec;
+    if (deltaR(iCand, l1PFCand) < fTauSize_ &&
+        (l1PFCand.id() == l1t::PFCandidate::Electron || l1PFCand.id() == l1t::PFCandidate::ChargedHadron ||
+         l1PFCand.id() == l1t::PFCandidate::Photon)) {
+      lId++;
+      lCand += pVec;
+    }
+    pfTauCands.push_back(l1PFCand);
+  }
+  if (lTot.Pt() < fSeedPt_)
+    return;
+  std::sort(
+      pfTauCands.begin(), pfTauCands.end(), [](l1t::PFCandidate i, l1t::PFCandidate j) { return (i.pt() > j.pt()); });
+  float NN = fTauNNId->compute(iCand, pfTauCands);
+  math::PtEtaPhiMLorentzVector tempP4(lCand.Pt(), lCand.Eta(), lCand.Phi(), lCand.M());
+  l1t::PFTau l1PFTau(tempP4, NN, 0, lId);
+  outputTaus->push_back(l1PFTau);
+}
+float L1NNTauProducer::deltaR(auto iPart1, auto iPart2) {
+  float delta_r = 20;
+  float pDPhi = fabs(iPart1.phi() - iPart2.phi());
+  if (pDPhi > 2. * TMath::Pi() - pDPhi)
+    pDPhi = 2. * TMath::Pi() - pDPhi;
+  delta_r = sqrt((iPart1.eta() - iPart2.eta()) * (iPart1.eta() - iPart2.eta()) + pDPhi * pDPhi);
+  return delta_r;
+}
+L1NNTauProducer::~L1NNTauProducer() {}
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+DEFINE_FWK_MODULE(L1NNTauProducer);

L1Trigger/Phase2L1ParticleFlow/python/L1NNTauProducer_cff.py

@@ -0,0 +1,22 @@
+import FWCore.ParameterSet.Config as cms
+
+L1NNTauProducer = cms.EDProducer("L1NNTauProducer",
+                                 seedpt          = cms.double(20),
+                                 conesize        = cms.double(0.4),
+                                 tausize         = cms.double(0.1),
+                                 maxtaus         = cms.int32(5),
+                                 nparticles      = cms.int32(10),
+                                 L1PFObjects     = cms.InputTag("L1PFProducer","l1pfCandidates"),
+                                 NNFileName      = cms.string("L1Trigger/Phase2L1ParticleFlow/data/tau_3layer.pb")
+                                 )
+
+
+L1NNTauProducerPuppi = cms.EDProducer("L1NNTauProducer",
+                                 seedpt          = cms.double(20),
+                                 conesize        = cms.double(0.4),
+                                 tausize         = cms.double(0.1),
+                                 maxtaus         = cms.int32(5),
+                                 nparticles      = cms.int32(10),
+                                 L1PFObjects     = cms.InputTag("L1PFProducer","l1pfCandidates"),
+                                 NNFileName      = cms.string("L1Trigger/Phase2L1ParticleFlow/data/tau_3layer_puppi.pb")
+                                 )

L1Trigger/Phase2L1ParticleFlow/src/TauNNId.cc

@@ -0,0 +1,77 @@
+#include "L1Trigger/Phase2L1ParticleFlow/interface/TauNNId.h"
+#include <iostream>
+#include <cmath>
+#include <TMath.h>
+
+TauNNId::TauNNId() { NNvectorVar_.clear(); }
+TauNNId::~TauNNId() {
+  tensorflow::closeSession(session_);
+  delete graphDef_;
+}
+void TauNNId::initialize(const std::string &iInput, const std::string &iWeightFile, int iNParticles) {
+  std::string cmssw_base_src = getenv("CMSSW_BASE");
+  graphDef_ = tensorflow::loadGraphDef((cmssw_base_src + "/src/" + iWeightFile).c_str());
+  session_ = tensorflow::createSession(graphDef_);
+  fNParticles_ = iNParticles;
+  fPt_ = std::make_unique<float>(fNParticles_);
+  fEta_ = std::make_unique<float>(fNParticles_);
+  fPhi_ = std::make_unique<float>(fNParticles_);
+  fId_ = std::make_unique<float>(fNParticles_);
+  fInput_ = iInput;  //tensorflow::run(session_, { { "input_1:0",input } }, { "dense_4/Sigmoid:0" }, &outputs);
+}
+void TauNNId::SetNNVectorVar() {
+  NNvectorVar_.clear();
+  for (int i0 = 0; i0 < fNParticles_; i0++) {
+    NNvectorVar_.push_back(fPt_.get()[i0]);   //pT
+    NNvectorVar_.push_back(fEta_.get()[i0]);  //dEta from jet axis
+    NNvectorVar_.push_back(fPhi_.get()[i0]);  //dPhi from jet axis
+    if (fPt_.get()[i0] == 0) {
+      for (int i1 = 0; i1 < 5; i1++)
+        NNvectorVar_.push_back(0);
+      continue;
+    }
+    fId_.get()[i0] == l1t::PFCandidate::Photon ? NNvectorVar_.push_back(1) : NNvectorVar_.push_back(0);    //Photon
+    fId_.get()[i0] == l1t::PFCandidate::Electron ? NNvectorVar_.push_back(1) : NNvectorVar_.push_back(0);  //Electron
+    fId_.get()[i0] == l1t::PFCandidate::Muon ? NNvectorVar_.push_back(1) : NNvectorVar_.push_back(0);      //Muon
+    fId_.get()[i0] == l1t::PFCandidate::NeutralHadron ? NNvectorVar_.push_back(1)
+                                                      : NNvectorVar_.push_back(0);  //Neutral Had
+    fId_.get()[i0] == l1t::PFCandidate::ChargedHadron ? NNvectorVar_.push_back(1)
+                                                      : NNvectorVar_.push_back(0);  //Charged Had
+  }
+}
+float TauNNId::EvaluateNN() {
+  tensorflow::Tensor input(tensorflow::DT_FLOAT,
+                           {1, (unsigned int)NNvectorVar_.size()});  //was {1,35} but get size mismatch, CHECK
+  for (unsigned int i = 0; i < NNvectorVar_.size(); i++) {
+    input.matrix<float>()(0, i) = float(NNvectorVar_[i]);
+  }
+  std::vector<tensorflow::Tensor> outputs;
+  tensorflow::run(session_, {{fInput_, input}}, {"dense_4/Sigmoid:0"}, &outputs);
+  float disc = outputs[0].matrix<float>()(0, 0);
+  return disc;
+}  //end EvaluateNN
+
+float TauNNId::compute(l1t::PFCandidate &iSeed, l1t::PFCandidateCollection &iParts) {
+  for (int i0 = 0; i0 < fNParticles_; i0++) {
+    fPt_.get()[i0] = 0;
+    fEta_.get()[i0] = 0;
+    fPhi_.get()[i0] = 0;
+    fId_.get()[i0] = 0;
+  }
+  std::sort(iParts.begin(), iParts.end(), [](l1t::PFCandidate i, l1t::PFCandidate j) { return (i.pt() > j.pt()); });
+  for (unsigned int i0 = 0; i0 < iParts.size(); i0++) {
+    if (i0 > 10)
+      break;
+    fPt_.get()[i0] = iParts[i0].pt();
+    fEta_.get()[i0] = iSeed.eta() - iParts[i0].eta();
+    float lDPhi = iSeed.phi() - iParts[i0].phi();
+    if (lDPhi > TMath::Pi())
+      lDPhi -= TMath::Pi();
+    if (lDPhi < -TMath::Pi())
+      lDPhi += TMath::Pi();
+    fPhi_.get()[i0] = lDPhi;
+    fId_.get()[i0] = iParts[i0].id();
+  }
+  SetNNVectorVar();
+  return EvaluateNN();
+}