VertexClassifierByProxy.h

Go to the documentation of this file.

#ifndef VertexClassifierByProxy_h
#define VertexClassifierByProxy_h

#include "DataFormats/Common/interface/AssociationMap.h"

#include "SimTracker/TrackHistory/interface/VertexClassifier.h"

template <typename Collection>
class VertexClassifierByProxy : public VertexClassifier {
public:
  typedef edm::AssociationMap<edm::OneToMany<Collection, reco::VertexCollection>> Association;

  VertexClassifierByProxy(edm::ParameterSet const &config, edm::ConsumesCollector &&collector)
      : VertexClassifier(config, std::move(collector)),
        proxy_(config.getUntrackedParameter<edm::InputTag>("vertexProducer")) {
    collector.consumes<Association>(proxy_);
  }

  void newEvent(edm::Event const &event, edm::EventSetup const &config) override {
    // Get the association part of the proxy to the collection
    event.getByLabel(proxy_, proxyHandler_);
    // Call the previous new event
    VertexClassifier::newEvent(event, config);
  }

  VertexClassifierByProxy<Collection> const &evaluate(TrackingVertexRef const &vertex) {
    VertexClassifier::evaluate(vertex);
    return *this;
  }

  VertexClassifierByProxy<Collection> const &evaluate(edm::Ref<Collection> const &vertex, std::size_t index) {
    const reco::VertexRefVector *vertexes = nullptr;

    try {
      // Get a reference to the vector of associated vertexes
      vertexes = &(proxyHandler_->find(vertex)->val);
    } catch (edm::Exception &e) {
      // If association fails define the vertex as unknown
      reset();
      unknownVertex();
      return *this;
    }

    // Evaluate the history for a given index
    VertexClassifier::evaluate(vertexes->at(index));

    return *this;
  }

  VertexClassifierByProxy<Collection> const &evaluate(edm::Ref<Collection> const &vertex) {
    const reco::VertexRefVector *vertexes = nullptr;

    try {
      // Get a reference to the vector of associated vertexes
      vertexes = &(proxyHandler_->find(vertex)->val);
    } catch (edm::Exception &e) {
      // If association fails define the vertex as unknown
      reset();
      unknownVertex();
      return *this;
    }

    // Loop over all the associated vertexes
    for (std::size_t index = 0; index < vertexes->size(); ++index) {
      // Copy the last status for all the flags
      Flags flags(flags_);

      // Evaluate the history for a given index
      VertexClassifier::evaluate(vertexes->at(index));

      // Combine OR the flag information
      for (std::size_t i = 0; i < flags_.size(); ++i)
        flags_[i] = flags_[i] | flags[i];
    }

    return *this;
  }

private:
  const edm::InputTag proxy_;

  edm::Handle<Association> proxyHandler_;
};

#endif