GenericOverlapFinder.h

Go to the documentation of this file.

#ifndef PhysicsTools_PatUtils_GenericOverlapFinder_h
#define PhysicsTools_PatUtils_GenericOverlapFinder_h

#include "DataFormats/Math/interface/deltaR.h"

#include <memory>
#include <vector>
#include <algorithm>

namespace pat {

  typedef std::vector<std::pair<size_t, size_t> > OverlapList;

  template <typename Comparator>
  struct OverlapDistance {
  public:
    OverlapDistance() {}
    OverlapDistance(const Comparator &comp) : comp_(comp) {}
    template <typename T1, typename T2>
    double operator()(const T1 &t1, const T2 &t2) const {
      return 1.0 - comp_(t1, t2);
    }

  private:
    Comparator comp_;
  };  //struct

  struct OverlapByDeltaR {
  public:
    OverlapByDeltaR(double deltaR) : scale_(1.0 / (deltaR * deltaR)) {}
    template <typename T1, typename T2>
    double operator()(const T1 &t1, const T2 &t2) const {
      return deltaR2(t1, t2) * scale_;
    }

  private:
    double scale_;
  };  //struct

  template <typename Distance>
  class GenericOverlapFinder {
  public:
    GenericOverlapFinder() {}
    GenericOverlapFinder(const Distance &dist) : distance_(dist) {}

    template <typename Collection, typename OtherCollection>
    std::unique_ptr<OverlapList> find(const Collection &items, const OtherCollection &other) const;

  private:
    Distance distance_;

  };  // class
}  // namespace pat

template <typename Distance>
template <typename Collection, typename OtherCollection>
std::unique_ptr<pat::OverlapList> pat::GenericOverlapFinder<Distance>::find(const Collection &items,
                                                                            const OtherCollection &other) const {
  size_t size = items.size(), size2 = other.size();

  auto ret = std::make_unique<OverlapList>();

  for (size_t ie = 0; ie < size; ++ie) {
    double dmin = 1.0;
    size_t match = 0;

    for (size_t je = 0; je < size2; ++je) {
      double dist = distance_(items[ie], other[je]);
      if (dist < dmin) {
        match = je;
        dmin = dist;
      }
    }

    if (dmin < 1.0) {
      ret->push_back(std::make_pair(ie, match));
    }
  }

  return ret;
}

#endif