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
}

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