PixelJetPuId.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    PixelJetPuId
// Class:      PixelJetPuId
//
//
// Original Author:  Silvio DONATO
//         Created:  Wed Dec 18 10:05:40 CET 2013
//
//

// system include files
#include <memory>

// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/global/EDProducer.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Framework/interface/makeRefToBaseProdFrom.h"

#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"

#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/JetReco/interface/CaloJet.h"
#include "DataFormats/JetReco/interface/CaloJetCollection.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/VertexReco/interface/Vertex.h"

#include "TrackingTools/IPTools/interface/IPTools.h"
#include "TrackingTools/TransientTrack/interface/TransientTrack.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
#include "TrackingTools/Records/interface/TransientTrackRecord.h"

#include "DataFormats/Math/interface/deltaR.h"
#include "DataFormats/BTauReco/interface/JetTag.h"
#include "DataFormats/Common/interface/RefToBase.h"
//
// class declaration
//

class PixelJetPuId : public edm::global::EDProducer<> {
public:
  PixelJetPuId(const edm::ParameterSet&);
  ~PixelJetPuId() override;

  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);

private:
  void produce(edm::StreamID sid, edm::Event&, const edm::EventSetup&) const override;

  // ----------member data ---------------------------
  edm::InputTag m_primaryVertex;
  edm::InputTag m_tracks;
  edm::InputTag m_jets;
  edm::EDGetTokenT<std::vector<reco::Track> > tracksToken;
  edm::EDGetTokenT<edm::View<reco::CaloJet> > jetsToken;
  edm::EDGetTokenT<edm::View<reco::Jet> > generaljetsToken;
  edm::EDGetTokenT<reco::VertexCollection> primaryVertexToken;

  double m_MinTrackPt;
  double m_MaxTrackChi2;
  double m_MaxTrackDistanceToJet;

  bool m_fwjets;
  double m_mineta_fwjets;
  double m_minet_fwjets;

  double m_MinGoodJetTrackPt;
  double m_MinGoodJetTrackPtRatio;
};

//
// constructors and destructor
//
PixelJetPuId::PixelJetPuId(const edm::ParameterSet& iConfig) {
  //InputTag
  m_tracks = iConfig.getParameter<edm::InputTag>("tracks");
  tracksToken = consumes<std::vector<reco::Track> >(m_tracks);
  m_jets = iConfig.getParameter<edm::InputTag>("jets");
  jetsToken = consumes<edm::View<reco::CaloJet> >(m_jets);
  generaljetsToken = consumes<edm::View<reco::Jet> >(m_jets);
  m_primaryVertex = iConfig.getParameter<edm::InputTag>("primaryVertex");
  primaryVertexToken = consumes<reco::VertexCollection>(m_primaryVertex);

  //Tracks Selection
  m_MinTrackPt = iConfig.getParameter<double>("MinTrackPt");
  m_MaxTrackDistanceToJet = iConfig.getParameter<double>("MaxTrackDistanceToJet");
  m_MaxTrackChi2 = iConfig.getParameter<double>("MaxTrackChi2");

  //A jet is defined as a signal jet if Sum(trackPt) > minPt or Sum(comp.trackPt)/CaloJetPt > minPtRatio
  m_MinGoodJetTrackPt = iConfig.getParameter<double>("MinGoodJetTrackPt");
  m_MinGoodJetTrackPtRatio = iConfig.getParameter<double>("MinGoodJetTrackPtRatio");

  m_fwjets = iConfig.getParameter<bool>("UseForwardJetsAsNoPU");
  m_mineta_fwjets = iConfig.getParameter<double>("MinEtaForwardJets");
  m_minet_fwjets = iConfig.getParameter<double>("MinEtForwardJets");

  produces<std::vector<reco::CaloJet> >();
  produces<std::vector<reco::CaloJet> >("PUjets");
  produces<reco::JetTagCollection>();
}

PixelJetPuId::~PixelJetPuId() = default;

void PixelJetPuId::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("jets", edm::InputTag("hltCaloJetL1FastJetCorrected"));
  desc.add<edm::InputTag>("tracks", edm::InputTag("hltPixelTracksNoPU"));
  desc.add<edm::InputTag>("primaryVertex", edm::InputTag("hltFastPVPixelVertices"));
  desc.add<double>("MinGoodJetTrackPtRatio", 0.045);
  desc.add<double>("MinGoodJetTrackPt", 1.8);
  desc.add<double>("MaxTrackDistanceToJet", 0.04);
  desc.add<double>("MinTrackPt", 0.6);
  desc.add<double>("MaxTrackChi2", 20.);
  desc.add<bool>("UseForwardJetsAsNoPU", true);
  desc.add<double>("MinEtaForwardJets", 2.4);
  desc.add<double>("MinEtForwardJets", 40.);
  descriptions.add("pixelJetPuId", desc);
}

//
// member functions
//

// ------------ method called on each new Event  ------------
void PixelJetPuId::produce(edm::StreamID sid, edm::Event& iEvent, const edm::EventSetup& iSetup) const {
  using namespace edm;
  std::unique_ptr<std::vector<reco::CaloJet> > pOut(new std::vector<reco::CaloJet>);
  std::unique_ptr<std::vector<reco::CaloJet> > pOut_PUjets(new std::vector<reco::CaloJet>);
  std::unique_ptr<reco::JetTagCollection> pOut_jetTagCollection(new reco::JetTagCollection);

  //get tracks
  Handle<std::vector<reco::Track> > tracks;
  iEvent.getByToken(tracksToken, tracks);
  unsigned int tsize = tracks->size();
  float teta[tsize], tphi[tsize];
  unsigned int i = 0;
  for (auto const& tr : *tracks) {
    teta[i] = tr.eta();
    tphi[i] = tr.phi();
    ++i;
  }

  //get jets
  Handle<edm::View<reco::CaloJet> > jets;
  iEvent.getByToken(jetsToken, jets);

  Handle<edm::View<reco::Jet> > generaljets;
  iEvent.getByToken(generaljetsToken, generaljets);

  //get primary vertices
  Handle<reco::VertexCollection> primaryVertex;
  iEvent.getByToken(primaryVertexToken, primaryVertex);

  //get Transient Track Builder
  edm::ESHandle<TransientTrackBuilder> builder;
  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", builder);

  //init JetTagCollection
  if (!generaljets.product()->empty()) {
    edm::RefToBase<reco::Jet> jj = edm::RefToBase<reco::Jet>(generaljets, 0);
    pOut_jetTagCollection.reset(new reco::JetTagCollection(edm::makeRefToBaseProdFrom(jj, iEvent)));
  }

  //loop on trackIPTagInfos
  if (!primaryVertex->empty()) {
    const reco::Vertex* pv = &*primaryVertex->begin();
    //loop on jets
    for (edm::View<reco::CaloJet>::const_iterator itJet = jets->begin(); itJet != jets->end(); itJet++) {
      math::XYZVector jetMomentum = itJet->momentum();
      GlobalVector direction(jetMomentum.x(), jetMomentum.y(), jetMomentum.z());

      math::XYZVector trMomentum;

      if (fabs(itJet->eta()) > m_mineta_fwjets) {
        if ((m_fwjets) && (itJet->et() > m_minet_fwjets))
          pOut->push_back(*itJet);  // fill forward jet as signal jet
      } else {
        //loop on tracks
        auto itTrack = tracks->begin();
        for (unsigned int i = 0; i < tsize; ++i) {
          float deltaR2 = reco::deltaR2(itJet->eta(), itJet->phi(), teta[i], tphi[i]);
          if (deltaR2 < 0.25) {
            reco::TransientTrack transientTrack = builder->build(*itTrack);
            float jetTrackDistance = -((IPTools::jetTrackDistance(transientTrack, direction, *pv)).second).value();

            //select the tracks compabible with the jet
            if ((itTrack->pt() > m_MinTrackPt) && (itTrack->normalizedChi2() < m_MaxTrackChi2) &&
                (jetTrackDistance < m_MaxTrackDistanceToJet)) {
              trMomentum += itTrack->momentum();  //calculate the Sum(trackPt)
            }
          }
          itTrack++;
        }
        //if Sum(comp.trackPt)/CaloJetPt > minPtRatio or Sum(trackPt) > minPt  the jet is a signal jet
        if (trMomentum.rho() / jetMomentum.rho() > m_MinGoodJetTrackPtRatio || trMomentum.rho() > m_MinGoodJetTrackPt) {
          pOut->push_back(*itJet);  // fill it as signal jet
        } else                      //else it is a PUjet
        {
          pOut_PUjets->push_back(*itJet);  // fill it as PUjets
        }
      }
      RefToBase<reco::Jet> jRef(generaljets, itJet - jets->begin());
      (*pOut_jetTagCollection)[jRef] = trMomentum.rho();  // fill jetTagCollection
    }
  }
  iEvent.put(std::move(pOut));
  iEvent.put(std::move(pOut_PUjets), "PUjets");
  iEvent.put(std::move(pOut_jetTagCollection));
}

// declare this class as a framework plugin
DEFINE_FWK_MODULE(PixelJetPuId);