TriggerObjectTableProducer.cc

Go to the documentation of this file.

// system include files
#include <memory>
#include <sstream>
 
// user include files
#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 "DataFormats/PatCandidates/interface/TriggerObjectStandAlone.h"
#include "DataFormats/L1Trigger/interface/EGamma.h"
#include "DataFormats/L1Trigger/interface/Tau.h"
#include "DataFormats/L1Trigger/interface/Jet.h"
#include "DataFormats/L1Trigger/interface/Muon.h"
#include "DataFormats/L1Trigger/interface/EtSum.h"
#include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
#include "CommonTools/Utils/interface/StringCutObjectSelector.h"
#include "CommonTools/Utils/interface/StringObjectFunction.h"
#include "DataFormats/Math/interface/deltaR.h"
#include "DataFormats/NanoAOD/interface/FlatTable.h"
 
class TriggerObjectTableProducer : public edm::stream::EDProducer<> {
public:
  explicit TriggerObjectTableProducer(const edm::ParameterSet &iConfig)
      : name_(iConfig.getParameter<std::string>("name")),
        src_(consumes<std::vector<pat::TriggerObjectStandAlone>>(iConfig.getParameter<edm::InputTag>("src"))),
        l1EG_(consumes<l1t::EGammaBxCollection>(iConfig.getParameter<edm::InputTag>("l1EG"))),
        l1Sum_(consumes<l1t::EtSumBxCollection>(iConfig.getParameter<edm::InputTag>("l1Sum"))),
        l1Jet_(consumes<l1t::JetBxCollection>(iConfig.getParameter<edm::InputTag>("l1Jet"))),
        l1Muon_(consumes<l1t::MuonBxCollection>(iConfig.getParameter<edm::InputTag>("l1Muon"))),
        l1Tau_(consumes<l1t::TauBxCollection>(iConfig.getParameter<edm::InputTag>("l1Tau"))) {
    std::vector<edm::ParameterSet> selPSets = iConfig.getParameter<std::vector<edm::ParameterSet>>("selections");
    sels_.reserve(selPSets.size());
    std::stringstream idstr, qualitystr;
    idstr << "ID of the object: ";
    for (auto &pset : selPSets) {
      sels_.emplace_back(pset);
      idstr << sels_.back().id << " = " << sels_.back().name;
      if (sels_.size() < selPSets.size())
        idstr << ", ";
      if (!sels_.back().qualityBitsDoc.empty()) {
        qualitystr << sels_.back().qualityBitsDoc << " for " << sels_.back().name << "; ";
      }
    }
    idDoc_ = idstr.str();
    bitsDoc_ = qualitystr.str();
 
    produces<nanoaod::FlatTable>();
  }
 
  ~TriggerObjectTableProducer() override {}
 
private:
  void produce(edm::Event &, edm::EventSetup const &) override;
 
  std::string name_;
  edm::EDGetTokenT<std::vector<pat::TriggerObjectStandAlone>> src_;
  std::string idDoc_, bitsDoc_;
 
  edm::EDGetTokenT<l1t::EGammaBxCollection> l1EG_;
  edm::EDGetTokenT<l1t::EtSumBxCollection> l1Sum_;
  edm::EDGetTokenT<l1t::JetBxCollection> l1Jet_;
  edm::EDGetTokenT<l1t::MuonBxCollection> l1Muon_;
  edm::EDGetTokenT<l1t::TauBxCollection> l1Tau_;
 
  struct SelectedObject {
    std::string name;
    int id;
    StringCutObjectSelector<pat::TriggerObjectStandAlone> cut;
    StringCutObjectSelector<pat::TriggerObjectStandAlone> l1cut, l1cut_2, l2cut;
    float l1DR2, l1DR2_2, l2DR2;
    bool skipObjectsNotPassingQualityBits;
    StringObjectFunction<pat::TriggerObjectStandAlone> qualityBits;
    std::string qualityBitsDoc;
 
    SelectedObject(const edm::ParameterSet &pset)
        : name(pset.getParameter<std::string>("name")),
          id(pset.getParameter<int>("id")),
          cut(pset.getParameter<std::string>("sel")),
          l1cut(""),
          l1cut_2(""),
          l2cut(""),
          l1DR2(-1),
          l1DR2_2(-1),
          l2DR2(-1),
          skipObjectsNotPassingQualityBits(pset.getParameter<bool>("skipObjectsNotPassingQualityBits")),
          qualityBits(pset.getParameter<std::string>("qualityBits")),
          qualityBitsDoc(pset.getParameter<std::string>("qualityBitsDoc")) {
      if (pset.existsAs<std::string>("l1seed")) {
        l1cut = StringCutObjectSelector<pat::TriggerObjectStandAlone>(pset.getParameter<std::string>("l1seed"));
        l1DR2 = std::pow(pset.getParameter<double>("l1deltaR"), 2);
      }
      if (pset.existsAs<std::string>("l1seed_2")) {
        l1cut_2 = StringCutObjectSelector<pat::TriggerObjectStandAlone>(pset.getParameter<std::string>("l1seed_2"));
        l1DR2_2 = std::pow(pset.getParameter<double>("l1deltaR_2"), 2);
      }
      if (pset.existsAs<std::string>("l2seed")) {
        l2cut = StringCutObjectSelector<pat::TriggerObjectStandAlone>(pset.getParameter<std::string>("l2seed"));
        l2DR2 = std::pow(pset.getParameter<double>("l2deltaR"), 2);
      }
    }
 
    bool match(const pat::TriggerObjectStandAlone &obj) const { return cut(obj); }
  };
 
  std::vector<SelectedObject> sels_;
};
 
// ------------ method called to produce the data  ------------
void TriggerObjectTableProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) {
  edm::Handle<std::vector<pat::TriggerObjectStandAlone>> src;
  iEvent.getByToken(src_, src);
 
  std::vector<std::pair<const pat::TriggerObjectStandAlone *, const SelectedObject *>> selected;
  for (const auto &obj : *src) {
    for (const auto &sel : sels_) {
      if (sel.match(obj) && (sel.skipObjectsNotPassingQualityBits ? (int(sel.qualityBits(obj)) > 0) : true)) {
        selected.emplace_back(&obj, &sel);
        break;
      }
    }
  }
 
  // Self-cleaning
  std::map<const pat::TriggerObjectStandAlone *, int> selected_bits;
  for (unsigned int i = 0; i < selected.size(); ++i) {
    const auto &obj = *selected[i].first;
    const auto &sel = *selected[i].second;
    selected_bits[&obj] = int(sel.qualityBits(obj));
 
    for (unsigned int j = 0; j < i; ++j) {
      const auto &obj2 = *selected[j].first;
      const auto &sel2 = *selected[j].second;
      if (sel.id == sel2.id && abs(obj.pt() - obj2.pt()) < 1e-6 && deltaR2(obj, obj2) < 1e-6) {
        selected_bits[&obj2] |= selected_bits[&obj];  //Keep filters from all the objects
        selected.erase(selected.begin() + i);
        i--;
      }
    }
  }
 
  edm::Handle<l1t::EGammaBxCollection> l1EG;
  edm::Handle<l1t::EtSumBxCollection> l1Sum;
  edm::Handle<l1t::JetBxCollection> l1Jet;
  edm::Handle<l1t::MuonBxCollection> l1Muon;
  edm::Handle<l1t::TauBxCollection> l1Tau;
  iEvent.getByToken(l1EG_, l1EG);
  iEvent.getByToken(l1Sum_, l1Sum);
  iEvent.getByToken(l1Jet_, l1Jet);
  iEvent.getByToken(l1Muon_, l1Muon);
  iEvent.getByToken(l1Tau_, l1Tau);
 
  std::vector<pair<pat::TriggerObjectStandAlone, int>> l1Objects;
 
  for (l1t::EGammaBxCollection::const_iterator it = l1EG->begin(0); it != l1EG->end(0); it++) {
    pat::TriggerObjectStandAlone l1obj(it->p4());
    l1obj.setCollection("L1EG");
    l1obj.addTriggerObjectType(trigger::TriggerL1EG);
    l1Objects.emplace_back(l1obj, it->hwIso());
  }
 
  for (l1t::EtSumBxCollection::const_iterator it = l1Sum->begin(0); it != l1Sum->end(0); it++) {
    pat::TriggerObjectStandAlone l1obj(it->p4());
 
    switch (it->getType()) {
      case l1t::EtSum::EtSumType::kMissingEt:
        l1obj.addTriggerObjectType(trigger::TriggerL1ETM);
        l1obj.setCollection("L1ETM");
        break;
 
      case l1t::EtSum::EtSumType::kMissingEtHF:
        l1obj.addTriggerObjectType(trigger::TriggerL1ETM);
        l1obj.setCollection("L1ETMHF");
        break;
 
      case l1t::EtSum::EtSumType::kTotalEt:
        l1obj.addTriggerObjectType(trigger::TriggerL1ETT);
        l1obj.setCollection("L1ETT");
        break;
 
      case l1t::EtSum::EtSumType::kTotalEtEm:
        l1obj.addTriggerObjectType(trigger::TriggerL1ETT);
        l1obj.setCollection("L1ETEm");
        break;
 
      case l1t::EtSum::EtSumType::kTotalHt:
        l1obj.addTriggerObjectType(trigger::TriggerL1HTT);
        l1obj.setCollection("L1HTT");
        break;
 
      case l1t::EtSum::EtSumType::kTotalHtHF:
        l1obj.addTriggerObjectType(trigger::TriggerL1HTT);
        l1obj.setCollection("L1HTTHF");
        break;
 
      case l1t::EtSum::EtSumType::kMissingHt:
        l1obj.addTriggerObjectType(trigger::TriggerL1HTM);
        l1obj.setCollection("L1HTM");
        break;
 
      case l1t::EtSum::EtSumType::kMissingHtHF:
        l1obj.addTriggerObjectType(trigger::TriggerL1HTM);
        l1obj.setCollection("L1HTMHF");
        break;
 
      default:
        continue;
    }
 
    l1Objects.emplace_back(l1obj, it->hwIso());
  }
 
  for (l1t::JetBxCollection::const_iterator it = l1Jet->begin(0); it != l1Jet->end(0); it++) {
    pat::TriggerObjectStandAlone l1obj(it->p4());
    l1obj.setCollection("L1Jet");
    l1obj.addTriggerObjectType(trigger::TriggerL1Jet);
    l1Objects.emplace_back(l1obj, it->hwIso());
  }
 
  for (l1t::MuonBxCollection::const_iterator it = l1Muon->begin(0); it != l1Muon->end(0); it++) {
    pat::TriggerObjectStandAlone l1obj(it->p4());
    l1obj.setCollection("L1Mu");
    l1obj.addTriggerObjectType(trigger::TriggerL1Mu);
    l1obj.setCharge(it->charge());
    l1Objects.emplace_back(l1obj, it->hwIso());
  }
 
  for (l1t::TauBxCollection::const_iterator it = l1Tau->begin(0); it != l1Tau->end(0); it++) {
    pat::TriggerObjectStandAlone l1obj(it->p4());
    l1obj.setCollection("L1Tau");
    l1obj.addTriggerObjectType(trigger::TriggerL1Tau);
    l1Objects.emplace_back(l1obj, it->hwIso());
  }
 
  unsigned int nobj = selected.size();
  std::vector<float> pt(nobj, 0), eta(nobj, 0), phi(nobj, 0), l1pt(nobj, 0), l1pt_2(nobj, 0), l2pt(nobj, 0);
  std::vector<int> id(nobj, 0), bits(nobj, 0), l1iso(nobj, 0), l1charge(nobj, 0);
  for (unsigned int i = 0; i < nobj; ++i) {
    const auto &obj = *selected[i].first;
    const auto &sel = *selected[i].second;
    pt[i] = obj.pt();
    eta[i] = obj.eta();
    phi[i] = obj.phi();
    id[i] = sel.id;
    bits[i] = selected_bits[&obj];
    if (sel.l1DR2 > 0) {
      float best = sel.l1DR2;
      for (const auto &l1obj : l1Objects) {
        const auto &seed = l1obj.first;
        float dr2 = deltaR2(seed, obj);
        if (dr2 < best && sel.l1cut(seed)) {
          l1pt[i] = seed.pt();
          l1iso[i] = l1obj.second;
          l1charge[i] = seed.charge();
        }
      }
    }
    if (sel.l1DR2_2 > 0) {
      float best = sel.l1DR2_2;
      for (const auto &l1obj : l1Objects) {
        const auto &seed = l1obj.first;
        float dr2 = deltaR2(seed, obj);
        if (dr2 < best && sel.l1cut_2(seed)) {
          l1pt_2[i] = seed.pt();
        }
      }
    }
    if (sel.l2DR2 > 0) {
      float best = sel.l2DR2;
      for (const auto &seed : *src) {
        float dr2 = deltaR2(seed, obj);
        if (dr2 < best && sel.l2cut(seed)) {
          l2pt[i] = seed.pt();
        }
      }
    }
  }
 
  auto tab = std::make_unique<nanoaod::FlatTable>(nobj, name_, false, false);
  tab->addColumn<int>("id", id, idDoc_, nanoaod::FlatTable::IntColumn);
  tab->addColumn<float>("pt", pt, "pt", nanoaod::FlatTable::FloatColumn, 12);
  tab->addColumn<float>("eta", eta, "eta", nanoaod::FlatTable::FloatColumn, 12);
  tab->addColumn<float>("phi", phi, "phi", nanoaod::FlatTable::FloatColumn, 12);
  tab->addColumn<float>("l1pt", l1pt, "pt of associated L1 seed", nanoaod::FlatTable::FloatColumn, 8);
  tab->addColumn<int>("l1iso", l1iso, "iso of associated L1 seed", nanoaod::FlatTable::IntColumn);
  tab->addColumn<int>("l1charge", l1charge, "charge of associated L1 seed", nanoaod::FlatTable::IntColumn);
  tab->addColumn<float>("l1pt_2", l1pt_2, "pt of associated secondary L1 seed", nanoaod::FlatTable::FloatColumn, 8);
  tab->addColumn<float>(
      "l2pt", l2pt, "pt of associated 'L2' seed (i.e. HLT before tracking/PF)", nanoaod::FlatTable::FloatColumn, 10);
  tab->addColumn<int>(
      "filterBits", bits, "extra bits of associated information: " + bitsDoc_, nanoaod::FlatTable::IntColumn);
  iEvent.put(std::move(tab));
}
 
//define this as a plug-in
DEFINE_FWK_MODULE(TriggerObjectTableProducer);