Associator_BestDeltaRZSinThetaMatcher Class Reference

#include <Associator_BestMatch.h>

Inheritance diagram for Associator_BestDeltaRZSinThetaMatcher:

Collaboration diagram for Associator_BestDeltaRZSinThetaMatcher:

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

Public Member Functions
	Associator_BestDeltaRZSinThetaMatcher (const std::string &name, double deta=0.05, double dphi=0.05, double dzed=5)
virtual	~Associator_BestDeltaRZSinThetaMatcher ()
virtual TrackAssociator *	clone () override
virtual double	distance (const TIDA::Track *t0, const TIDA::Track *t1) const override
virtual void	match (const std::vector< TIDA::Track * > &ref, const std::vector< TIDA::Track * > &test)
virtual void	match (const std::vector< T * > &s1, const std::vector< S * > &s2)=0
virtual const S *	matched (T *t)
const map_type &	matched () const
virtual const T *	revmatched (S *t)
const rmap_type &	revmatched () const
void	clear ()
unsigned	size () const

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

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

Detailed Description

Definition at line 152 of file Associator_BestMatch.h.

Member Typedef Documentation

map_type

template<typename T, typename S = T>

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

inherited

Definition at line 28 of file TIDAAssociator.h.

rmap_type

template<typename T, typename S = T>

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

inherited

Definition at line 29 of file TIDAAssociator.h.

Constructor & Destructor Documentation

Associator_BestDeltaRZSinThetaMatcher()

Associator_BestDeltaRZSinThetaMatcher::Associator_BestDeltaRZSinThetaMatcher ( const std::string & name, double deta = 0.05, double dphi = 0.05, double dzed = 5 )

inline

Definition at line 156 of file Associator_BestMatch.h.

                                                                                                                  : 
    Associator_BestMatcher(name, 1), 
    m_deta2(deta*deta),
    m_dphi2(dphi*dphi),
    m_dzed2(dzed*dzed)
  {
    std::cout << "Associator: Best RZ Matcher" << std::endl;
  } 

~Associator_BestDeltaRZSinThetaMatcher()

virtual Associator_BestDeltaRZSinThetaMatcher::~Associator_BestDeltaRZSinThetaMatcher ( )

inlinevirtual

Definition at line 165 of file Associator_BestMatch.h.

{ } 

Member Function Documentation

clear()

template<typename T, typename S = T>

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

inlineinherited

Definition at line 63 of file TIDAAssociator.h.

{ mmatched.clear(); mrevmatched.clear(); } 

clone()

virtual TrackAssociator * Associator_BestDeltaRZSinThetaMatcher::clone ( )

inlineoverridevirtual

Implements TIDA::Associator< T, S >.

Definition at line 167 of file Associator_BestMatch.h.

{ return new Associator_BestDeltaRZSinThetaMatcher(*this); }

distance()

virtual double Associator_BestDeltaRZSinThetaMatcher::distance ( const TIDA::Track * t0, const TIDA::Track * t1 ) const

inlineoverridevirtual

Implements BestMatcher< TIDA::Track >.

Definition at line 169 of file Associator_BestMatch.h.

                                                                                     {
    double theta = 2*std::atan(std::exp(-t1->eta()));
 
    double deta = t0->eta()-t1->eta();
    double dphi = t0->phi()-t1->phi(); if ( dphi> M_PI ) dphi-=2*M_PI;  if ( dphi<-M_PI ) dphi+=2*M_PI;
 
    double dzed = (t0->z0()-t1->z0())*std::sin(theta);    
 
    double dr =  std::sqrt( deta*deta/m_deta2 + dphi*dphi/m_dphi2 + dzed*dzed/m_dzed2 );
 
    //    std::cout << "RZ matcher dr: " << dr 
    //        << "\t : \t" << deta*deta/m_deta2 << "\t" << dphi*dphi/m_dphi2 << "\t" << dzed*dzed/m_dzed2  << "\t" << *t1 
    //        << std::endl;
 
    return dr;
  }

match() [1/2]

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

inlinevirtualinherited

Definition at line 68 of file BestMatcher.h.

  {
    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;
    }  
 
  }

match() [2/2]

template<typename T, typename S = T>

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

pure virtualinherited

Implemented in Associator_DeltaEtaPhi, Associator_DeltaRCosmics, Associator_TruthMatcher, BestMatcher< TIDA::Vertex >, TrackMatchDeltaR, and TrackMatchDeltaRCosmic.

matched() [1/2]

template<typename T, typename S = T>

const map_type & TIDA::Associator< T, S >::matched ( ) const

inlineinherited

Definition at line 59 of file TIDAAssociator.h.

{ return mmatched; }

matched() [2/2]

template<typename T, typename S = T>

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

inlinevirtualinherited

Definition at line 45 of file TIDAAssociator.h.

                                  { 
     typename map_type::const_iterator titr = mmatched.find(t);
     if ( titr != mmatched.end() ) return titr->second;
     else                          return 0;
  } 

matcher()

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

inlineprotectedinherited

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;
    
  }

revmatched() [1/2]

template<typename T, typename S = T>

const rmap_type & TIDA::Associator< T, S >::revmatched ( ) const

inlineinherited

Definition at line 60 of file TIDAAssociator.h.

{ return mrevmatched; }

revmatched() [2/2]

template<typename T, typename S = T>

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

inlinevirtualinherited

Definition at line 52 of file TIDAAssociator.h.

                                     { 
     typename rmap_type::const_iterator titr = mrevmatched.find(t);
     if ( titr != mrevmatched.end() ) return titr->second;
     else                             return 0;
  } 

size()

template<typename T, typename S = T>

unsigned TIDA::Associator< T, S >::size ( ) const

inlineinherited

Definition at line 66 of file TIDAAssociator.h.

{ return mmatched.size(); }

Member Data Documentation

m_d

double BestMatcher< TIDA::Track, TIDA::Track >::m_d

protectedinherited

Definition at line 171 of file BestMatcher.h.

m_deta2

double Associator_BestDeltaRZSinThetaMatcher::m_deta2

protected

Definition at line 188 of file Associator_BestMatch.h.

m_dphi2

double Associator_BestDeltaRZSinThetaMatcher::m_dphi2

protected

Definition at line 189 of file Associator_BestMatch.h.

m_dzed2

double Associator_BestDeltaRZSinThetaMatcher::m_dzed2

protected

Definition at line 190 of file Associator_BestMatch.h.

mmatched

template<typename T, typename S = T>

map_type TIDA::Associator< T, S >::mmatched

protectedinherited

Definition at line 73 of file TIDAAssociator.h.

mname

template<typename T, typename S = T>

std::string TIDA::Associator< T, S >::mname

protectedinherited

Definition at line 71 of file TIDAAssociator.h.

mrevmatched

template<typename T, typename S = T>

rmap_type TIDA::Associator< T, S >::mrevmatched

protectedinherited

Definition at line 74 of file TIDAAssociator.h.

---

The documentation for this class was generated from the following file:

• Associator_BestMatch.h