HLTTrackMETProducer.cc

Go to the documentation of this file.

#include "HLTrigger/JetMET/interface/HLTTrackMETProducer.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
#include "DataFormats/Common/interface/Handle.h"

// Constructor
HLTTrackMETProducer::HLTTrackMETProducer(const edm::ParameterSet& iConfig)
    : usePt_(iConfig.getParameter<bool>("usePt")),
      useTracks_(iConfig.getParameter<bool>("useTracks")),
      usePFRecTracks_(iConfig.getParameter<bool>("usePFRecTracks")),
      usePFCandidatesCharged_(iConfig.getParameter<bool>("usePFCandidatesCharged")),
      usePFCandidates_(iConfig.getParameter<bool>("usePFCandidates")),
      excludePFMuons_(iConfig.getParameter<bool>("excludePFMuons")),
      minNJet_(iConfig.getParameter<int>("minNJet")),
      minPtJet_(iConfig.getParameter<double>("minPtJet")),
      maxEtaJet_(iConfig.getParameter<double>("maxEtaJet")),
      jetsLabel_(iConfig.getParameter<edm::InputTag>("jetsLabel")),
      tracksLabel_(iConfig.getParameter<edm::InputTag>("tracksLabel")),
      pfRecTracksLabel_(iConfig.getParameter<edm::InputTag>("pfRecTracksLabel")),
      pfCandidatesLabel_(iConfig.getParameter<edm::InputTag>("pfCandidatesLabel")) {
  m_theJetToken = consumes<edm::View<reco::Jet>>(jetsLabel_);
  m_theTrackToken = consumes<reco::TrackCollection>(tracksLabel_);
  m_theRecTrackToken = consumes<reco::PFRecTrackCollection>(pfRecTracksLabel_);
  m_thePFCandidateToken = consumes<reco::PFCandidateCollection>(pfCandidatesLabel_);

  // Register the products
  produces<reco::METCollection>();
}

// Destructor
HLTTrackMETProducer::~HLTTrackMETProducer() = default;

// Fill descriptions
void HLTTrackMETProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  // Current default is for hltPFMET
  edm::ParameterSetDescription desc;
  desc.add<bool>("usePt", true);
  desc.add<bool>("useTracks", false);
  desc.add<bool>("usePFRecTracks", false);
  desc.add<bool>("usePFCandidatesCharged", true);
  desc.add<bool>("usePFCandidates", false);
  desc.add<bool>("excludePFMuons", false);
  desc.add<int>("minNJet", 0);
  desc.add<double>("minPtJet", 0.);
  desc.add<double>("maxEtaJet", 999.);
  desc.add<edm::InputTag>("jetsLabel", edm::InputTag("hltAntiKT4PFJets"));
  desc.add<edm::InputTag>("tracksLabel", edm::InputTag("hltL3Muons"));
  desc.add<edm::InputTag>("pfRecTracksLabel", edm::InputTag("hltLightPFTracks"));
  desc.add<edm::InputTag>("pfCandidatesLabel", edm::InputTag("hltParticleFlow"));
  descriptions.add("hltTrackMETProducer", desc);
}

// Produce the products
void HLTTrackMETProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  // Create a pointer to the products
  std::unique_ptr<reco::METCollection> result(new reco::METCollection());

  if (pfCandidatesLabel_.label().empty())
    excludePFMuons_ = false;

  bool useJets = !useTracks_ && !usePFRecTracks_ && !usePFCandidatesCharged_ && !usePFCandidates_;
  if (!useJets) {
    minNJet_ = 0;
  }

  edm::Handle<reco::JetView> jets;
  if (useJets)
    iEvent.getByToken(m_theJetToken, jets);

  edm::Handle<reco::TrackCollection> tracks;
  if (useTracks_)
    iEvent.getByToken(m_theTrackToken, tracks);

  edm::Handle<reco::PFRecTrackCollection> pfRecTracks;
  if (usePFRecTracks_)
    iEvent.getByToken(m_theRecTrackToken, pfRecTracks);

  edm::Handle<reco::PFCandidateCollection> pfCandidates;
  if (excludePFMuons_ || usePFCandidatesCharged_ || usePFCandidates_)
    iEvent.getByToken(m_thePFCandidateToken, pfCandidates);

  int nj = 0;
  double sumet = 0., mhx = 0., mhy = 0.;

  if (useJets && !jets->empty()) {
    for (reco::JetView::const_iterator j = jets->begin(); j != jets->end(); ++j) {
      double pt = usePt_ ? j->pt() : j->et();
      double eta = j->eta();
      double phi = j->phi();
      double px = usePt_ ? j->px() : j->et() * cos(phi);
      double py = usePt_ ? j->py() : j->et() * sin(phi);

      if (pt > minPtJet_ && std::abs(eta) < maxEtaJet_) {
        mhx -= px;
        mhy -= py;
        sumet += pt;
        ++nj;
      }
    }

  } else if (useTracks_ && !tracks->empty()) {
    for (auto const& j : *tracks) {
      double pt = j.pt();
      double px = j.px();
      double py = j.py();
      double eta = j.eta();

      if (pt > minPtJet_ && std::abs(eta) < maxEtaJet_) {
        mhx -= px;
        mhy -= py;
        sumet += pt;
        ++nj;
      }
    }

  } else if (usePFRecTracks_ && !pfRecTracks->empty()) {
    for (auto const& j : *pfRecTracks) {
      double pt = j.trackRef()->pt();
      double px = j.trackRef()->px();
      double py = j.trackRef()->py();
      double eta = j.trackRef()->eta();

      if (pt > minPtJet_ && std::abs(eta) < maxEtaJet_) {
        mhx -= px;
        mhy -= py;
        sumet += pt;
        ++nj;
      }
    }

  } else if ((usePFCandidatesCharged_ || usePFCandidates_) && !pfCandidates->empty()) {
    for (auto const& j : *pfCandidates) {
      if (usePFCandidatesCharged_ && j.charge() == 0)
        continue;
      double pt = j.pt();
      double px = j.px();
      double py = j.py();
      double eta = j.eta();

      if (pt > minPtJet_ && std::abs(eta) < maxEtaJet_) {
        mhx -= px;
        mhy -= py;
        sumet += pt;
        ++nj;
      }
    }
  }

  if (excludePFMuons_) {
    for (auto const& j : *pfCandidates) {
      if (std::abs(j.pdgId()) == 13) {
        mhx += j.px();
        mhy += j.py();
      }
    }
  }

  if (nj < minNJet_) {
    sumet = 0;
    mhx = 0;
    mhy = 0;
  }

  reco::MET::LorentzVector p4(mhx, mhy, 0, sqrt(mhx * mhx + mhy * mhy));
  reco::MET::Point vtx(0, 0, 0);
  reco::MET mht(sumet, p4, vtx);
  result->push_back(mht);

  // Put the products into the Event
  iEvent.put(std::move(result));
}