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