PATJetSelector.h

Go to the documentation of this file.

//
//
 
#ifndef PhysicsTools_PatAlgos_PATJetSelector_h
#define PhysicsTools_PatAlgos_PATJetSelector_h
 
#include "FWCore/Framework/interface/stream/EDFilter.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
 
#include "DataFormats/Common/interface/RefVector.h"
 
#include "CommonTools/UtilAlgos/interface/StringCutObjectSelector.h"
#include "CommonTools/UtilAlgos/interface/SingleObjectSelector.h"
#include "CommonTools/UtilAlgos/interface/ObjectSelector.h"
#include "CommonTools/UtilAlgos/interface/SingleElementCollectionSelector.h"
 
#include "DataFormats/PatCandidates/interface/Jet.h"
 
#include <vector>
 
namespace pat {
 
  class PATJetSelector : public edm::stream::EDFilter<> {
  public:
    PATJetSelector(edm::ParameterSet const& params)
        : srcToken_(consumes<edm::View<pat::Jet>>(params.getParameter<edm::InputTag>("src"))),
          cut_(params.getParameter<std::string>("cut")),
          cutLoose_(params.getParameter<std::string>("cutLoose")),
          filter_(params.exists("filter") ? params.getParameter<bool>("filter") : false),
          nLoose_(params.getParameter<unsigned>("nLoose")),
          selector_(cut_),
          selectorLoose_(cutLoose_) {
      produces<std::vector<pat::Jet>>();
      produces<reco::GenJetCollection>("genJets");
      produces<std::vector<CaloTower>>("caloTowers");
      produces<reco::PFCandidateCollection>("pfCandidates");
      produces<edm::OwnVector<reco::BaseTagInfo>>("tagInfos");
    }
 
    ~PATJetSelector() override {}
 
    virtual void beginJob() {}
    virtual void endJob() {}
 
    bool filter(edm::Event& iEvent, const edm::EventSetup& iSetup) override {
      auto patJets = std::make_unique<std::vector<Jet>>();
 
      auto genJetsOut = std::make_unique<reco::GenJetCollection>();
      auto caloTowersOut = std::make_unique<std::vector<CaloTower>>();
      auto pfCandidatesOut = std::make_unique<reco::PFCandidateCollection>();
      auto tagInfosOut = std::make_unique<edm::OwnVector<reco::BaseTagInfo>>();
 
      edm::RefProd<reco::GenJetCollection> h_genJetsOut = iEvent.getRefBeforePut<reco::GenJetCollection>("genJets");
      edm::RefProd<std::vector<CaloTower>> h_caloTowersOut =
          iEvent.getRefBeforePut<std::vector<CaloTower>>("caloTowers");
      edm::RefProd<reco::PFCandidateCollection> h_pfCandidatesOut =
          iEvent.getRefBeforePut<reco::PFCandidateCollection>("pfCandidates");
      edm::RefProd<edm::OwnVector<reco::BaseTagInfo>> h_tagInfosOut =
          iEvent.getRefBeforePut<edm::OwnVector<reco::BaseTagInfo>>("tagInfos");
 
      edm::Handle<edm::View<pat::Jet>> h_jets;
      iEvent.getByToken(srcToken_, h_jets);
 
      unsigned nl = 0;  // number of loose jets
      // First loop over the products and make the secondary output collections
      for (edm::View<pat::Jet>::const_iterator ibegin = h_jets->begin(), iend = h_jets->end(), ijet = ibegin;
           ijet != iend;
           ++ijet) {
        bool selectedLoose = false;
        if (nLoose_ > 0 && nl < nLoose_ && selectorLoose_(*ijet)) {
          selectedLoose = true;
          ++nl;
        }
 
        if (selector_(*ijet) || selectedLoose) {
          // Copy over the calo towers
          for (CaloTowerFwdPtrVector::const_iterator itowerBegin = ijet->caloTowersFwdPtr().begin(),
                                                     itowerEnd = ijet->caloTowersFwdPtr().end(),
                                                     itower = itowerBegin;
               itower != itowerEnd;
               ++itower) {
            // Add to global calo tower list
            caloTowersOut->push_back(**itower);
          }
 
          // Copy over the pf candidates
          for (reco::PFCandidateFwdPtrVector::const_iterator icandBegin = ijet->pfCandidatesFwdPtr().begin(),
                                                             icandEnd = ijet->pfCandidatesFwdPtr().end(),
                                                             icand = icandBegin;
               icand != icandEnd;
               ++icand) {
            // Add to global pf candidate list
            pfCandidatesOut->push_back(**icand);
          }
 
          // Copy the tag infos
          for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = ijet->tagInfosFwdPtr().begin(),
                                                       iinfoEnd = ijet->tagInfosFwdPtr().end(),
                                                       iinfo = iinfoBegin;
               iinfo != iinfoEnd;
               ++iinfo) {
            // Add to global calo tower list
            tagInfosOut->push_back(**iinfo);
          }
 
          // Copy the gen jet
          if (ijet->genJet() != nullptr) {
            genJetsOut->push_back(*(ijet->genJet()));
          }
        }
      }
 
      // Output the secondary collections.
      edm::OrphanHandle<reco::GenJetCollection> oh_genJetsOut = iEvent.put(std::move(genJetsOut), "genJets");
      edm::OrphanHandle<std::vector<CaloTower>> oh_caloTowersOut = iEvent.put(std::move(caloTowersOut), "caloTowers");
      edm::OrphanHandle<reco::PFCandidateCollection> oh_pfCandidatesOut =
          iEvent.put(std::move(pfCandidatesOut), "pfCandidates");
      edm::OrphanHandle<edm::OwnVector<reco::BaseTagInfo>> oh_tagInfosOut =
          iEvent.put(std::move(tagInfosOut), "tagInfos");
 
      unsigned int caloTowerIndex = 0;
      unsigned int pfCandidateIndex = 0;
      unsigned int tagInfoIndex = 0;
      unsigned int genJetIndex = 0;
      // Now set the Ptrs with the orphan handles.
      nl = 0;  // Reset number of loose jets
      for (edm::View<pat::Jet>::const_iterator ibegin = h_jets->begin(), iend = h_jets->end(), ijet = ibegin;
           ijet != iend;
           ++ijet) {
        bool selectedLoose = false;
        if (nLoose_ > 0 && nl < nLoose_ && selectorLoose_(*ijet)) {
          selectedLoose = true;
          ++nl;
        }
 
        if (selector_(*ijet) || selectedLoose) {
          // Add the jets that pass to the output collection
          patJets->push_back(*ijet);
 
          // Copy over the calo towers
          for (CaloTowerFwdPtrVector::const_iterator itowerBegin = ijet->caloTowersFwdPtr().begin(),
                                                     itowerEnd = ijet->caloTowersFwdPtr().end(),
                                                     itower = itowerBegin;
               itower != itowerEnd;
               ++itower) {
            // Update the "forward" bit of the FwdPtr to point at the new tower collection.
 
            //  ptr to "this" tower in the global list
            edm::Ptr<CaloTower> outPtr(oh_caloTowersOut, caloTowerIndex);
            patJets->back().updateFwdCaloTowerFwdPtr(itower - itowerBegin,  // index of "this" tower in the jet
                                                     outPtr);
            ++caloTowerIndex;
          }
 
          // Copy over the pf candidates
          for (reco::PFCandidateFwdPtrVector::const_iterator icandBegin = ijet->pfCandidatesFwdPtr().begin(),
                                                             icandEnd = ijet->pfCandidatesFwdPtr().end(),
                                                             icand = icandBegin;
               icand != icandEnd;
               ++icand) {
            // Update the "forward" bit of the FwdPtr to point at the new tower collection.
 
            // ptr to "this" cand in the global list
            edm::Ptr<reco::PFCandidate> outPtr(oh_pfCandidatesOut, pfCandidateIndex);
            patJets->back().updateFwdPFCandidateFwdPtr(icand - icandBegin,  // index of "this" tower in the jet
                                                       outPtr);
            ++pfCandidateIndex;
          }
 
          // Copy the tag infos
          for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = ijet->tagInfosFwdPtr().begin(),
                                                       iinfoEnd = ijet->tagInfosFwdPtr().end(),
                                                       iinfo = iinfoBegin;
               iinfo != iinfoEnd;
               ++iinfo) {
            // Update the "forward" bit of the FwdPtr to point at the new tower collection.
 
            // ptr to "this" info in the global list
            edm::Ptr<reco::BaseTagInfo> outPtr(oh_tagInfosOut, tagInfoIndex);
            patJets->back().updateFwdTagInfoFwdPtr(iinfo - iinfoBegin,  // index of "this" tower in the jet
                                                   outPtr);
            ++tagInfoIndex;
          }
 
          // Copy the gen jet
          if (ijet->genJet() != nullptr) {
            patJets->back().updateFwdGenJetFwdRef(
                edm::Ref<reco::GenJetCollection>(oh_genJetsOut, genJetIndex)  // ref to "this" genjet in the global list
            );
            ++genJetIndex;
          }
        }
      }
 
      // put genEvt  in Event
      bool pass = !patJets->empty();
      iEvent.put(std::move(patJets));
 
      if (filter_)
        return pass;
      else
        return true;
    }
 
    static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
      edm::ParameterSetDescription iDesc;
      iDesc.setComment("Energy Correlation Functions adder");
      iDesc.add<edm::InputTag>("src", edm::InputTag("no default"))->setComment("input collection");
      iDesc.add<std::string>("cut", "")->setComment("Jet selection.");
      iDesc.add<std::string>("cutLoose", "")->setComment("Loose jet selection. Will keep nLoose loose jets.");
      iDesc.add<bool>("filter", false)->setComment("Filter selection?");
      iDesc.add<unsigned>("nLoose", 0)->setComment("Keep nLoose loose jets that satisfy cutLoose");
      descriptions.add("PATJetSelector", iDesc);
    }
 
  protected:
    const edm::EDGetTokenT<edm::View<pat::Jet>> srcToken_;
    const std::string cut_;
    const std::string cutLoose_;  // Cut to define loose jets.
    const bool filter_;
    const unsigned nLoose_;  // If desired, keep nLoose loose jets.
    const StringCutObjectSelector<Jet> selector_;
    const StringCutObjectSelector<Jet> selectorLoose_;  // Selector for loose jets.
  };
 
}  // namespace pat
 
#endif