BestMatcher< T, S > Class Template Reference

#include <BestMatcher.h>

Inheritance diagram for BestMatcher< T, S >:

Collaboration diagram for BestMatcher< T, S >:

Classes
class	matched_
	internal class to store the matching paramter for a pair, and in the indices of the pair More...

Public Types
typedef std::map< T *, T * >	map_type
typedef std::map< T *, T * >	rmap_type

Public Member Functions
	BestMatcher (const std::string &name, double d)
virtual	~BestMatcher ()
virtual void	match (const std::vector< T * > &ref, const std::vector< S * > &test)
virtual double	distance (const T *t0, const S *t1) const =0
virtual Associator *	clone ()=0
virtual void	match (const std::vector< T * > &s1, const std::vector< T * > &s2)=0
virtual const T *	matched (T *t)
virtual const T *	revmatched (T *t)
void	clear ()
unsigned	size () const

Protected Member Functions
template<typename Tp, typename Tq>
std::map< int, int >	matcher (const std::vector< Tp * > &ref, const std::vector< Tq * > &test)

Protected Attributes
double	m_d
std::string	mname
map_type	mmatched
rmap_type	mrevmatched

Detailed Description

template<typename T, typename S = T>
class BestMatcher< T, S >

Definition at line 29 of file BestMatcher.h.

Member Typedef Documentation

map_type

typedef std::map<T*, T*> TIDA::Associator< T, T >::map_type

inherited

Definition at line 28 of file TIDAAssociator.h.

rmap_type

typedef std::map<T*, T*> TIDA::Associator< T, T >::rmap_type

inherited

Definition at line 29 of file TIDAAssociator.h.

Constructor & Destructor Documentation

BestMatcher()

template<typename T, typename S = T>

BestMatcher< T, S >::BestMatcher ( const std::string & name, double d )

inline

Definition at line 61 of file BestMatcher.h.

~BestMatcher()

template<typename T, typename S = T>

virtual BestMatcher< T, S >::~BestMatcher ( )

inlinevirtual

Definition at line 65 of file BestMatcher.h.

Member Function Documentation

clear()

void TIDA::Associator< T, T >::clear ( )

inlineinherited

Definition at line 63 of file TIDAAssociator.h.

clone()

virtual Associator * TIDA::Associator< T, T >::clone ( )

pure virtualinherited

distance()

template<typename T, typename S = T>

virtual double BestMatcher< T, S >::distance ( const T * t0, const S * t1 ) const

pure virtual

Implemented in Associator_BestDeltaPhiMatcher, Associator_BestDeltaRMatcher, Associator_BestDeltaRZMatcher, Associator_BestDeltaRZSinThetaMatcher, Associator_BestSigmaMatcher, Associator_DeltaRMatcher, Associator_SecondBestpTMatcher, VertexMatcher, and VertexNewMatcher.

match() [1/2]

template<typename T, typename S = T>

virtual void BestMatcher< T, S >::match ( const std::vector< T * > & ref, const std::vector< S * > & test )

inlinevirtual

Definition at line 68 of file BestMatcher.h.

match() [2/2]

virtual void TIDA::Associator< T, T >::match ( const std::vector< T * > & s1, const std::vector< T * > & s2 )

pure virtualinherited

matched()

virtual const T * TIDA::Associator< T, T >::matched ( T * t )

inlinevirtualinherited

Definition at line 45 of file TIDAAssociator.h.

matcher()

template<typename T, typename S = T>

template<typename Tp, typename Tq>

std::map< int, int > BestMatcher< T, S >::matcher ( const std::vector< Tp * > & ref, const std::vector< Tq * > & test )

inlineprotected

inserting into a multimatch sorts them into order as they are added so you get the list of best matches imediately NB: probably quicker to add them to a vector and then sort them afterward

now go through from best to worst, adding to another sorted set only the matches that do not use tracks already used by a better matching pair already found

set of unique track pairings NB: for some reason, using the multiset is faster than using a vector, even though we are only iterating through it later

hooray!! now print out the answer, make a map etc this isn't technically needed, could just use the set of "matched" objects, but hey ho

Definition at line 91 of file BestMatcher.h.

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;

}