TrackAssociator that associates by hits a bit quicker than the normal TrackAssociatorByHits class. More...

#include <QuickTrackAssociatorByHits.h>

Inheritance diagram for QuickTrackAssociatorByHits:

Public Member Functions
virtual reco::RecoToSimCollection	associateRecoToSim (edm::Handle< edm::View< reco::Track > > &trackCollectionHandle, edm::Handle< TrackingParticleCollection > &trackingParticleCollectionHandle, const edm::Event pEvent=0, const edm::EventSetup pSetup=0) const override
	compare reco to sim the handle of reco::Track and TrackingParticle collections More...

virtual reco::RecoToSimCollection	associateRecoToSim (const edm::RefToBaseVector< reco::Track > &trackCollection, const edm::RefVector< TrackingParticleCollection > &trackingParticleCollection, const edm::Event pEvent=0, const edm::EventSetup pSetup=0) const override
	Association Reco To Sim with Collections. More...

virtual reco::RecoToSimCollectionSeed	associateRecoToSim (edm::Handle< edm::View< TrajectorySeed > > &, edm::Handle< TrackingParticleCollection > &, const edm::Event event, const edm::EventSetup setup) const override

virtual reco::SimToRecoCollection	associateSimToReco (edm::Handle< edm::View< reco::Track > > &trackCollectionHandle, edm::Handle< TrackingParticleCollection > &trackingParticleCollectionHandle, const edm::Event pEvent=0, const edm::EventSetup pSetup=0) const override
	compare reco to sim the handle of reco::Track and TrackingParticle collections More...

virtual reco::SimToRecoCollection	associateSimToReco (const edm::RefToBaseVector< reco::Track > &trackCollection, const edm::RefVector< TrackingParticleCollection > &trackingParticleCollection, const edm::Event pEvent=0, const edm::EventSetup pSetup=0) const override
	Association Sim To Reco with Collections. More...

virtual reco::SimToRecoCollectionSeed	associateSimToReco (edm::Handle< edm::View< TrajectorySeed > > &, edm::Handle< TrackingParticleCollection > &, const edm::Event event, const edm::EventSetup setup) const override

	QuickTrackAssociatorByHits (const edm::ParameterSet &config)

	~QuickTrackAssociatorByHits ()

Public Member Functions inherited from TrackAssociatorBase
virtual reco::RecoToSimCollectionTCandidate	associateRecoToSim (edm::Handle< TrackCandidateCollection > &, edm::Handle< TrackingParticleCollection > &, const edm::Event event, const edm::EventSetup setup) const

virtual reco::SimToRecoCollectionTCandidate	associateSimToReco (edm::Handle< TrackCandidateCollection > &, edm::Handle< TrackingParticleCollection > &, const edm::Event event, const edm::EventSetup setup) const

	TrackAssociatorBase ()
	Constructor. More...

virtual	~TrackAssociatorBase ()
	Destructor. More...

Private Types
typedef std::vector< std::pair < OmniClusterRef, TrackingParticleRef > >	ClusterTPAssociationList

enum	SimToRecoDenomType { denomnone, denomsim, denomreco }

typedef std::pair< uint32_t, EncodedEventId >	SimTrackIdentifiers
	This is enough information to uniquely identify a sim track. More...

Private Member Functions
template<class T_TrackCollection , class T_TrackingParticleCollection , class T_hitOrClusterAssociator >
reco::RecoToSimCollection	associateRecoToSimImplementation (T_TrackCollection trackCollection, T_TrackingParticleCollection trackingParticleCollection, T_hitOrClusterAssociator hitOrClusterAssociator) const
	The method that does the work for both overloads of associateRecoToSim. More...

template<class T_TrackCollection , class T_TrackingParticleCollection , class T_hitOrClusterAssociator >
reco::SimToRecoCollection	associateSimToRecoImplementation (T_TrackCollection trackCollection, T_TrackingParticleCollection trackingParticleCollection, T_hitOrClusterAssociator hitOrClusterAssociator) const
	The method that does the work for both overloads of associateSimToReco. More...

template<typename T_TPCollection , typename iter >
std::vector< std::pair < edm::Ref < TrackingParticleCollection > , size_t > >	associateTrack (const TrackerHitAssociator &hitAssociator, T_TPCollection trackingParticles, iter begin, iter end) const
	Returns the TrackingParticle that has the most associated hits to the given track. More...

template<typename T_TPCollection , typename iter >
std::vector< std::pair < edm::Ref < TrackingParticleCollection > , size_t > >	associateTrack (const ClusterTPAssociationList &clusterToTPMap, T_TPCollection trackingParticles, iter begin, iter end) const
	Returns the TrackingParticle that has the most associated hits to the given track. More...

template<typename iter >
std::vector< std::pair < SimTrackIdentifiers, size_t > >	getAllSimTrackIdentifiers (const TrackerHitAssociator &hitAssociator, iter begin, iter end) const
	Returns a vector of pairs where first is a SimTrackIdentifiers (see typedef above) and second is the number of hits that came from that sim track. More...

template<typename iter >
int	getDoubleCount (const TrackerHitAssociator &hitAssociator, iter begin, iter end, TrackingParticleRef associatedTrackingParticle) const
	This method was copied almost verbatim from the standard TrackAssociatorByHits. More...

template<typename iter >
int	getDoubleCount (const ClusterTPAssociationList &clusterToTPList, iter begin, iter end, TrackingParticleRef associatedTrackingParticle) const
	Overload for when using cluster to TrackingParticle association list. More...

const TrackingRecHit *	getHitFromIter (trackingRecHit_iterator iter) const

const TrackingRecHit *	getHitFromIter (TrackingRecHitCollection::const_iterator iter) const

template<typename iter >
std::vector< OmniClusterRef >	getMatchedClusters (iter begin, iter end) const

void	prepareEitherHitAssociatorOrClusterToTPMap (const edm::Event *pEvent, std::unique_ptr< ClusterTPAssociationList > &pClusterToTPMap, std::unique_ptr< TrackerHitAssociator > &pHitAssociator) const
	creates either a ClusterTPAssociationList OR a TrackerHitAssociator and stores it in the provided unique_ptr. The other will be null. More...

bool	trackingParticleContainsIdentifier (const TrackingParticle *pTrackingParticle, const SimTrackIdentifiers &identifier) const
	Returns true if the supplied TrackingParticle has the supplied g4 track identifiers. More...

Static Private Member Functions
static bool	clusterTPAssociationListGreater (std::pair< OmniClusterRef, TrackingParticleRef > i, std::pair< OmniClusterRef, TrackingParticleRef > j)

static bool	tpIntPairGreater (std::pair< edm::Ref< TrackingParticleCollection >, size_t > i, std::pair< edm::Ref< TrackingParticleCollection >, size_t > j)

Private Attributes
bool	absoluteNumberOfHits_

edm::InputTag	cluster2TPSrc_

double	cutRecoToSim_

edm::ParameterSet	hitAssociatorParameters_

double	puritySimToReco_

double	qualitySimToReco_

SimToRecoDenomType	simToRecoDenominator_

bool	threeHitTracksAreSpecial_

bool	useClusterTPAssociation_

Detailed Description

TrackAssociator that associates by hits a bit quicker than the normal TrackAssociatorByHits class.

NOTE - Doesn't implement the TrackCandidate association methods (from TrackAssociatorBase) so will always return empty associations for those.

This track associator (mostly) does the same as TrackAssociatorByHits, but faster. I've tested it a fair bit and can't find any differences between the results of this and the standard TrackAssociatorByHits.

Configuration parameters:

AbsoluteNumberOfHits - bool - if true, Quality_SimToReco and Cut_RecoToSim are the absolute number of shared hits required for association, not the percentage.

Quality_SimToReco - double - The minimum amount of shared hits required, as a percentage of either the reconstructed hits or simulated hits (see SimToRecoDenominator), for the track to be considered associated during a call to associateSimToReco. See also AbsoluteNumberOfHits.

Purity_SimToReco - double - The minimum amount of shared hits required, as a percentage of the reconstructed hits, for the track to be considered associated during a call to associateSimToReco. Has no effect if AbsoluteNumberOfHits is true.

Cut_RecoToSim - double - The minimum amount of shared hits required, as a percentage of the reconstructed hits, for the track to be considered associated during a call to associateRecoToSim. See also AbsoluteNumberOfHits.

ThreeHitTracksAreSpecial - bool - If true, tracks with 3 hits must have all their hits associated.

SimToRecoDenominator - string - Must be either "sim" or "reco". If "sim" Quality_SimToReco is the percentage of simulated hits that need to be shared. If "reco" then it's the percentage of reconstructed hits (i.e. same as Purity_SimToReco).

associatePixel - bool - Passed on to the hit associator.

associateStrip - bool - Passed on to the hit associator.

requireStoredHits - bool - Whether or not to insist all TrackingParticles have at least one PSimHit. The PSimHits are not required for the association, but the old TrackAssociatorByHits still had this requirement. Storing PSimHits in the TrackingParticle is now optional (see TrackingTruthAccumulator which replaces TrackingTruthProducer). Having requireStoredHits set to true will mean no TrackingParticles will be associated if you have chosen not to store the hits. The flag is only kept in order to retain the old behaviour which can give very slightly different results.

Note that the TrackAssociatorByHits parameters UseGrouped and UseSplitting are not used.

Author: Mark Grimes (mark..nosp@m.grim.nosp@m.es@ce.nosp@m.rn.c.nosp@m.h)

Date: 09/Nov/2010 Significant changes to remove any differences to the standard TrackAssociatorByHits results 07/Jul/2011. Association for TrajectorySeeds added by Giuseppe Cerati sometime between 2011 and 2013. Functionality to associate using pre calculated cluster to TrackingParticle maps added by Subir Sarker sometime in 2013. Overhauled to remove mutables to make it thread safe by Mark Grimes 01/May/2014.

Definition at line 62 of file QuickTrackAssociatorByHits.h.

Member Typedef Documentation

typedef std::vector<std::pair<OmniClusterRef, TrackingParticleRef> > QuickTrackAssociatorByHits::ClusterTPAssociationList

private

Definition at line 107 of file QuickTrackAssociatorByHits.h.

typedef std::pair<uint32_t,EncodedEventId> QuickTrackAssociatorByHits::SimTrackIdentifiers

private

This is enough information to uniquely identify a sim track.

Definition at line 103 of file QuickTrackAssociatorByHits.h.

Member Enumeration Documentation

enum QuickTrackAssociatorByHits::SimToRecoDenomType

private

Enumerator
denomnone
denomsim
denomreco

Definition at line 104 of file QuickTrackAssociatorByHits.h.

104 {denomnone,denomsim,denomreco};

QuickTrackAssociatorByHits::denomreco

Definition: QuickTrackAssociatorByHits.h:104

QuickTrackAssociatorByHits::denomnone

Definition: QuickTrackAssociatorByHits.h:104

QuickTrackAssociatorByHits::denomsim

Definition: QuickTrackAssociatorByHits.h:104

Constructor & Destructor Documentation

QuickTrackAssociatorByHits::QuickTrackAssociatorByHits ( const edm::ParameterSet & config )

Definition at line 89 of file QuickTrackAssociatorByHits.cc.

References edm::ParameterSet::addParameter(), denomreco, denomsim, edm::hlt::Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), hitAssociatorParameters_, simToRecoDenominator_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                       :
         absoluteNumberOfHits_( config.getParameter<bool>( "AbsoluteNumberOfHits" ) ),
         qualitySimToReco_( config.getParameter<double>( "Quality_SimToReco" ) ),
         puritySimToReco_( config.getParameter<double>( "Purity_SimToReco" ) ),
         cutRecoToSim_( config.getParameter<double>( "Cut_RecoToSim" ) ),
         threeHitTracksAreSpecial_( config.getParameter<bool>( "ThreeHitTracksAreSpecial" ) ),
         useClusterTPAssociation_( config.getParameter<bool>( "useClusterTPAssociation" ) ),
         cluster2TPSrc_( config.getParameter < edm::InputTag > ("cluster2TPSrc") )
 {
     //
     // Check whether the denominator when working out the percentage of shared hits should
     // be the number of simulated hits or the number of reconstructed hits.
     //
     std::string denominatorString=config.getParameter<std::string>("SimToRecoDenominator");
     if( denominatorString=="sim" ) simToRecoDenominator_=denomsim;
     else if( denominatorString=="reco" ) simToRecoDenominator_=denomreco;
     else throw cms::Exception( "QuickTrackAssociatorByHits" ) << "SimToRecoDenominator not specified as sim or reco";
 
     //
     // Set up the parameter set for the hit associator
     //
     hitAssociatorParameters_.addParameter<bool>( "associatePixel", config.getParameter<bool>("associatePixel") );
     hitAssociatorParameters_.addParameter<bool>( "associateStrip", config.getParameter<bool>("associateStrip") );
     // This is the important one, it stops the hit associator searching through the list of sim hits.
     // I only want to use the hit associator methods that work on the hit IDs (i.e. the uint32_t trackId
     // and the EncodedEventId eventId) so I'm not interested in matching that to the PSimHit objects.
     hitAssociatorParameters_.addParameter<bool>("associateRecoTracks",true);
 
     //
     // Do some checks on whether UseGrouped or UseSplitting have been set. They're not used
     // unlike the standard TrackAssociatorByHits so show a warning.
     //
     bool useGrouped, useSplitting;
     if( config.exists("UseGrouped") ) useGrouped=config.getParameter<bool>("UseGrouped");
     else useGrouped=true;
 
     if( config.exists("UseSplitting") ) useSplitting=config.getParameter<bool>("UseSplitting");
     else useSplitting=true;
 
     // This associator works as though both UseGrouped and UseSplitting were set to true, so show a
     // warning if this isn't the case.
     if( !(useGrouped && useSplitting) )
     {
         edm::LogWarning("QuickTrackAssociatorByHits") << "UseGrouped and/or UseSplitting has been set to false, but this associator ignores that setting.";
     }
 }

QuickTrackAssociatorByHits::~QuickTrackAssociatorByHits ( )

Definition at line 136 of file QuickTrackAssociatorByHits.cc.

 {
     // No operation
 }

Member Function Documentation

reco::RecoToSimCollection QuickTrackAssociatorByHits::associateRecoToSim	(	edm::Handle< edm::View< reco::Track > > &	tCH,
		edm::Handle< TrackingParticleCollection > &	tPCH,
		const edm::Event *	event = `0`,
		const edm::EventSetup *	setup = `0`
	)		const

overridevirtual

compare reco to sim the handle of reco::Track and TrackingParticle collections

Reimplemented from TrackAssociatorBase.

Definition at line 141 of file QuickTrackAssociatorByHits.cc.

References associateRecoToSimImplementation(), and prepareEitherHitAssociatorOrClusterToTPMap().

 {
     std::unique_ptr<ClusterTPAssociationList> pClusterToTPMap;
     std::unique_ptr<TrackerHitAssociator> pHitAssociator;
     // This call will set EITHER pClusterToTPMap OR pHitAssociator depending on what the user requested in the configuration.
     prepareEitherHitAssociatorOrClusterToTPMap( pEvent, pClusterToTPMap, pHitAssociator );
 
     // Only pass the one that was successfully created to the templated method.
     if( pClusterToTPMap==nullptr ) return associateRecoToSimImplementation( trackCollectionHandle, trackingParticleCollectionHandle, *pHitAssociator );
     else return associateRecoToSimImplementation( trackCollectionHandle, trackingParticleCollectionHandle, *pClusterToTPMap );
 }

reco::RecoToSimCollection QuickTrackAssociatorByHits::associateRecoToSim	(	const edm::RefToBaseVector< reco::Track > &	tc,
		const edm::RefVector< TrackingParticleCollection > &	tpc,
		const edm::Event *	event = `0`,
		const edm::EventSetup *	setup = `0`
	)		const

overridevirtual

Association Reco To Sim with Collections.

Implements TrackAssociatorBase.

Definition at line 167 of file QuickTrackAssociatorByHits.cc.

References associateRecoToSimImplementation(), and prepareEitherHitAssociatorOrClusterToTPMap().

 {
     std::unique_ptr<ClusterTPAssociationList> pClusterToTPMap;
     std::unique_ptr<TrackerHitAssociator> pHitAssociator;
     // This call will set EITHER pClusterToTPMap OR pHitAssociator depending on what the user requested in the configuration.
     prepareEitherHitAssociatorOrClusterToTPMap( pEvent, pClusterToTPMap, pHitAssociator );
 
     // Only pass the one that was successfully created to the templated method.
     if( pClusterToTPMap==nullptr ) return associateRecoToSimImplementation( trackCollection, trackingParticleCollection, *pHitAssociator );
     else return associateRecoToSimImplementation( trackCollection, trackingParticleCollection, *pClusterToTPMap );
 }

reco::RecoToSimCollectionSeed QuickTrackAssociatorByHits::associateRecoToSim	(	edm::Handle< edm::View< TrajectorySeed > > &	pSeedCollectionHandle_,
		edm::Handle< TrackingParticleCollection > &	trackingParticleCollectionHandle,
		const edm::Event *	event,
		const edm::EventSetup *	setup
	)		const

overridevirtual

Reimplemented from TrackAssociatorBase.

Definition at line 601 of file QuickTrackAssociatorByHits.cc.

References funct::abs(), absoluteNumberOfHits_, associateTrack(), cutRecoToSim_, getDoubleCount(), i, edm::AssociationMap< Tag >::insert(), LogTrace, edm::AssociationMap< Tag >::post_insert(), prepareEitherHitAssociatorOrClusterToTPMap(), TrajectorySeed::recHits(), edm::AssociationMap< Tag >::size(), and threeHitTracksAreSpecial_.

 {
 
     edm::LogVerbatim( "TrackAssociator" ) << "Starting TrackAssociatorByHits::associateRecoToSim - #seeds=" << pSeedCollectionHandle_->size()
             << " #TPs=" << trackingParticleCollectionHandle->size();
 
     //
     // First create either the hit associator or the cluster to TrackingParticle map
     // depending on how the user set the configuration. Depending on the logic here
     // only one of pClusterToTPList or pTrackerHitAssociator will ever be non-null.
     //
     std::unique_ptr<ClusterTPAssociationList> pClusterToTPList;
     std::unique_ptr<TrackerHitAssociator> pTrackerHitAssociator;
     // This call will set EITHER pClusterToTPList OR pHitAssociator depending on what the user requested in the configuration.
     prepareEitherHitAssociatorOrClusterToTPMap( pEvent, pClusterToTPList, pTrackerHitAssociator );
 
     //
     // Now that either pClusterToTPList or pTrackerHitAssociator have been initialised
     // (never both) I can carry on and do the association.
     //
     reco::RecoToSimCollectionSeed returnValue;
 
     size_t collectionSize=pSeedCollectionHandle_->size();
 
     for( size_t i=0; i < collectionSize; ++i )
     {
         const TrajectorySeed* pSeed= &( *pSeedCollectionHandle_)[i];
 
         // The return of this function has first as the index and second as the number of associated hits
         std::vector < std::pair<edm::Ref<TrackingParticleCollection>,size_t> > trackingParticleQualityPairs=
                 (pClusterToTPList!=nullptr) ? associateTrack( *pClusterToTPList, trackingParticleCollectionHandle, pSeed->recHits().first, pSeed->recHits().second ) : associateTrack( *pTrackerHitAssociator, trackingParticleCollectionHandle, pSeed->recHits().first, pSeed->recHits().second );
         for( std::vector<std::pair<edm::Ref<TrackingParticleCollection>,size_t> >::const_iterator iTrackingParticleQualityPair=
                 trackingParticleQualityPairs.begin(); iTrackingParticleQualityPair != trackingParticleQualityPairs.end();
                 ++iTrackingParticleQualityPair )
         {
             const edm::Ref<TrackingParticleCollection>& trackingParticleRef=iTrackingParticleQualityPair->first;
             size_t numberOfSharedHits=iTrackingParticleQualityPair->second;
             size_t numberOfValidTrackHits=pSeed->recHits().second - pSeed->recHits().first;
 
             if( numberOfSharedHits == 0 ) continue; // No point in continuing if there was no association
 
             //if electron subtract double counting
             if( abs( trackingParticleRef->pdgId() ) == 11 && (trackingParticleRef->g4Track_end() - trackingParticleRef->g4Track_begin()) > 1 )
             {
                 if( pClusterToTPList!=nullptr ) numberOfSharedHits-=getDoubleCount( *pClusterToTPList, pSeed->recHits().first, pSeed->recHits().second, trackingParticleRef );
                 else numberOfSharedHits-=getDoubleCount( *pTrackerHitAssociator, pSeed->recHits().first, pSeed->recHits().second, trackingParticleRef );
             }
 
             double quality;
             if( absoluteNumberOfHits_ ) quality=static_cast<double>( numberOfSharedHits );
             else if( numberOfValidTrackHits != 0 ) quality=
                     (static_cast<double>( numberOfSharedHits ) / static_cast<double>( numberOfValidTrackHits ));
             else quality=0;
 
             if( quality > cutRecoToSim_ && !(threeHitTracksAreSpecial_ && numberOfValidTrackHits == 3 && numberOfSharedHits < 3) )
             {
                 returnValue.insert( edm::RefToBase < TrajectorySeed > (pSeedCollectionHandle_, i), std::make_pair( trackingParticleRef, quality ) );
             }
         }
     }
 
     LogTrace( "TrackAssociator" ) << "% of Assoc Seeds=" << ((double)returnValue.size()) / ((double)pSeedCollectionHandle_->size());
     returnValue.post_insert();
     return returnValue;
 
 }

template<class T_TrackCollection , class T_TrackingParticleCollection , class T_hitOrClusterAssociator >

reco::RecoToSimCollection QuickTrackAssociatorByHits::associateRecoToSimImplementation	(	T_TrackCollection	trackCollection,
		T_TrackingParticleCollection	trackingParticleCollection,
		T_hitOrClusterAssociator	hitOrClusterAssociator
	)		const

private

The method that does the work for both overloads of associateRecoToSim.

Parts that actually rely on the type of the collections are delegated out to overloaded functions in the unnamed namespace of the .cc file. Parts that rely on the type of T_hitOrClusterAssociator are delegated out to overloaded methods.

Definition at line 195 of file QuickTrackAssociatorByHits.cc.

References funct::abs(), absoluteNumberOfHits_, associateTrack(), cutRecoToSim_, reco::Track::found(), getDoubleCount(), i, edm::AssociationMap< Tag >::insert(), reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), and threeHitTracksAreSpecial_.

Referenced by associateRecoToSim().

 {
     reco::RecoToSimCollection returnValue;
 
     size_t collectionSize=::collectionSize(trackCollection); // Delegate away type specific part
 
     //std::cout << "#reco Tracks = " << collectionSize << std::endl;
     for( size_t i=0; i < collectionSize; ++i )
     {
         const reco::Track* pTrack=::getTrackAt(trackCollection,i); // Get a normal pointer for ease of use. This part is type specific so delegate.
         //    std::cout << ">>> recoTrack #index = " << i << " pt = " << pTrack->pt() << std::endl;
 
         // The return of this function has first as the index and second as the number of associated hits
         std::vector < std::pair<edm::Ref<TrackingParticleCollection>,size_t> > trackingParticleQualityPairs=associateTrack( hitOrClusterAssociator, trackingParticleCollection, pTrack->recHitsBegin(), pTrack->recHitsEnd() );
 
         // int nt = 0;
         for( std::vector<std::pair<edm::Ref<TrackingParticleCollection>,size_t> >::const_iterator iTrackingParticleQualityPair=
                 trackingParticleQualityPairs.begin(); iTrackingParticleQualityPair != trackingParticleQualityPairs.end();
                 ++iTrackingParticleQualityPair )
         {
             const edm::Ref<TrackingParticleCollection>& trackingParticleRef=iTrackingParticleQualityPair->first;
             size_t numberOfSharedHits=iTrackingParticleQualityPair->second;
             size_t numberOfValidTrackHits=pTrack->found();
 
             //std::cout << ">>> reco2sim. numberOfSharedHits = " << nt++ << ", " << numberOfSharedHits << std::endl;
             if( numberOfSharedHits == 0 ) continue; // No point in continuing if there was no association
 
             //if electron subtract double counting
             if( abs( trackingParticleRef->pdgId() ) == 11 && (trackingParticleRef->g4Track_end() - trackingParticleRef->g4Track_begin()) > 1 )
             {
                 numberOfSharedHits-=getDoubleCount( hitOrClusterAssociator, pTrack->recHitsBegin(), pTrack->recHitsEnd(), trackingParticleRef );
             }
 
             double quality;
             if( absoluteNumberOfHits_ ) quality=static_cast<double>( numberOfSharedHits );
             else if( numberOfValidTrackHits != 0 ) quality=
                     (static_cast<double>( numberOfSharedHits ) / static_cast<double>( numberOfValidTrackHits ));
             else quality=0;
             if( quality > cutRecoToSim_ && !(threeHitTracksAreSpecial_ && numberOfValidTrackHits == 3 && numberOfSharedHits < 3) )
             {
                 // Getting the RefToBase is dependent on the type of trackCollection, so delegate that to an overload.
                 returnValue.insert( ::getRefToTrackAt(trackCollection,i), std::make_pair( trackingParticleRef, quality ) );
             }
         }
     }
     return returnValue;
 }

reco::SimToRecoCollection QuickTrackAssociatorByHits::associateSimToReco	(	edm::Handle< edm::View< reco::Track > > &	tCH,
		edm::Handle< TrackingParticleCollection > &	tPCH,
		const edm::Event *	event = `0`,
		const edm::EventSetup *	setup = `0`
	)		const

overridevirtual

compare reco to sim the handle of reco::Track and TrackingParticle collections

Reimplemented from TrackAssociatorBase.

Definition at line 154 of file QuickTrackAssociatorByHits.cc.

References associateSimToRecoImplementation(), and prepareEitherHitAssociatorOrClusterToTPMap().

 {
     std::unique_ptr<ClusterTPAssociationList> pClusterToTPMap;
     std::unique_ptr<TrackerHitAssociator> pHitAssociator;
     // This call will set EITHER pClusterToTPMap OR pHitAssociator depending on what the user requested in the configuration.
     prepareEitherHitAssociatorOrClusterToTPMap( pEvent, pClusterToTPMap, pHitAssociator );
 
     // Only pass the one that was successfully created to the templated method.
     if( pClusterToTPMap==nullptr ) return associateSimToRecoImplementation( trackCollectionHandle, trackingParticleCollectionHandle, *pHitAssociator );
     else return associateSimToRecoImplementation( trackCollectionHandle, trackingParticleCollectionHandle, *pClusterToTPMap );
 }

reco::SimToRecoCollection QuickTrackAssociatorByHits::associateSimToReco	(	const edm::RefToBaseVector< reco::Track > &	tc,
		const edm::RefVector< TrackingParticleCollection > &	tpc,
		const edm::Event *	event = `0`,
		const edm::EventSetup *	setup = `0`
	)		const

overridevirtual

Association Sim To Reco with Collections.

Implements TrackAssociatorBase.

Definition at line 180 of file QuickTrackAssociatorByHits.cc.

References associateSimToRecoImplementation(), and prepareEitherHitAssociatorOrClusterToTPMap().

 {
     std::unique_ptr<ClusterTPAssociationList> pClusterToTPMap;
     std::unique_ptr<TrackerHitAssociator> pHitAssociator;
     // This call will set EITHER pClusterToTPMap OR pHitAssociator depending on what the user requested in the configuration.
     prepareEitherHitAssociatorOrClusterToTPMap( pEvent, pClusterToTPMap, pHitAssociator );
 
     // Only pass the one that was successfully created to the templated method.
     if( pClusterToTPMap==nullptr ) return associateSimToRecoImplementation( trackCollection, trackingParticleCollection, *pHitAssociator );
     else return associateSimToRecoImplementation( trackCollection, trackingParticleCollection, *pClusterToTPMap );
 }

reco::SimToRecoCollectionSeed QuickTrackAssociatorByHits::associateSimToReco	(	edm::Handle< edm::View< TrajectorySeed > > &	pSeedCollectionHandle_,
		edm::Handle< TrackingParticleCollection > &	trackingParticleCollectionHandle,
		const edm::Event *	event,
		const edm::EventSetup *	setup
	)		const

overridevirtual

Reimplemented from TrackAssociatorBase.

Definition at line 669 of file QuickTrackAssociatorByHits.cc.

References funct::abs(), absoluteNumberOfHits_, associateTrack(), denomreco, denomsim, getDoubleCount(), i, edm::AssociationMap< Tag >::insert(), LogTrace, edm::AssociationMap< Tag >::post_insert(), prepareEitherHitAssociatorOrClusterToTPMap(), puritySimToReco_, qualitySimToReco_, TrajectorySeed::recHits(), simToRecoDenominator_, edm::AssociationMap< Tag >::size(), and threeHitTracksAreSpecial_.

 {
 
     edm::LogVerbatim( "TrackAssociator" ) << "Starting TrackAssociatorByHits::associateSimToReco - #seeds=" << pSeedCollectionHandle_->size()
             << " #TPs=" << trackingParticleCollectionHandle->size();
 
     //
     // First create either the hit associator or the cluster to TrackingParticle map
     // depending on how the user set the configuration. Depending on the logic here
     // only one of pClusterToTPList or pTrackerHitAssociator will ever be non-null.
     //
     std::unique_ptr<ClusterTPAssociationList> pClusterToTPList;
     std::unique_ptr<TrackerHitAssociator> pTrackerHitAssociator;
     // This call will set EITHER pClusterToTPList OR pHitAssociator depending on what the user requested in the configuration.
     prepareEitherHitAssociatorOrClusterToTPMap( pEvent, pClusterToTPList, pTrackerHitAssociator );
 
     //
     // Now that either pClusterToTPList or pTrackerHitAssociator have been initialised
     // (never both) I can carry on and do the association.
     //
     reco::SimToRecoCollectionSeed returnValue;
 
     size_t collectionSize=pSeedCollectionHandle_->size();
 
     for( size_t i=0; i < collectionSize; ++i )
     {
         const TrajectorySeed* pSeed= &( *pSeedCollectionHandle_)[i];
 
         // The return of this function has first as an edm:Ref to the associated TrackingParticle, and second as the number of associated hits
         std::vector < std::pair<edm::Ref<TrackingParticleCollection>,size_t> > trackingParticleQualityPairs=
                 (pClusterToTPList!=nullptr) ? associateTrack( *pClusterToTPList, trackingParticleCollectionHandle, pSeed->recHits().first, pSeed->recHits().second ) : associateTrack( *pTrackerHitAssociator, trackingParticleCollectionHandle, pSeed->recHits().first, pSeed->recHits().second );
         for( std::vector<std::pair<edm::Ref<TrackingParticleCollection>,size_t> >::const_iterator iTrackingParticleQualityPair=
                 trackingParticleQualityPairs.begin(); iTrackingParticleQualityPair != trackingParticleQualityPairs.end();
                 ++iTrackingParticleQualityPair )
         {
             const edm::Ref<TrackingParticleCollection>& trackingParticleRef=iTrackingParticleQualityPair->first;
             size_t numberOfSharedHits=iTrackingParticleQualityPair->second;
             size_t numberOfValidTrackHits=pSeed->recHits().second - pSeed->recHits().first;
             size_t numberOfSimulatedHits=0; // Set a few lines below, but only if required.
 
             if( numberOfSharedHits == 0 ) continue; // No point in continuing if there was no association
 
             //if electron subtract double counting
             if( abs( trackingParticleRef->pdgId() ) == 11 && (trackingParticleRef->g4Track_end() - trackingParticleRef->g4Track_begin()) > 1 )
             {
                 if( pClusterToTPList!=nullptr ) numberOfSharedHits-=getDoubleCount( *pClusterToTPList, pSeed->recHits().first, pSeed->recHits().second, trackingParticleRef );
                 else numberOfSharedHits-=getDoubleCount( *pTrackerHitAssociator, pSeed->recHits().first, pSeed->recHits().second, trackingParticleRef );
             }
 
             if( simToRecoDenominator_ == denomsim || (numberOfSharedHits < 3 && threeHitTracksAreSpecial_) ) // the numberOfSimulatedHits is not always required, so can skip counting in some circumstances
             {
                 // Note that in the standard TrackAssociatorByHits, all of the hits in associatedTrackingParticleHits are checked for
                 // various things.  I'm not sure what these checks are for but they depend on the UseGrouping and UseSplitting settings.
                 // This associator works as though both UseGrouping and UseSplitting were set to true, i.e. just counts the number of
                 // hits in the tracker.
                 numberOfSimulatedHits=trackingParticleRef->numberOfTrackerHits();
             }
 
             double purity=static_cast<double>( numberOfSharedHits ) / static_cast<double>( numberOfValidTrackHits );
             double quality;
             if( absoluteNumberOfHits_ ) quality=static_cast<double>( numberOfSharedHits );
             else if( simToRecoDenominator_ == denomsim && numberOfSimulatedHits != 0 ) quality=static_cast<double>( numberOfSharedHits )
                     / static_cast<double>( numberOfSimulatedHits );
             else if( simToRecoDenominator_ == denomreco && numberOfValidTrackHits != 0 ) quality=purity;
             else quality=0;
 
             if( quality > qualitySimToReco_ && !(threeHitTracksAreSpecial_ && numberOfSimulatedHits == 3 && numberOfSharedHits < 3)
                     && (absoluteNumberOfHits_ || (purity > puritySimToReco_)) )
             {
                 returnValue.insert( trackingParticleRef, std::make_pair( edm::RefToBase < TrajectorySeed > (pSeedCollectionHandle_, i), quality ) );
             }
         }
     }
     return returnValue;
 
     LogTrace("TrackAssociator") << "% of Assoc TPs=" << ((double)returnValue.size())/((double)trackingParticleCollectionHandle->size());
     returnValue.post_insert();
     return returnValue;
 }

template<class T_TrackCollection , class T_TrackingParticleCollection , class T_hitOrClusterAssociator >

reco::SimToRecoCollection QuickTrackAssociatorByHits::associateSimToRecoImplementation	(	T_TrackCollection	trackCollection,
		T_TrackingParticleCollection	trackingParticleCollection,
		T_hitOrClusterAssociator	hitOrClusterAssociator
	)		const

private

The method that does the work for both overloads of associateSimToReco.

Parts that actually rely on the type of the collections are delegated out to overloaded functions in the unnamed namespace of the .cc file. Parts that rely on the type of T_hitOrClusterAssociator are delegated out to overloaded methods.

Definition at line 244 of file QuickTrackAssociatorByHits.cc.

References funct::abs(), absoluteNumberOfHits_, associateTrack(), denomreco, denomsim, reco::Track::found(), getDoubleCount(), i, edm::AssociationMap< Tag >::insert(), puritySimToReco_, qualitySimToReco_, reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), simToRecoDenominator_, and threeHitTracksAreSpecial_.

Referenced by associateSimToReco().

 {
     reco::SimToRecoCollection returnValue;
 
     size_t collectionSize=::collectionSize(trackCollection); // Delegate away type specific part
 
     for( size_t i=0; i<collectionSize; ++i )
     {
         const reco::Track* pTrack=::getTrackAt(trackCollection,i); // Get a normal pointer for ease of use. This part is type specific so delegate.
 
         // The return of this function has first as an edm:Ref to the associated TrackingParticle, and second as the number of associated hits
         std::vector < std::pair<edm::Ref<TrackingParticleCollection>,size_t> > trackingParticleQualityPairs=associateTrack( hitOrClusterAssociator, trackingParticleCollection, pTrack->recHitsBegin(), pTrack->recHitsEnd() );
 
         // int nt = 0;
         for( std::vector< std::pair<edm::Ref<TrackingParticleCollection>,size_t> >::const_iterator iTrackingParticleQualityPair=trackingParticleQualityPairs.begin();
                 iTrackingParticleQualityPair!=trackingParticleQualityPairs.end(); ++iTrackingParticleQualityPair )
         {
             const edm::Ref<TrackingParticleCollection>& trackingParticleRef=iTrackingParticleQualityPair->first;
             size_t numberOfSharedHits=iTrackingParticleQualityPair->second;
             size_t numberOfValidTrackHits=pTrack->found();
             size_t numberOfSimulatedHits=0; // Set a few lines below, but only if required.
 
             //std::cout << ">>> sim2reco. numberOfSharedHits = " << nt++ << ", " << numberOfSharedHits << std::endl;
             if( numberOfSharedHits==0 ) continue; // No point in continuing if there was no association
 
             if( simToRecoDenominator_==denomsim || (numberOfSharedHits<3 && threeHitTracksAreSpecial_) ) // the numberOfSimulatedHits is not always required, so can skip counting in some circumstances
             {
                 // Note that in the standard TrackAssociatorByHits, all of the hits in associatedTrackingParticleHits are checked for
                 // various things.  I'm not sure what these checks are for but they depend on the UseGrouping and UseSplitting settings.
                 // This associator works as though both UseGrouping and UseSplitting were set to true, i.e. just counts the number of
                 // hits in the tracker.
                 numberOfSimulatedHits=trackingParticleRef->numberOfTrackerHits();
             }
 
             //if electron subtract double counting
             if (abs(trackingParticleRef->pdgId())==11 && (trackingParticleRef->g4Track_end() - trackingParticleRef->g4Track_begin()) > 1 )
             {
                 numberOfSharedHits -= getDoubleCount( hitOrClusterAssociator, pTrack->recHitsBegin(), pTrack->recHitsEnd(), trackingParticleRef );
             }
 
             double purity=static_cast<double>(numberOfSharedHits)/static_cast<double>(numberOfValidTrackHits);
             double quality;
             if( absoluteNumberOfHits_ ) quality=static_cast<double>(numberOfSharedHits);
             else if( simToRecoDenominator_==denomsim && numberOfSimulatedHits != 0 ) quality=static_cast<double>(numberOfSharedHits)/static_cast<double>(numberOfSimulatedHits);
             else if( simToRecoDenominator_==denomreco && numberOfValidTrackHits != 0 ) quality=purity;
             else quality=0;
 
             if( quality>qualitySimToReco_ && !( threeHitTracksAreSpecial_ && numberOfSimulatedHits==3 && numberOfSharedHits<3 ) && ( absoluteNumberOfHits_ || (purity>puritySimToReco_) ) )
             {
                 // Getting the RefToBase is dependent on the type of trackCollection, so delegate that to an overload.
                 returnValue.insert( trackingParticleRef, std::make_pair( ::getRefToTrackAt(trackCollection,i), quality ) );
             }
         }
     }
     return returnValue;
 
 }

template<typename T_TPCollection , typename iter >

std::vector< std::pair< edm::Ref< TrackingParticleCollection >, size_t > > QuickTrackAssociatorByHits::associateTrack	(	const TrackerHitAssociator &	hitAssociator,
		T_TPCollection	trackingParticles,
		iter	begin,
		iter	end
	)		const

private

Returns the TrackingParticle that has the most associated hits to the given track.

Return value is a vector of pairs, where first is an edm::Ref to the associated TrackingParticle, and second is the number of associated hits.

Definition at line 302 of file QuickTrackAssociatorByHits.cc.

References getAllSimTrackIdentifiers(), i, TrackingParticle::numberOfHits(), and trackingParticleContainsIdentifier().

Referenced by associateRecoToSim(), associateRecoToSimImplementation(), associateSimToReco(), and associateSimToRecoImplementation().

 {
     // The pairs in this vector have a Ref to the associated TrackingParticle as "first" and the number of associated hits as "second"
     std::vector< std::pair<edm::Ref<TrackingParticleCollection>,size_t> > returnValue;
 
     // The pairs in this vector have first as the sim track identifiers, and second the number of reco hits associated to that sim track.
     // Most reco hits will probably have come from the same sim track, so the number of entries in this vector should be fewer than the
     // number of reco hits.  The pair::second entries should add up to the total number of reco hits though.
     std::vector< std::pair<SimTrackIdentifiers,size_t> > hitIdentifiers=getAllSimTrackIdentifiers( hitAssociator, begin, end );
 
     // Loop over the TrackingParticles
     size_t collectionSize=::collectionSize(trackingParticles);
 
     for( size_t i=0; i<collectionSize; ++i )
     {
         const TrackingParticle* pTrackingParticle=getTrackingParticleAt( trackingParticles, i );
 
         // Ignore TrackingParticles with no hits
         if( pTrackingParticle->numberOfHits()==0 ) continue;
 
         size_t numberOfAssociatedHits=0;
         // Loop over all of the sim track identifiers and see if any of them are part of this TrackingParticle. If they are, add
         // the number of reco hits associated to that sim track to the total number of associated hits.
         for( std::vector< std::pair<SimTrackIdentifiers,size_t> >::const_iterator iIdentifierCountPair=hitIdentifiers.begin(); iIdentifierCountPair!=hitIdentifiers.end(); ++iIdentifierCountPair )
         {
             if( trackingParticleContainsIdentifier( pTrackingParticle, iIdentifierCountPair->first ) ) numberOfAssociatedHits+=iIdentifierCountPair->second;
         }
 
         if( numberOfAssociatedHits>0 )
         {
             returnValue.push_back( std::make_pair( getRefToTrackingParticleAt(trackingParticles,i), numberOfAssociatedHits ) );
         }
     }
 
     return returnValue;
 }

template<typename T_TPCollection , typename iter >

std::vector< std::pair< edm::Ref< TrackingParticleCollection >, size_t > > QuickTrackAssociatorByHits::associateTrack	(	const ClusterTPAssociationList &	clusterToTPMap,
		T_TPCollection	trackingParticles,
		iter	begin,
		iter	end
	)		const

private

Returns the TrackingParticle that has the most associated hits to the given track.

See the notes for the other overload for the return type.

Note that the trackingParticles parameter is not actually required since all the information is in clusterToTPMap, but the method signature has to match the other overload because it is called from a templated method.

Definition at line 371 of file QuickTrackAssociatorByHits.cc.

References clusterTPAssociationListGreater(), and getMatchedClusters().

 {
     // Note that the trackingParticles parameter is not actually required since all the information is in clusterToTPMap,
     // but the method signature has to match the other overload because it is called from a templated method.
 
     // The pairs in this vector have a Ref to the associated TrackingParticle as "first" and the number of associated clusters as "second"
     // Note: typedef edm::Ref<TrackingParticleCollection> TrackingParticleRef;
     std::vector < std::pair<edm::Ref<TrackingParticleCollection>,size_t> > returnValue;
     if( clusterToTPMap.empty() ) return returnValue;
 
     // The pairs in this vector have first as the TP, and second the number of reco clusters associated to that TP.
     // Most reco clusters will probably have come from the same sim track (i.e TP), so the number of entries in this
     // vector should be fewer than the number of clusters. The pair::second entries should add up to the total
     // number of reco clusters though.
     std::vector<OmniClusterRef> oClusters=getMatchedClusters( begin, end );
 
     std::map < TrackingParticleRef, size_t > lmap;
     for( std::vector<OmniClusterRef>::const_iterator it=oClusters.begin(); it != oClusters.end(); ++it )
     {
 
         std::pair < OmniClusterRef, TrackingParticleRef > clusterTPpairWithDummyTP( *it, TrackingParticleRef() ); //TP is dummy: for clusterTPAssociationListGreater sorting only the cluster is needed
         auto range=std::equal_range( clusterToTPMap.begin(), clusterToTPMap.end(), clusterTPpairWithDummyTP, clusterTPAssociationListGreater );
         if( range.first != range.second )
         {
             for( auto ip=range.first; ip != range.second; ++ip )
             {
 
                 const TrackingParticleRef trackingParticle=(ip->second);
 
                 // Ignore TrackingParticles with no hits
                 if( trackingParticle->numberOfHits() == 0 ) continue;
 
                 /* Alternative implementation to avoid the use of lmap... memory slightly improved but slightly slower...
                  std::pair<edm::Ref<TrackingParticleCollection>,size_t> tpIntPair(trackingParticle, 1);
                  auto tp_range = std::equal_range(returnValue.begin(), returnValue.end(), tpIntPair, tpIntPairGreater);
                  if ((tp_range.second-tp_range.first)>1) {
                  edm::LogError("TrackAssociator") << ">>> Error in counting TPs!" << " file: " << __FILE__ << " line: " << __LINE__;
                  }
                  if(tp_range.first != tp_range.second) {
                  tp_range.first->second++;
                  } else {
                  returnValue.push_back(tpIntPair);
                  std::sort(returnValue.begin(), returnValue.end(), tpIntPairGreater);
                  }
                  */
                 auto jpos=lmap.find( trackingParticle );
                 if( jpos != lmap.end() ) ++jpos->second;
                 else lmap.insert( std::make_pair( trackingParticle, 1 ) );
             }
         }
     }
     // now copy the map to returnValue
     for( auto ip=lmap.begin(); ip != lmap.end(); ++ip )
     {
         returnValue.push_back( std::make_pair( ip->first, ip->second ) );
     }
     return returnValue;
 }

static bool QuickTrackAssociatorByHits::clusterTPAssociationListGreater	(	std::pair< OmniClusterRef, TrackingParticleRef >	i,
		std::pair< OmniClusterRef, TrackingParticleRef >	j
	)

inlinestaticprivate

Definition at line 108 of file QuickTrackAssociatorByHits.h.

Referenced by associateTrack(), getDoubleCount(), and prepareEitherHitAssociatorOrClusterToTPMap().

108 { return (i.first.rawIndex()>j.first.rawIndex()); }

i

int i

Definition: DBlmapReader.cc:9

j

int j

Definition: DBlmapReader.cc:9

template<typename iter >

std::vector< std::pair< QuickTrackAssociatorByHits::SimTrackIdentifiers, size_t > > QuickTrackAssociatorByHits::getAllSimTrackIdentifiers	(	const TrackerHitAssociator &	hitAssociator,
		iter	begin,
		iter	end
	)		const

private

Returns a vector of pairs where first is a SimTrackIdentifiers (see typedef above) and second is the number of hits that came from that sim track.

This is used so that the TrackingParticle collection only has to be looped over once to search for each sim track, rather than once per hit. E.g. If all the hits in the reco track come from the same sim track, then there will only be one entry with second as the number of hits in the track.

Definition at line 476 of file QuickTrackAssociatorByHits.cc.

References TrackerHitAssociator::associateHitId(), end, getHitFromIter(), and getDQMSummary::iter.

Referenced by associateTrack().

 {
     // The pairs in this vector have first as the sim track identifiers, and second the number of reco hits associated to that sim track.
     std::vector < std::pair<SimTrackIdentifiers,size_t> > returnValue;
 
     std::vector<SimTrackIdentifiers> simTrackIdentifiers;
     // Loop over all of the rec hits in the track
     //iter tRHIterBeginEnd = getTRHIterBeginEnd( pTrack );
     for( iter iRecHit=begin; iRecHit != end; ++iRecHit )
     {
         if( getHitFromIter( iRecHit )->isValid() )
         {
             simTrackIdentifiers.clear();
 
             // Get the identifiers for the sim track that this hit came from. There should only be one entry unless clusters
             // have merged (as far as I know).
             hitAssociator.associateHitId( *(getHitFromIter( iRecHit )), simTrackIdentifiers ); // This call fills simTrackIdentifiers
             // Loop over each identifier, and add it to the return value only if it's not already in there
             for( std::vector<SimTrackIdentifiers>::const_iterator iIdentifier=simTrackIdentifiers.begin(); iIdentifier != simTrackIdentifiers.end();
                     ++iIdentifier )
             {
                 std::vector<std::pair<SimTrackIdentifiers,size_t> >::iterator iIdentifierCountPair;
                 for( iIdentifierCountPair=returnValue.begin(); iIdentifierCountPair != returnValue.end(); ++iIdentifierCountPair )
                 {
                     if( iIdentifierCountPair->first.first == iIdentifier->first && iIdentifierCountPair->first.second == iIdentifier->second )
                     {
                         // This sim track identifier is already in the list, so increment the count of how many hits it relates to.
                         ++iIdentifierCountPair->second;
                         break;
                     }
                 }
                 if( iIdentifierCountPair == returnValue.end() ) returnValue.push_back( std::make_pair( *iIdentifier, 1 ) );
                 // This identifier wasn't found, so add it
             }
         }
     }
     return returnValue;
 }

template<typename iter >

int QuickTrackAssociatorByHits::getDoubleCount	(	const TrackerHitAssociator &	hitAssociator,
		iter	begin,
		iter	end,
		TrackingParticleRef	associatedTrackingParticle
	)		const

private

This method was copied almost verbatim from the standard TrackAssociatorByHits.

Modified 01/May/2014 to take the TrackerHitAssociator as a parameter rather than using a member.

Definition at line 533 of file QuickTrackAssociatorByHits.cc.

References TrackerHitAssociator::associateHitId(), spr::find(), getHitFromIter(), and getDQMSummary::iter.

Referenced by associateRecoToSim(), associateRecoToSimImplementation(), associateSimToReco(), and associateSimToRecoImplementation().

 {
     // This method is largely copied from the standard TrackAssociatorByHits. Once I've tested how much difference
     // it makes I'll go through and comment it properly.
 
     int doubleCount=0;
     std::vector < SimHitIdpr > SimTrackIdsDC;
 
     for( iter iHit=startIterator; iHit != endIterator; iHit++ )
     {
         int idcount=0;
 
         SimTrackIdsDC.clear();
         hitAssociator.associateHitId( *(getHitFromIter( iHit )), SimTrackIdsDC );
         if( SimTrackIdsDC.size() > 1 )
         {
             for( TrackingParticle::g4t_iterator g4T=associatedTrackingParticle->g4Track_begin(); g4T != associatedTrackingParticle->g4Track_end();
                     ++g4T )
             {
                 if( find( SimTrackIdsDC.begin(), SimTrackIdsDC.end(), SimHitIdpr( ( *g4T).trackId(), SimTrackIdsDC.begin()->second ) )
                         != SimTrackIdsDC.end() )
                 {
                     idcount++;
                 }
             }
         }
         if( idcount > 1 ) doubleCount+=(idcount - 1);
     }
 
     return doubleCount;
 }

template<typename iter >

int QuickTrackAssociatorByHits::getDoubleCount	(	const ClusterTPAssociationList &	clusterToTPList,
		iter	begin,
		iter	end,
		TrackingParticleRef	associatedTrackingParticle
	)		const

private

Overload for when using cluster to TrackingParticle association list.

Definition at line 565 of file QuickTrackAssociatorByHits.cc.

References clusterTPAssociationListGreater(), getMatchedClusters(), and getDQMSummary::iter.

 {
     // This code here was written by Subir Sarkar. I'm just splitting it off into a
     // separate method. - Grimes 01/May/2014
 
     int doubleCount=0;
     std::vector < SimHitIdpr > SimTrackIdsDC;
 
     for( iter iHit=startIterator; iHit != endIterator; iHit++ )
     {
         int idcount=0;
 
         std::vector < OmniClusterRef > oClusters=getMatchedClusters( iHit, iHit + 1 );  //only for the cluster being checked
         for( std::vector<OmniClusterRef>::const_iterator it=oClusters.begin(); it != oClusters.end(); ++it )
         {
             std::pair<OmniClusterRef,TrackingParticleRef> clusterTPpairWithDummyTP( *it, TrackingParticleRef() ); //TP is dummy: for clusterTPAssociationListGreater sorting only the cluster is needed
             auto range=std::equal_range( clusterToTPList.begin(), clusterToTPList.end(), clusterTPpairWithDummyTP, clusterTPAssociationListGreater );
             if( range.first != range.second )
             {
                 for( auto ip=range.first; ip != range.second; ++ip )
                 {
                     const TrackingParticleRef trackingParticle=(ip->second);
                     if( associatedTrackingParticle == trackingParticle )
                     {
                         idcount++;
                     }
                 }
             }
         }
 
         if( idcount > 1 ) doubleCount+=(idcount - 1);
     }
 
     return doubleCount;
 }

const TrackingRecHit* QuickTrackAssociatorByHits::getHitFromIter ( trackingRecHit_iterator iter ) const

inlineprivate

Definition at line 169 of file QuickTrackAssociatorByHits.h.

Referenced by getAllSimTrackIdentifiers(), getDoubleCount(), and getMatchedClusters().

                                                                              {
       return &(**iter);
     }

const TrackingRecHit* QuickTrackAssociatorByHits::getHitFromIter ( TrackingRecHitCollection::const_iterator iter ) const

inlineprivate

Definition at line 173 of file QuickTrackAssociatorByHits.h.

                                                                                             {
       return &(*iter);
     }

template<typename iter >

std::vector< OmniClusterRef > QuickTrackAssociatorByHits::getMatchedClusters	(	iter	begin,
		iter	end
	)		const

private

Definition at line 430 of file QuickTrackAssociatorByHits.cc.

References SiStripRecHit1D::cluster(), SiStripRecHit2D::cluster(), SiPixelRecHit::cluster(), end, TrackingRecHit::geographicalId(), getHitFromIter(), edm::Ref< C, T, F >::isNonnull(), TrackingRecHit::isValid(), getDQMSummary::iter, SiStripMatchedRecHit2D::monoClusterRef(), SiStripMatchedRecHit2D::monoHit(), TrackerSingleRecHit::omniClusterRef(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, SiStripMatchedRecHit2D::stereoClusterRef(), SiStripMatchedRecHit2D::stereoHit(), DetId::subdetId(), SiStripDetId::TEC, SiStripDetId::TIB, SiStripDetId::TID, and SiStripDetId::TOB.

Referenced by associateTrack(), and getDoubleCount().

 {
     std::vector<OmniClusterRef> returnValue;
     for (iter iRecHit = begin; iRecHit != end; ++iRecHit) {
         const TrackingRecHit* rhit = getHitFromIter(iRecHit);
         if (rhit->isValid()) {
             int subdetid = rhit->geographicalId().subdetId();
             if (subdetid==PixelSubdetector::PixelBarrel||subdetid==PixelSubdetector::PixelEndcap) {
                 const SiPixelRecHit* pRHit = dynamic_cast<const SiPixelRecHit*>(rhit);
                 if (!pRHit->cluster().isNonnull())
                     edm::LogError("TrackAssociator") << ">>> RecHit does not have an associated cluster!" << " file: " << __FILE__ << " line: " << __LINE__;
                 returnValue.push_back(pRHit->omniClusterRef());
             }
             else if (subdetid==SiStripDetId::TIB||subdetid==SiStripDetId::TOB||subdetid==SiStripDetId::TID||subdetid==SiStripDetId::TEC) {
                 const std::type_info &tid = typeid(*rhit);
                 if (tid == typeid(SiStripMatchedRecHit2D)) {
                     const SiStripMatchedRecHit2D* sMatchedRHit = dynamic_cast<const SiStripMatchedRecHit2D*>(rhit);
                     if (!sMatchedRHit->monoHit().cluster().isNonnull() || !sMatchedRHit->stereoHit().cluster().isNonnull())
                         edm::LogError("TrackAssociator") << ">>> RecHit does not have an associated cluster!" << " file: " << __FILE__ << " line: " << __LINE__;
                     returnValue.push_back(sMatchedRHit->monoClusterRef());
                     returnValue.push_back(sMatchedRHit->stereoClusterRef());
                 }
                 else if (tid == typeid(SiStripRecHit2D)) {
                     const SiStripRecHit2D* sRHit = dynamic_cast<const SiStripRecHit2D*>(rhit);
                     if (!sRHit->cluster().isNonnull())
                         edm::LogError("TrackAssociator") << ">>> RecHit does not have an associated cluster!" << " file: " << __FILE__ << " line: " << __LINE__;
                     returnValue.push_back(sRHit->omniClusterRef());
                 }
                 else if (tid == typeid(SiStripRecHit1D)) {
                     const SiStripRecHit1D* sRHit = dynamic_cast<const SiStripRecHit1D*>(rhit);
                     if (!sRHit->cluster().isNonnull())
                         edm::LogError("TrackAssociator") << ">>> RecHit does not have an associated cluster!" << " file: " << __FILE__ << " line: " << __LINE__;
                     returnValue.push_back(sRHit->omniClusterRef());
                 }
                 else {
                     edm::LogError("TrackAssociator") << ">>> getMatchedClusters: TrackingRecHit not associated to any SiStripCluster! subdetid = " << subdetid;
                 }
             }
             else {
                 edm::LogError("TrackAssociator") << ">>> getMatchedClusters: TrackingRecHit not associated to any cluster! subdetid = " << subdetid;
             }
         }
     }
     return returnValue;
 }

void QuickTrackAssociatorByHits::prepareEitherHitAssociatorOrClusterToTPMap	(	const edm::Event *	pEvent,
		std::unique_ptr< ClusterTPAssociationList > &	pClusterToTPMap,
		std::unique_ptr< TrackerHitAssociator > &	pHitAssociator
	)		const

private

creates either a ClusterTPAssociationList OR a TrackerHitAssociator and stores it in the provided unique_ptr. The other will be null.

A decision is made whether to create a ClusterTPAssociationList or a TrackerHitAssociator depending on how this track associator was configured. If the ClusterTPAssociationList couldn't be fetched from the event then it falls back to creating a TrackerHitAssociator.

Only one type will be created, never both. The other unique_ptr reference will be null so check for that and decide which to use.

N.B. The value of useClusterTPAssociation_ should not be used to decide which of the two pointers to use. If the cluster to TrackingParticle couldn't be retrieved from the event then pClusterToTPMap will be null but useClusterTPAssociation_ is no longer changed to false.

Definition at line 339 of file QuickTrackAssociatorByHits.cc.

References cluster2TPSrc_, clusterTPAssociationListGreater(), edm::Event::getByLabel(), hitAssociatorParameters_, edm::HandleBase::isValid(), edm::Handle< T >::product(), python.multivaluedict::sort(), and useClusterTPAssociation_.

Referenced by associateRecoToSim(), and associateSimToReco().

 {
     if( useClusterTPAssociation_ )
     {
         edm::Handle<ClusterTPAssociationList> pCluster2TPListH;
         pEvent->getByLabel( cluster2TPSrc_, pCluster2TPListH );
         if( pCluster2TPListH.isValid() )
         {
             pClusterToTPMap.reset( new ClusterTPAssociationList( *(pCluster2TPListH.product()) ) );
             //make sure it is properly sorted
             std::sort( pClusterToTPMap->begin(), pClusterToTPMap->end(), clusterTPAssociationListGreater );
             // Make sure that pHitAssociator is null. There may have been something there before the call.
             pHitAssociator.reset();
             return;
         }
         else
         {
             edm::LogInfo( "TrackAssociator" ) << "ClusterTPAssociationList with label "<< cluster2TPSrc_
                     << " not found. Using DigiSimLink based associator";
             // Can't do this next line anymore because useClusterTPAssociation_ is no longer mutable
             //useClusterTPAssociation_=false;
         }
     }
 
     // If control got this far then either useClusterTPAssociation_ was false or getting the cluster
     // to TrackingParticle association from the event failed. Either way I need to create a hit associator.
     pHitAssociator.reset( new TrackerHitAssociator( *pEvent, hitAssociatorParameters_ ) );
     // Make sure that pClusterToTPMap is null. There may have been something there before the call.
     pClusterToTPMap.reset();
 }

static bool QuickTrackAssociatorByHits::tpIntPairGreater	(	std::pair< edm::Ref< TrackingParticleCollection >, size_t >	i,
		std::pair< edm::Ref< TrackingParticleCollection >, size_t >	j
	)

inlinestaticprivate

Definition at line 109 of file QuickTrackAssociatorByHits.h.

References i, and j.

109 { return (i.first.key()>j.first.key()); }

i

int i

Definition: DBlmapReader.cc:9

j

int j

Definition: DBlmapReader.cc:9

bool QuickTrackAssociatorByHits::trackingParticleContainsIdentifier	(	const TrackingParticle *	pTrackingParticle,
		const SimTrackIdentifiers &	identifier
	)		const

private

Returns true if the supplied TrackingParticle has the supplied g4 track identifiers.

Definition at line 515 of file QuickTrackAssociatorByHits.cc.

References TrackingParticle::g4Track_begin(), and TrackingParticle::g4Track_end().

Referenced by associateTrack().

 {
     // Loop over all of the g4 tracks in the tracking particle
     for( std::vector<SimTrack>::const_iterator iSimTrack=pTrackingParticle->g4Track_begin(); iSimTrack != pTrackingParticle->g4Track_end();
             ++iSimTrack )
     {
         // And see if the sim track identifiers match
         if( iSimTrack->eventId() == identifier.second && iSimTrack->trackId() == identifier.first )
         {
             return true;
         }
     }
 
     // If control has made it this far then none of the identifiers were found in
     // any of the g4 tracks, so return false.
     return false;
 }