MatcherUsingTracks.cc

Go to the documentation of this file.

//
//
 
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Utilities/interface/InputTag.h"
 
#include "DataFormats/Common/interface/Association.h"
#include "DataFormats/Common/interface/ValueMap.h"
 
#include "DataFormats/Candidate/interface/Candidate.h"
 
#include "DataFormats/PatCandidates/interface/UserData.h"
 
#include "MuonAnalysis/MuonAssociators/interface/MatcherUsingTracksAlgorithm.h"
 
// template-related workaround for bug in OwnVector+Ptr
namespace edm {
  using std::advance;
}
 
namespace pat {
 
  class MatcherUsingTracks : public edm::EDProducer {
  public:
    explicit MatcherUsingTracks(const edm::ParameterSet &iConfig);
    ~MatcherUsingTracks() override {}
 
    void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override;
 
  private:
    edm::EDGetTokenT<edm::View<reco::Candidate> > srcToken_;
    edm::EDGetTokenT<edm::View<reco::Candidate> > matchedToken_;
 
    MatcherUsingTracksAlgorithm algo_;
 
    bool dontFailOnMissingInput_;
    bool writeExtraPATOutput_;
 
    template <typename T>
    void storeValueMap(edm::Event &iEvent,
                       const edm::Handle<edm::View<reco::Candidate> > &handle,
                       const std::vector<T> &values,
                       const std::string &label) const;
  };
 
}  // namespace pat
 
pat::MatcherUsingTracks::MatcherUsingTracks(const edm::ParameterSet &iConfig)
    : srcToken_(consumes<edm::View<reco::Candidate> >(iConfig.getParameter<edm::InputTag>("src"))),
      matchedToken_(consumes<edm::View<reco::Candidate> >(iConfig.getParameter<edm::InputTag>("matched"))),
      algo_(iConfig),
      dontFailOnMissingInput_(iConfig.existsAs<bool>("dontFailOnMissingInput")
                                  ? iConfig.getParameter<bool>("dontFailOnMissingInput")
                                  : false),
      writeExtraPATOutput_(
          iConfig.existsAs<bool>("writeExtraPATOutput") ? iConfig.getParameter<bool>("writeExtraPATOutput") : false) {
  // this is the basic output (edm::Association is not generic)
  produces<edm::ValueMap<reco::CandidatePtr> >();
  if (writeExtraPATOutput_) {
    // this is the crazy stuff to get the same with UserData
    produces<edm::OwnVector<pat::UserData> >();
    produces<edm::ValueMap<edm::Ptr<pat::UserData> > >();
  }
  // this is the extra stuff
  if (algo_.hasMetrics()) {
    produces<edm::ValueMap<float> >("deltaR");
    produces<edm::ValueMap<float> >("deltaEta");
    produces<edm::ValueMap<float> >("deltaPhi");
    produces<edm::ValueMap<float> >("deltaLocalPos");
    produces<edm::ValueMap<float> >("deltaPtRel");
    if (algo_.hasChi2()) {
      produces<edm::ValueMap<float> >("chi2");
    }
  } else {
    produces<edm::ValueMap<int> >("matched");
  }
}
 
void pat::MatcherUsingTracks::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) {
  using namespace edm;
  using namespace std;
 
  algo_.init(iSetup);
 
  Handle<View<reco::Candidate> > src, matched;
 
  iEvent.getByToken(srcToken_, src);
  iEvent.getByToken(matchedToken_, matched);
 
  // declare loop variables and some intermediate stuff
  View<reco::Candidate>::const_iterator itsrc, edsrc;
  int isrc, nsrc = src->size();
 
  // working and output variables
  vector<int> match(nsrc, -1);
  vector<float> deltaRs(nsrc, 999);
  vector<float> deltaEtas(nsrc, 999);
  vector<float> deltaPhis(nsrc, 999);
  vector<float> deltaPtRel(nsrc, 999);
  vector<float> deltaLocalPos(nsrc, 999);
  vector<float> chi2(nsrc, 999999);
 
  // don't try matching if the input collection is missing and the module is configured to fail silently
  if (!(matched.failedToGet() && dontFailOnMissingInput_)) {
    // loop on the source collection, and request for the match
    for (itsrc = src->begin(), edsrc = src->end(), isrc = 0; itsrc != edsrc; ++itsrc, ++isrc) {
      match[isrc] = algo_.match(*itsrc,
                                *matched,
                                deltaRs[isrc],
                                deltaEtas[isrc],
                                deltaPhis[isrc],
                                deltaLocalPos[isrc],
                                deltaPtRel[isrc],
                                chi2[isrc]);
    }
  }
 
  std::vector<reco::CandidatePtr> ptrs(nsrc);
  for (isrc = 0; isrc < nsrc; ++isrc) {
    if (match[isrc] != -1) {
      ptrs[isrc] = matched->ptrAt(match[isrc]);
    }
  }
  storeValueMap<reco::CandidatePtr>(iEvent, src, ptrs, "");
 
  if (writeExtraPATOutput_) {
    auto outUDVect = std::make_unique<edm::OwnVector<pat::UserData> >();
    std::vector<int> idxUD(nsrc, -1);
    for (isrc = 0; isrc < nsrc; ++isrc) {
      if (match[isrc] != -1) {
        outUDVect->push_back(pat::UserData::make(ptrs[isrc]));
        idxUD[isrc] = outUDVect->size() - 1;
      }
    }
    edm::OrphanHandle<edm::OwnVector<pat::UserData> > doneUDVect = iEvent.put(std::move(outUDVect));
    std::vector<edm::Ptr<pat::UserData> > ptrUD(nsrc);
    for (isrc = 0; isrc < nsrc; ++isrc) {
      if (idxUD[isrc] != -1)
        ptrUD[isrc] = edm::Ptr<pat::UserData>(doneUDVect, idxUD[isrc]);
    }
    storeValueMap<edm::Ptr<pat::UserData> >(iEvent, src, ptrUD, "");
  }
 
  if (algo_.hasMetrics()) {
    storeValueMap<float>(iEvent, src, deltaRs, "deltaR");
    storeValueMap<float>(iEvent, src, deltaEtas, "deltaEta");
    storeValueMap<float>(iEvent, src, deltaPhis, "deltaPhi");
    storeValueMap<float>(iEvent, src, deltaLocalPos, "deltaLocalPos");
    storeValueMap<float>(iEvent, src, deltaPtRel, "deltaPtRel");
    if (algo_.hasChi2()) {
      storeValueMap<float>(iEvent, src, chi2, "chi2");
    }
  } else {
    std::vector<int> ismatched(nsrc, 0);
    for (isrc = 0; isrc < nsrc; ++isrc) {
      ismatched[isrc] = (match[isrc] != -1);
    }
    storeValueMap<int>(iEvent, src, ismatched, "matched");
  }
}
 
template <typename T>
void pat::MatcherUsingTracks::storeValueMap(edm::Event &iEvent,
                                            const edm::Handle<edm::View<reco::Candidate> > &handle,
                                            const std::vector<T> &values,
                                            const std::string &label) const {
  using namespace edm;
  using namespace std;
  unique_ptr<ValueMap<T> > valMap(new ValueMap<T>());
  typename edm::ValueMap<T>::Filler filler(*valMap);
  filler.insert(handle, values.begin(), values.end());
  filler.fill();
  iEvent.put(std::move(valMap), label);
}
 
#include "FWCore/Framework/interface/MakerMacros.h"
using namespace pat;
DEFINE_FWK_MODULE(MatcherUsingTracks);