VertexingHelper.h

Go to the documentation of this file.

#ifndef PhysicsTools_PatAlgos_interface_VertexingHelper_h
#define PhysicsTools_PatAlgos_interface_VertexingHelper_h

#include "DataFormats/PatCandidates/interface/Vertexing.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "PhysicsTools/PatUtils/interface/VertexAssociationSelector.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"

#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
#include "TrackingTools/Records/interface/TransientTrackRecord.h"

#include "PhysicsTools/UtilAlgos/interface/ParameterAdapter.h"
namespace reco {
  namespace modules {
    template <>
    struct ParameterAdapter<pat::VertexAssociationSelector> {
      static pat::VertexAssociationSelector make(const edm::ParameterSet &iConfig) {
        pat::VertexAssociationSelector::Config assoconf;
        if (iConfig.existsAs<double>("deltaZ"))
          assoconf.dZ = iConfig.getParameter<double>("deltaZ");
        if (iConfig.existsAs<double>("deltaR"))
          assoconf.dR = iConfig.getParameter<double>("deltaR");
        if (iConfig.existsAs<double>("sigmasZ"))
          assoconf.sigmasZ = iConfig.getParameter<double>("sigmasZ");
        if (iConfig.existsAs<double>("sigmasR"))
          assoconf.sigmasR = iConfig.getParameter<double>("sigmasR");
        return pat::VertexAssociationSelector(assoconf);
      }
    };
  }  // namespace modules
}  // namespace reco

namespace pat {
  namespace helper {
    class VertexingHelper {
    public:
      VertexingHelper() : enabled_(false) {}
      VertexingHelper(const edm::ParameterSet &iConfig, edm::ConsumesCollector &&iC);

      bool enabled() const { return enabled_; }

      void newEvent(const edm::Event &event);

      void newEvent(const edm::Event &event, const edm::EventSetup &setup);

      template <typename AnyCandRef>
      pat::VertexAssociation operator()(const AnyCandRef &) const;

    private:
      bool enabled_;

      bool playback_;

      pat::VertexAssociationSelector assoSelector_;

      //-------- Tools for production of vertex associations -------
      edm::EDGetTokenT<reco::VertexCollection> verticesToken_;
      edm::Handle<reco::VertexCollection> vertexHandle_;
      bool useTracks_;
      edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> ttToken_;
      edm::ESHandle<TransientTrackBuilder> ttBuilder_;

      //--------- Tools for reading vertex associations (playback mode) -----
      edm::EDGetTokenT<edm::ValueMap<pat::VertexAssociation> > vertexAssociationsToken_;
      edm::Handle<edm::ValueMap<pat::VertexAssociation> > vertexAssoMap_;

      reco::TrackBaseRef getTrack_(const reco::Candidate &c) const;

      pat::VertexAssociation associate(const reco::Candidate &) const;

    };  // class

    template <typename AnyCandRef>
    pat::VertexAssociation pat::helper::VertexingHelper::operator()(const AnyCandRef &cand) const {
      if (playback_) {
        const pat::VertexAssociation &assoc = (*vertexAssoMap_)[cand];
        return assoSelector_(assoc) ? assoc : pat::VertexAssociation();
      } else {
        return associate(*cand);
      }
    }

  }  // namespace helper
}  // namespace pat

#endif