BestMatcher.h

Go to the documentation of this file.

/* emacs: this is -*- c++ -*- */
 
 
#ifndef  BESTMATCHER_H
#define  BESTMATCHER_H
 
#include <iostream>
#include <set>
 
 
#include "TrigInDetAnalysis/TIDAAssociator.h"
 
 
 
 
template<typename T, typename S=T>
class BestMatcher : public TIDA::Associator<T,S>  {
 
protected:

 
  class matched_ { 
    
  public:
    
    matched_(double d, int i, int j) : m_d(d), m_match(std::pair<int,int>(i,j)) { } 
    
    double d() const { return m_d; } 
    
    std::pair<int, int> pair() const { return m_match; }
    
    int first()  const { return m_match.first; } 
    int second() const { return m_match.second; } 
    
    bool  operator<(const matched_& a) const { return d()<a.d(); }
    bool  operator>(const matched_& a) const { return d()>a.d(); }
    bool operator==(const matched_& a) const { return  d()==a.d(); } 
    bool operator!=(const matched_& a) const { return  d()!=a.d(); } 
    
  private:
    double              m_d;
    std::pair<int, int> m_match; 
  };
 
public:
 
  BestMatcher(const std::string& name, double d) : 
    TIDA::Associator<T,S>(name), m_d(d) 
  {   } 
  
  virtual ~BestMatcher() { } 
  
  
  virtual void match(const std::vector<T*>& ref, const std::vector<S*>& test ) 
  {
    this->clear();
    
    std::map<int,int> matched = matcher( ref, test);
 
    std::map<int,int>::iterator  mitr = matched.begin();
    while ( mitr!=matched.end() ) {
      this->mmatched.insert(    typename TIDA::Associator<T,S>::map_type::value_type( ref[mitr->first],   test[mitr->second]) );
      this->mrevmatched.insert( typename TIDA::Associator<S,T>::map_type::value_type( test[mitr->second], ref[mitr->first] ) );
      ++mitr;
    }  
 
  }
 
 
  virtual double distance( const T* t0, const S* t1 ) const = 0;
 
 
protected:
 
 
  template<typename Tp, typename Tq>
  std::map<int, int>  matcher( const std::vector<Tp*>& ref, const std::vector<Tq*>& test) { 
    
    
    std::multiset<matched_> m;
    
    for (unsigned int i=0 ; i<ref.size() ; i++ ) { 
      
      for (unsigned int j=0 ; j<test.size() ; j++ ) { 
    double d = distance(ref[i], test[j]);   
    if ( d<m_d ){  
      m.insert( matched_(d, i, j) ); 
    }
      }
    }
    
    
    std::vector<bool>  refused(  ref.size(), false ); 
    std::vector<bool> testused( test.size(), false ); 

    std::multiset<matched_> unique;
 
    typename std::multiset<matched_>::iterator mitr = m.begin();
    
    double  chi2 = 0;
    
    for ( ; mitr!=m.end() ; ++mitr ) {
 
      int rind = mitr->first();
      int tind = mitr->second();
 
      if (  refused[rind] ) continue;
      if ( testused[tind] ) continue;
 
      refused[rind]  = true;
      testused[tind] = true;
 
      unique.insert( *mitr );
 
      chi2 += (mitr->d()*mitr->d());
 
    }
    
    
    //    std::cout << "chi2 of matches " << chi2 << std::endl;
   
    
    //  std::cout << "\nmatched" << std::endl; 
    
    std::map<int, int> matches;
 
 
    mitr = unique.begin();
    while ( mitr!=unique.end() ) {
      matches.insert( std::map<int, int>::value_type( mitr->first(), mitr->second() ) );
      //   std::cout << "\tbest match " << *mitr << "\t" <<  ref[mitr->first()] << "\t" << test[mitr->second()] << std::endl;
      ++mitr;
    }  
 
    return matches;
    
  }
 
 
protected:
 
  double m_d;
 
};
 
 
 
#endif  // MATCH_H