FastCandMatcher< C > Class Template Reference

#include <FastCandMatcher.h>

Public Types
typedef edm::AssociationMap< edm::OneToOne< C, reco::CandidateCollection > >	map_type
	map type More...
typedef std::vector< const map_type * >	map_vector
	map vector More...

Public Member Functions
	FastCandMatcher (const map_type &map)
	constructor More...
	FastCandMatcher (const map_vector &maps)
	constructor More...
const reco::Candidate *	operator() (const reco::Candidate &) const
	get match from transient reference More...

Protected Member Functions
const std::vector< const map_type * > &	maps () const

Private Attributes
std::vector< const map_type * >	maps_
	pointers to stored maps More...

Detailed Description

template<typename C>
class FastCandMatcher< C >

Definition at line 15 of file FastCandMatcher.h.

Member Typedef Documentation

map_type

template<typename C>

typedef edm::AssociationMap<edm::OneToOne<C, reco::CandidateCollection> > FastCandMatcher< C >::map_type

map type

Definition at line 18 of file FastCandMatcher.h.

map_vector

template<typename C>

typedef std::vector<const map_type *> FastCandMatcher< C >::map_vector

map vector

Definition at line 20 of file FastCandMatcher.h.

Constructor & Destructor Documentation

FastCandMatcher() [1/2]

template<typename C>

FastCandMatcher< C >::FastCandMatcher ( const map_vector &  maps )

explicit

constructor

FastCandMatcher() [2/2]

template<typename C>

FastCandMatcher< C >::FastCandMatcher ( const map_type &  map )

explicit

constructor

Member Function Documentation

maps()

template<typename C>

const std::vector<const map_type *>& FastCandMatcher< C >::maps ( ) const

inlineprotected

Definition at line 29 of file FastCandMatcher.h.

{ return maps_; }

References FastCandMatcher< C >::maps_.

operator()()

template<typename C >

const reco::Candidate * FastCandMatcher< C >::operator()

(

const reco::Candidate &

c

)

const

get match from transient reference

Definition at line 46 of file FastCandMatcher.h.

                                                                                    {
  using namespace reco;
  using namespace std;
  if ( c.hasMasterClone() )
    return (*this)( * c.masterClone() );
  unsigned int nDau = c.numberOfDaughters();
  if ( nDau > 0 ) {
    // check for composite candidate c
    // navigate to daughters and find parent matches
    set<const reco::Candidate *> momsIntersection, momDaughters, tmp;
    for( Candidate::const_iterator dau = c.begin(); dau != c.end(); ++ dau ) {
      // check here generically if status == 3, then descend down to one more level
      const Candidate * dauMatch = (*this)( * dau );
      // if a daughter does not match, return a null ref.
      if ( dauMatch == 0 ) return 0;
      // get matched mothers
      size_t mothers = dauMatch->numberOfMothers();
      for( size_t i = 0; i < mothers; ++ i ) {
    const reco::Candidate * mom = dauMatch->mother( i );
    if ( mom != 0 && mom->pdgId() == dauMatch->pdgId() && 
         mom->status() == 3 && dauMatch->status() == 1 ) {
      // assume a single mother at this point...
      mom = mom->mother( 0 );
    }
    momDaughters.insert( mom );
      }
      // if no mother was found return null reference
      if ( momDaughters.size() == 0 ) return 0;
      // the first time, momsIntersection is set to momDaughters
      if ( momsIntersection.size() == 0 ) momsIntersection = momDaughters;
      else {
    tmp.clear();
    set_intersection( momsIntersection.begin(), momsIntersection.end(),
              momDaughters.begin(), momDaughters.end(),
             inserter( tmp, tmp.begin() ) );
    swap( momsIntersection, tmp );
      }
      if ( momsIntersection.size() == 0 ) return 0;
    }
    // if multiple mothers are found, return a null reference
    if ( momsIntersection.size() > 1 ) return 0;
    // return a reference to the unique mother
    return * momsIntersection.begin();
  } else {
    // check for non-composite (leaf) candidate 
    // if one of the maps contains the candidate c
    for( typename std::vector<const map_type *>::const_iterator m = maps_.begin(); 
     m != maps_.end(); ++ m ) {
      for( typename map_type::const_iterator i = (*m)->begin(); i != (*m)->end(); ++ i ) {
    if ( & * i->key == & c )
      return & * i->val;
      }
    }
    return 0;
  }
}

References c, mps_fire::i, visualization-live-secondInstance_cfg::m, reco::Candidate::mother(), reco::Candidate::numberOfMothers(), reco::Candidate::pdgId(), reco::Candidate::status(), reco::swap(), and createJobs::tmp.

Member Data Documentation

maps_

template<typename C>

std::vector<const map_type *> FastCandMatcher< C >::maps_

private

pointers to stored maps

Definition at line 32 of file FastCandMatcher.h.

Referenced by FastCandMatcher< C >::maps().