TrackToTrackingParticleAssociator that associates by hits a bit quicker than the normal TrackAssociatorByHitsImpl class. More...

#include <QuickTrackAssociatorByHitsImpl.h>

Inheritance diagram for QuickTrackAssociatorByHitsImpl:

Public Types
enum	SimToRecoDenomType { denomnone, denomsim, denomreco }

Public Member Functions
reco::RecoToSimCollection	associateRecoToSim (const edm::Handle< edm::View< reco::Track > > &trackCollectionHandle, const edm::Handle< TrackingParticleCollection > &trackingParticleCollectionHandle) const override

reco::RecoToSimCollectionSeed	associateRecoToSim (const edm::Handle< edm::View< TrajectorySeed > > &, const edm::Handle< TrackingParticleCollection > &) const override

reco::RecoToSimCollection	associateRecoToSim (const edm::RefToBaseVector< reco::Track > &trackCollection, const edm::RefVector< TrackingParticleCollection > &trackingParticleCollection) const override
	Association Reco To Sim with Collections. More...

reco::SimToRecoCollection	associateSimToReco (const edm::Handle< edm::View< reco::Track > > &trackCollectionHandle, const edm::Handle< TrackingParticleCollection > &trackingParticleCollectionHandle) const override

reco::SimToRecoCollectionSeed	associateSimToReco (const edm::Handle< edm::View< TrajectorySeed > > &, const edm::Handle< TrackingParticleCollection > &) const override

reco::SimToRecoCollection	associateSimToReco (const edm::RefToBaseVector< reco::Track > &trackCollection, const edm::RefVector< TrackingParticleCollection > &trackingParticleCollection) const override
	Association Sim To Reco with Collections. More...

	QuickTrackAssociatorByHitsImpl (edm::EDProductGetter const &productGetter, std::unique_ptr< const TrackerHitAssociator > hitAssoc, const ClusterTPAssociation *clusterToTPMap, bool absoluteNumberOfHits, double qualitySimToReco, double puritySimToReco, double cutRecoToSim, double pixelHitWeight, bool threeHitTracksAreSpecial, SimToRecoDenomType simToRecoDenominator)

Public Member Functions inherited from reco::TrackToTrackingParticleAssociatorBaseImpl
virtual reco::RecoToSimCollection	associateRecoToSim (const edm::Handle< edm::View< reco::Track >> &tCH, const edm::Handle< TrackingParticleCollection > &tPCH) const

virtual reco::RecoToSimCollectionSeed	associateRecoToSim (const edm::Handle< edm::View< TrajectorySeed >> &, const edm::Handle< TrackingParticleCollection > &) const

virtual reco::RecoToSimCollectionTCandidate	associateRecoToSim (const edm::Handle< TrackCandidateCollection > &, const edm::Handle< TrackingParticleCollection > &) const

virtual reco::SimToRecoCollection	associateSimToReco (const edm::Handle< edm::View< reco::Track >> &tCH, const edm::Handle< TrackingParticleCollection > &tPCH) const

virtual reco::SimToRecoCollectionSeed	associateSimToReco (const edm::Handle< edm::View< TrajectorySeed >> &, const edm::Handle< TrackingParticleCollection > &) const

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

	TrackToTrackingParticleAssociatorBaseImpl ()
	Constructor. More...

virtual	~TrackToTrackingParticleAssociatorBaseImpl ()
	Destructor. More...

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

typedef edm::IndexSet	TrackingParticleRefKeySet
	Set for TrackingParticleRef keys. More...

Private Member Functions
template<class T_TrackCollection , class T_TrackingParticleCollection , class T_hitOrClusterAssociator >
reco::RecoToSimCollection	associateRecoToSimImplementation (const T_TrackCollection &trackCollection, const T_TrackingParticleCollection &trackingParticleCollection, const TrackingParticleRefKeySet *trackingParticleKeys, 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 (const T_TrackCollection &trackCollection, const T_TrackingParticleCollection &trackingParticleCollection, const TrackingParticleRefKeySet *trackingParticleKeys, 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 >, double > >	associateTrack (const ClusterTPAssociation &clusterToTPMap, const T_TPCollection &trackingParticles, const TrackingParticleRefKeySet *trackingParticleKeys, 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 >, double > >	associateTrack (const TrackerHitAssociator &hitAssociator, const T_TPCollection &trackingParticles, const TrackingParticleRefKeySet *trackingParticleKeys, 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, double > >	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 >
double	getDoubleCount (const ClusterTPAssociation &clusterToTPList, iter begin, iter end, TrackingParticleRef associatedTrackingParticle) const
	Overload for when using cluster to TrackingParticle association list. More...

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

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

double	weightedNumberOfTrackClusters (const reco::Track &track, const ClusterTPAssociation &) const

double	weightedNumberOfTrackClusters (const reco::Track &track, const TrackerHitAssociator &) const

double	weightedNumberOfTrackClusters (const TrajectorySeed &seed, const ClusterTPAssociation &) const

double	weightedNumberOfTrackClusters (const TrajectorySeed &seed, const TrackerHitAssociator &) const

template<typename iter >
double	weightedNumberOfTrackClusters (iter begin, iter end) const

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

Private Attributes
bool	absoluteNumberOfHits_

const ClusterTPAssociation *	clusterToTPMap_

double	cutRecoToSim_

std::unique_ptr< const TrackerHitAssociator >	hitAssociator_

double	pixelHitWeight_

edm::EDProductGetter const *	productGetter_
	creates either a ClusterTPAssociation OR a TrackerHitAssociator and stores it in the provided unique_ptr. The other will be null. More...

double	puritySimToReco_

double	qualitySimToReco_

SimToRecoDenomType	simToRecoDenominator_

bool	threeHitTracksAreSpecial_

Detailed Description

TrackToTrackingParticleAssociator that associates by hits a bit quicker than the normal TrackAssociatorByHitsImpl 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 TrackAssociatorByHitsImpl, but faster. I've tested it a fair bit and can't find any differences between the results of this and the standard TrackAssociatorByHitsImpl.

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 TrackAssociatorByHitsImpl 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 TrackAssociatorByHitsImpl 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 TrackAssociatorByHitsImpl 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 66 of file QuickTrackAssociatorByHitsImpl.h.

Member Typedef Documentation

◆ SimTrackIdentifiers

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

private

This is enough information to uniquely identify a sim track.

Definition at line 104 of file QuickTrackAssociatorByHitsImpl.h.

◆ TrackingParticleRefKeySet

typedef edm::IndexSet QuickTrackAssociatorByHitsImpl::TrackingParticleRefKeySet

private

Set for TrackingParticleRef keys.

Definition at line 106 of file QuickTrackAssociatorByHitsImpl.h.

Member Enumeration Documentation

◆ SimToRecoDenomType

enum QuickTrackAssociatorByHitsImpl::SimToRecoDenomType

Enumerator
denomnone
denomsim
denomreco

Definition at line 68 of file QuickTrackAssociatorByHitsImpl.h.

68 { denomnone, denomsim, denomreco };

Constructor & Destructor Documentation

◆ QuickTrackAssociatorByHitsImpl()

QuickTrackAssociatorByHitsImpl::QuickTrackAssociatorByHitsImpl	(	edm::EDProductGetter const &	productGetter,
		std::unique_ptr< const TrackerHitAssociator >	hitAssoc,
		const ClusterTPAssociation *	clusterToTPMap,
		bool	absoluteNumberOfHits,
		double	qualitySimToReco,
		double	puritySimToReco,
		double	cutRecoToSim,
		double	pixelHitWeight,
		bool	threeHitTracksAreSpecial,
		SimToRecoDenomType	simToRecoDenominator
	)

Definition at line 93 of file QuickTrackAssociatorByHitsImpl.cc.

     : productGetter_(&productGetter),
       hitAssociator_(std::move(hitAssoc)),
       clusterToTPMap_(clusterToTPMap),
       qualitySimToReco_(qualitySimToReco),
       puritySimToReco_(puritySimToReco),
       pixelHitWeight_(pixelHitWeight),
       cutRecoToSim_(cutRecoToSim),
       simToRecoDenominator_(simToRecoDenominator),
       threeHitTracksAreSpecial_(threeHitTracksAreSpecial),
       absoluteNumberOfHits_(absoluteNumberOfHits) {}

Member Function Documentation

◆ associateRecoToSim() [1/3]

reco::RecoToSimCollection QuickTrackAssociatorByHitsImpl::associateRecoToSim	(	const edm::Handle< edm::View< reco::Track > > &	trackCollectionHandle,
		const edm::Handle< TrackingParticleCollection > &	trackingParticleCollectionHandle
	)		const

override

Definition at line 115 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                          {
   // Only pass the one that was successfully created to the templated method.
   if (not clusterToTPMap_)
     return associateRecoToSimImplementation(
         trackCollectionHandle, trackingParticleCollectionHandle, nullptr, *hitAssociator_);
   else
     return associateRecoToSimImplementation(
         trackCollectionHandle, trackingParticleCollectionHandle, nullptr, *clusterToTPMap_);
 }

References associateRecoToSimImplementation(), clusterToTPMap_, and hitAssociator_.

◆ associateRecoToSim() [2/3]

reco::RecoToSimCollectionSeed QuickTrackAssociatorByHitsImpl::associateRecoToSim	(	const edm::Handle< edm::View< TrajectorySeed > > &	pSeedCollectionHandle_,
		const edm::Handle< TrackingParticleCollection > &	trackingParticleCollectionHandle
	)		const

override

Definition at line 591 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                          {
   edm::LogVerbatim("TrackAssociator") << "Starting TrackAssociatorByHitsImpl::associateRecoToSim - #seeds="
                                       << pSeedCollectionHandle_->size()
                                       << " #TPs=" << trackingParticleCollectionHandle->size();
  
   reco::RecoToSimCollectionSeed returnValue(productGetter_);
  
   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>, double> > trackingParticleQualityPairs =
         (clusterToTPMap_) ? associateTrack(*clusterToTPMap_,
                                            trackingParticleCollectionHandle,
                                            nullptr,
                                            pSeed->recHits().begin(),
                                            pSeed->recHits().end())
                           : associateTrack(*hitAssociator_,
                                            trackingParticleCollectionHandle,
                                            nullptr,
                                            pSeed->recHits().begin(),
                                            pSeed->recHits().end());
     for (auto iTrackingParticleQualityPair = trackingParticleQualityPairs.begin();
          iTrackingParticleQualityPair != trackingParticleQualityPairs.end();
          ++iTrackingParticleQualityPair) {
       const edm::Ref<TrackingParticleCollection>& trackingParticleRef = iTrackingParticleQualityPair->first;
       double numberOfSharedClusters = iTrackingParticleQualityPair->second;
       double numberOfValidTrackClusters = clusterToTPMap_ ? weightedNumberOfTrackClusters(*pSeed, *clusterToTPMap_)
                                                           : weightedNumberOfTrackClusters(*pSeed, *hitAssociator_);
  
       if (numberOfSharedClusters == 0.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 (clusterToTPMap_)
           numberOfSharedClusters -=
               getDoubleCount(*clusterToTPMap_, pSeed->recHits().begin(), pSeed->recHits().end(), trackingParticleRef);
         else
           numberOfSharedClusters -=
               getDoubleCount(*hitAssociator_, pSeed->recHits().begin(), pSeed->recHits().end(), trackingParticleRef);
       }
  
       double quality;
       if (absoluteNumberOfHits_)
         quality = numberOfSharedClusters;
       else if (numberOfValidTrackClusters != 0.0)
         quality = numberOfSharedClusters / numberOfValidTrackClusters;
       else
         quality = 0;
  
       if (quality > cutRecoToSim_ &&
           !(threeHitTracksAreSpecial_ && pSeed->nHits() == 3 && numberOfSharedClusters < 3.0)) {
         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;
 }

References funct::abs(), absoluteNumberOfHits_, associateTrack(), edm::Range< T >::begin(), clusterToTPMap_, cutRecoToSim_, edm::Range< T >::end(), getDoubleCount(), hitAssociator_, mps_fire::i, edm::AssociationMap< Tag >::insert(), LogTrace, TrajectorySeed::nHits(), edm::AssociationMap< Tag >::post_insert(), productGetter_, quality, TrajectorySeed::recHits(), edm::AssociationMap< Tag >::size(), threeHitTracksAreSpecial_, and weightedNumberOfTrackClusters().

◆ associateRecoToSim() [3/3]

reco::RecoToSimCollection QuickTrackAssociatorByHitsImpl::associateRecoToSim	(	const edm::RefToBaseVector< reco::Track > &	tc,
		const edm::RefVector< TrackingParticleCollection > &	tpc
	)		const

overridevirtual

Association Reco To Sim with Collections.

Implements reco::TrackToTrackingParticleAssociatorBaseImpl.

Definition at line 139 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                       {
   // Only pass the one that was successfully created to the templated method.
   if (not clusterToTPMap_)
     return associateRecoToSimImplementation(trackCollection, trackingParticleCollection, nullptr, *hitAssociator_);
   else {
     TrackingParticleRefKeySet tpKeys;
     fillKeys(tpKeys, trackingParticleCollection);
     return associateRecoToSimImplementation(trackCollection, trackingParticleCollection, &tpKeys, *clusterToTPMap_);
   }
 }

References associateRecoToSimImplementation(), clusterToTPMap_, hitAssociator_, duplicaterechits_cfi::trackCollection, and PrimaryVertexAnalyzer4PUSlimmed_cfi::trackingParticleCollection.

◆ associateRecoToSimImplementation()

template<class T_TrackCollection , class T_TrackingParticleCollection , class T_hitOrClusterAssociator >

reco::RecoToSimCollection QuickTrackAssociatorByHitsImpl::associateRecoToSimImplementation	(	const T_TrackCollection &	trackCollection,
		const T_TrackingParticleCollection &	trackingParticleCollection,
		const TrackingParticleRefKeySet *	trackingParticleKeys,
		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 166 of file QuickTrackAssociatorByHitsImpl.cc.

                                                            {
   reco::RecoToSimCollection returnValue(productGetter_);
   if (::collectionSize(trackingParticleCollection) == 0)
     return returnValue;
  
   checkClusterMapProductID(hitOrClusterAssociator, trackingParticleCollection);
  
   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 the index and second as the number of associated hits
     std::vector<std::pair<edm::Ref<TrackingParticleCollection>, double> > trackingParticleQualityPairs =
         associateTrack(hitOrClusterAssociator,
                        trackingParticleCollection,
                        trackingParticleKeys,
                        pTrack->recHitsBegin(),
                        pTrack->recHitsEnd());
  
     // int nt = 0;
     for (auto iTrackingParticleQualityPair = trackingParticleQualityPairs.begin();
          iTrackingParticleQualityPair != trackingParticleQualityPairs.end();
          ++iTrackingParticleQualityPair) {
       const edm::Ref<TrackingParticleCollection>& trackingParticleRef = iTrackingParticleQualityPair->first;
       double numberOfSharedClusters = iTrackingParticleQualityPair->second;
       double numberOfValidTrackClusters = weightedNumberOfTrackClusters(*pTrack, hitOrClusterAssociator);
  
       if (numberOfSharedClusters == 0.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) {
         numberOfSharedClusters -=
             getDoubleCount(hitOrClusterAssociator, pTrack->recHitsBegin(), pTrack->recHitsEnd(), trackingParticleRef);
       }
  
       double quality;
       if (absoluteNumberOfHits_)
         quality = numberOfSharedClusters;
       else if (numberOfValidTrackClusters != 0.0)
         quality = numberOfSharedClusters / numberOfValidTrackClusters;
       else
         quality = 0;
       if (quality > cutRecoToSim_ &&
           !(threeHitTracksAreSpecial_ && pTrack->numberOfValidHits() == 3 && numberOfSharedClusters < 3.0)) {
         // 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));
       }
     }
   }
   returnValue.post_insert();
   return returnValue;
 }

References funct::abs(), absoluteNumberOfHits_, associateTrack(), cutRecoToSim_, getDoubleCount(), mps_fire::i, edm::AssociationMap< Tag >::insert(), reco::TrackBase::numberOfValidHits(), edm::AssociationMap< Tag >::post_insert(), productGetter_, quality, reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), threeHitTracksAreSpecial_, duplicaterechits_cfi::trackCollection, PrimaryVertexAnalyzer4PUSlimmed_cfi::trackingParticleCollection, and weightedNumberOfTrackClusters().

Referenced by associateRecoToSim().

◆ associateSimToReco() [1/3]

reco::SimToRecoCollection QuickTrackAssociatorByHitsImpl::associateSimToReco	(	const edm::Handle< edm::View< reco::Track > > &	trackCollectionHandle,
		const edm::Handle< TrackingParticleCollection > &	trackingParticleCollectionHandle
	)		const

override

Definition at line 127 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                          {
   // Only pass the one that was successfully created to the templated method.
   if (not clusterToTPMap_)
     return associateSimToRecoImplementation(
         trackCollectionHandle, trackingParticleCollectionHandle, nullptr, *hitAssociator_);
   else
     return associateSimToRecoImplementation(
         trackCollectionHandle, trackingParticleCollectionHandle, nullptr, *clusterToTPMap_);
 }

References associateSimToRecoImplementation(), clusterToTPMap_, and hitAssociator_.

◆ associateSimToReco() [2/3]

reco::SimToRecoCollectionSeed QuickTrackAssociatorByHitsImpl::associateSimToReco	(	const edm::Handle< edm::View< TrajectorySeed > > &	pSeedCollectionHandle_,
		const edm::Handle< TrackingParticleCollection > &	trackingParticleCollectionHandle
	)		const

override

Definition at line 661 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                          {
   edm::LogVerbatim("TrackAssociator") << "Starting TrackAssociatorByHitsImpl::associateSimToReco - #seeds="
                                       << pSeedCollectionHandle_->size()
                                       << " #TPs=" << trackingParticleCollectionHandle->size();
  
   reco::SimToRecoCollectionSeed returnValue(productGetter_);
   if (trackingParticleCollectionHandle->empty())
     return returnValue;
  
   if (clusterToTPMap_) {
     checkClusterMapProductID(*clusterToTPMap_, trackingParticleCollectionHandle);
   }
  
   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>, double> > trackingParticleQualityPairs =
         (clusterToTPMap_) ? associateTrack(*clusterToTPMap_,
                                            trackingParticleCollectionHandle,
                                            nullptr,
                                            pSeed->recHits().begin(),
                                            pSeed->recHits().end())
                           : associateTrack(*hitAssociator_,
                                            trackingParticleCollectionHandle,
                                            nullptr,
                                            pSeed->recHits().begin(),
                                            pSeed->recHits().end());
     for (auto iTrackingParticleQualityPair = trackingParticleQualityPairs.begin();
          iTrackingParticleQualityPair != trackingParticleQualityPairs.end();
          ++iTrackingParticleQualityPair) {
       const edm::Ref<TrackingParticleCollection>& trackingParticleRef = iTrackingParticleQualityPair->first;
       double numberOfSharedClusters = iTrackingParticleQualityPair->second;
       double numberOfValidTrackClusters = clusterToTPMap_ ? weightedNumberOfTrackClusters(*pSeed, *clusterToTPMap_)
                                                           : weightedNumberOfTrackClusters(*pSeed, *hitAssociator_);
       size_t numberOfSimulatedHits = 0;  // Set a few lines below, but only if required.
  
       if (numberOfSharedClusters == 0.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 (clusterToTPMap_)
           numberOfSharedClusters -=
               getDoubleCount(*clusterToTPMap_, pSeed->recHits().begin(), pSeed->recHits().end(), trackingParticleRef);
         else
           numberOfSharedClusters -=
               getDoubleCount(*hitAssociator_, pSeed->recHits().begin(), pSeed->recHits().end(), trackingParticleRef);
       }
  
       if (simToRecoDenominator_ == denomsim ||
           (numberOfSharedClusters < 3.0 &&
            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 = numberOfSharedClusters / numberOfValidTrackClusters;
       double quality;
       if (absoluteNumberOfHits_)
         quality = numberOfSharedClusters;
       else if (simToRecoDenominator_ == denomsim && numberOfSimulatedHits != 0)
         quality = numberOfSharedClusters / static_cast<double>(numberOfSimulatedHits);
       else if (simToRecoDenominator_ == denomreco && numberOfValidTrackClusters != 0.0)
         quality = purity;
       else
         quality = 0;
  
       if (quality > qualitySimToReco_ &&
           !(threeHitTracksAreSpecial_ && numberOfSimulatedHits == 3 && numberOfSharedClusters < 3.0) &&
           (absoluteNumberOfHits_ || (purity > puritySimToReco_))) {
         returnValue.insert(trackingParticleRef,
                            std::make_pair(edm::RefToBase<TrajectorySeed>(pSeedCollectionHandle_, i), quality));
       }
     }
   }
  
   LogTrace("TrackAssociator") << "% of Assoc TPs="
                               << ((double)returnValue.size()) / ((double)trackingParticleCollectionHandle->size());
   returnValue.post_insert();
   return returnValue;
 }

References funct::abs(), absoluteNumberOfHits_, associateTrack(), edm::Range< T >::begin(), clusterToTPMap_, denomreco, denomsim, edm::Range< T >::end(), getDoubleCount(), hitAssociator_, mps_fire::i, edm::AssociationMap< Tag >::insert(), LogTrace, edm::AssociationMap< Tag >::post_insert(), productGetter_, puritySimToReco_, quality, qualitySimToReco_, TrajectorySeed::recHits(), simToRecoDenominator_, edm::AssociationMap< Tag >::size(), threeHitTracksAreSpecial_, and weightedNumberOfTrackClusters().

◆ associateSimToReco() [3/3]

reco::SimToRecoCollection QuickTrackAssociatorByHitsImpl::associateSimToReco	(	const edm::RefToBaseVector< reco::Track > &	tc,
		const edm::RefVector< TrackingParticleCollection > &	tpc
	)		const

overridevirtual

Association Sim To Reco with Collections.

Implements reco::TrackToTrackingParticleAssociatorBaseImpl.

Definition at line 152 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                       {
   // Only pass the one that was successfully created to the templated method.
   if (not clusterToTPMap_)
     return associateSimToRecoImplementation(trackCollection, trackingParticleCollection, nullptr, *hitAssociator_);
   else {
     TrackingParticleRefKeySet tpKeys;
     fillKeys(tpKeys, trackingParticleCollection);
     return associateSimToRecoImplementation(trackCollection, trackingParticleCollection, &tpKeys, *clusterToTPMap_);
   }
 }

References associateSimToRecoImplementation(), clusterToTPMap_, hitAssociator_, duplicaterechits_cfi::trackCollection, and PrimaryVertexAnalyzer4PUSlimmed_cfi::trackingParticleCollection.

◆ associateSimToRecoImplementation()

template<class T_TrackCollection , class T_TrackingParticleCollection , class T_hitOrClusterAssociator >

reco::SimToRecoCollection QuickTrackAssociatorByHitsImpl::associateSimToRecoImplementation	(	const T_TrackCollection &	trackCollection,
		const T_TrackingParticleCollection &	trackingParticleCollection,
		const TrackingParticleRefKeySet *	trackingParticleKeys,
		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 228 of file QuickTrackAssociatorByHitsImpl.cc.

                                                            {
   reco::SimToRecoCollection returnValue(productGetter_);
   if (::collectionSize(trackingParticleCollection) == 0)
     return returnValue;
  
   checkClusterMapProductID(hitOrClusterAssociator, trackingParticleCollection);
  
   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>, double> > trackingParticleQualityPairs =
         associateTrack(hitOrClusterAssociator,
                        trackingParticleCollection,
                        trackingParticleKeys,
                        pTrack->recHitsBegin(),
                        pTrack->recHitsEnd());
  
     // int nt = 0;
     for (auto iTrackingParticleQualityPair = trackingParticleQualityPairs.begin();
          iTrackingParticleQualityPair != trackingParticleQualityPairs.end();
          ++iTrackingParticleQualityPair) {
       const edm::Ref<TrackingParticleCollection>& trackingParticleRef = iTrackingParticleQualityPair->first;
       double numberOfSharedClusters = iTrackingParticleQualityPair->second;
       double numberOfValidTrackClusters = weightedNumberOfTrackClusters(*pTrack, hitOrClusterAssociator);
       size_t numberOfSimulatedHits = 0;  // Set a few lines below, but only if required.
  
       if (numberOfSharedClusters == 0.0)
         continue;  // No point in continuing if there was no association
  
       if (simToRecoDenominator_ == denomsim ||
           (numberOfSharedClusters < 3.0 &&
            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) {
         numberOfSharedClusters -=
             getDoubleCount(hitOrClusterAssociator, pTrack->recHitsBegin(), pTrack->recHitsEnd(), trackingParticleRef);
       }
  
       double purity = numberOfSharedClusters / numberOfValidTrackClusters;
       double quality;
       if (absoluteNumberOfHits_)
         quality = numberOfSharedClusters;
       else if (simToRecoDenominator_ == denomsim && numberOfSimulatedHits != 0)
         quality = numberOfSharedClusters / static_cast<double>(numberOfSimulatedHits);
       else if (simToRecoDenominator_ == denomreco && numberOfValidTrackClusters != 0)
         quality = purity;
       else
         quality = 0;
  
       if (quality > qualitySimToReco_ &&
           !(threeHitTracksAreSpecial_ && numberOfSimulatedHits == 3 && numberOfSharedClusters < 3.0) &&
           (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));
       }
     }
   }
   returnValue.post_insert();
   return returnValue;
 }

References funct::abs(), absoluteNumberOfHits_, associateTrack(), denomreco, denomsim, getDoubleCount(), mps_fire::i, edm::AssociationMap< Tag >::insert(), edm::AssociationMap< Tag >::post_insert(), productGetter_, puritySimToReco_, quality, qualitySimToReco_, reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), simToRecoDenominator_, threeHitTracksAreSpecial_, duplicaterechits_cfi::trackCollection, PrimaryVertexAnalyzer4PUSlimmed_cfi::trackingParticleCollection, and weightedNumberOfTrackClusters().

Referenced by associateSimToReco().

◆ associateTrack() [1/2]

template<typename T_TPCollection , typename iter >

std::vector< std::pair< edm::Ref< TrackingParticleCollection >, double > > QuickTrackAssociatorByHitsImpl::associateTrack	(	const ClusterTPAssociation &	clusterToTPMap,
		const T_TPCollection &	trackingParticles,
		const TrackingParticleRefKeySet *	trackingParticleKeys,
		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 352 of file QuickTrackAssociatorByHitsImpl.cc.

                     {
   // 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.
  
   // Note further, that we can't completely ignore the
   // trackingParticles parameter, in case it is a subset of those
   // TrackingParticles used to construct clusterToTPMap (via the
   // TrackingParticleRefVector overloads). The trackingParticles
   // parameter is still ignored since looping over it on every call
   // would be expensive, but the keys of the TrackingParticleRefs are
   // cached to an IndexSet (trackingParticleKeys) which is used
   // as a fast search structure.
  
   // The pairs in this vector have a Ref to the associated TrackingParticle as "first" and the weighted number of associated clusters as "second"
   // Note: typedef edm::Ref<TrackingParticleCollection> TrackingParticleRef;
   std::vector<std::pair<edm::Ref<TrackingParticleCollection>, double> > 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 = track_associator::hitsToClusterRefs(begin, end);
  
   std::map<TrackingParticleRef, double> lmap;
   for (std::vector<OmniClusterRef>::const_iterator it = oClusters.begin(); it != oClusters.end(); ++it) {
     auto range = clusterToTPMap.equal_range(*it);
     const double weight = it->isPixel() ? pixelHitWeight_ : 1.0;
     if (range.first != range.second) {
       for (auto ip = range.first; ip != range.second; ++ip) {
         const TrackingParticleRef trackingParticle = (ip->second);
  
         if (trackingParticleKeys && !trackingParticleKeys->has(trackingParticle.key()))
           continue;
  
         // Historically there was a requirement that pTrackingParticle->numberOfHits() > 0
         // However, in TrackingTruthAccumulator, the numberOfHits is calculated from a subset
         // of the SimHits of the SimTracks of a TrackingParticle (essentially limiting the
         // processType and particleType to those of the "first" hit, and particleType to the pdgId of the SimTrack).
         // But, here the association between tracks and TrackingParticles is done with *all* the hits of
         // TrackingParticle, so we should not rely on the numberOfHits() calculated with a subset of SimHits.
  
         /* 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 += weight;
         else
           lmap.insert(std::make_pair(trackingParticle, weight));
       }
     }
   }
   // 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;
 }

References ClusterTPAssociation::empty(), mps_fire::end, ClusterTPAssociation::equal_range(), edm::IndexSet::has(), track_associator::hitsToClusterRefs(), edm::Ref< C, T, F >::key(), pixelHitWeight_, and FastTimerService_cff::range.

◆ associateTrack() [2/2]

template<typename T_TPCollection , typename iter >

std::vector< std::pair< edm::Ref< TrackingParticleCollection >, double > > QuickTrackAssociatorByHitsImpl::associateTrack	(	const TrackerHitAssociator &	hitAssociator,
		const T_TPCollection &	trackingParticles,
		const TrackingParticleRefKeySet *	trackingParticleKeys,
		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 307 of file QuickTrackAssociatorByHitsImpl.cc.

                     {
   // The pairs in this vector have a Ref to the associated TrackingParticle as "first" and the weighted number of associated hits as "second"
   std::vector<std::pair<edm::Ref<TrackingParticleCollection>, double> > 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, double> > 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);
  
     // Historically there was a requirement that pTrackingParticle->numberOfHits() > 0
     // However, in TrackingTruthAccumulator, the numberOfHits is calculated from a subset
     // of the SimHits of the SimTracks of a TrackingParticle (essentially limiting the
     // processType and particleType to those of the "first" hit, and particleType to the pdgId of the SimTrack).
     // But, here the association between tracks and TrackingParticles is done with *all* the hits of
     // TrackingParticle, so we should not rely on the numberOfHits() calculated with a subset of SimHits.
  
     double 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 (const auto& identifierCountPair : hitIdentifiers) {
       if (trackingParticleContainsIdentifier(pTrackingParticle, identifierCountPair.first))
         numberOfAssociatedHits += identifierCountPair.second;
     }
  
     if (numberOfAssociatedHits > 0) {
       returnValue.push_back(std::make_pair(getRefToTrackingParticleAt(trackingParticles, i), numberOfAssociatedHits));
     }
   }
  
   return returnValue;
 }

References mps_fire::end, getAllSimTrackIdentifiers(), TrackQuality_cff::hitAssociator, mps_fire::i, trackingParticleContainsIdentifier(), and muonClassificationByHits_cfi::trackingParticles.

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

◆ getAllSimTrackIdentifiers()

template<typename iter >

std::vector< std::pair< QuickTrackAssociatorByHitsImpl::SimTrackIdentifiers, double > > QuickTrackAssociatorByHitsImpl::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 430 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                           {
   // 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, double> > 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 (track_associator::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(*(track_associator::getHitFromIter(iRecHit)),
                                    simTrackIdentifiers);  // This call fills simTrackIdentifiers
  
       const auto subdetId = track_associator::getHitFromIter(iRecHit)->geographicalId().subdetId();
       const double weight = (subdetId == PixelSubdetector::PixelBarrel || subdetId == PixelSubdetector::PixelEndcap)
                                 ? pixelHitWeight_
                                 : 1.0;
  
       // 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, double> >::iterator iIdentifierCountPair;
         for (auto 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 += weight;
             break;
           }
         }
         if (iIdentifierCountPair == returnValue.end())
           returnValue.push_back(std::make_pair(*iIdentifier, 1.0));
         // This identifier wasn't found, so add it
       }
     }
   }
   return returnValue;
 }

References mps_fire::end, TrackingRecHit::geographicalId(), track_associator::getHitFromIter(), TrackQuality_cff::hitAssociator, sistrip::SpyUtilities::isValid(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, pixelHitWeight_, DetId::subdetId(), and mps_merge::weight.

Referenced by associateTrack().

◆ getDoubleCount() [1/2]

template<typename iter >

double QuickTrackAssociatorByHitsImpl::getDoubleCount	(	const ClusterTPAssociation &	clusterToTPList,
		iter	begin,
		iter	end,
		TrackingParticleRef	associatedTrackingParticle
	)		const

private

Overload for when using cluster to TrackingParticle association list.

Definition at line 539 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                                             {
   // This code here was written by Subir Sarkar. I'm just splitting it off into a
   // separate method. - Grimes 01/May/2014
  
   // The point here is that the electron TrackingParticles may contain
   // multiple SimTracks (from the bremsstrahling), and (historically)
   // the each matched hit/cluster has been multiplied by "how many
   // SimTracks from the TrackingParticle" it contains charge from.
   // Here the amount of this double counting is calculated, so that it
   // can be subtracted by the calling code.
   //
   // Note that recently (hence "historically" in the paragraph above)
   // the ClusterTPAssociationProducer was changed to remove the
   // duplicate cluster->TP associations (hence making this function
   // obsolete), but there is more recent proof that there is some
   // duplication left (to be investigated).
  
   double doubleCount = 0;
   std::vector<SimHitIdpr> SimTrackIdsDC;
  
   for (iter iHit = startIterator; iHit != endIterator; iHit++) {
     std::vector<OmniClusterRef> oClusters =
         track_associator::hitsToClusterRefs(iHit, iHit + 1);  //only for the cluster being checked
     for (std::vector<OmniClusterRef>::const_iterator it = oClusters.begin(); it != oClusters.end(); ++it) {
       int idcount = 0;
  
       auto range = clusterToTPList.equal_range(*it);
       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) {
         const auto subdetId = track_associator::getHitFromIter(iHit)->geographicalId().subdetId();
         const double weight = (subdetId == PixelSubdetector::PixelBarrel || subdetId == PixelSubdetector::PixelEndcap)
                                   ? pixelHitWeight_
                                   : 1.0;
         doubleCount += weight * (idcount - 1);
       }
     }
   }
  
   return doubleCount;
 }

References ClusterTPAssociation::equal_range(), TrackingRecHit::geographicalId(), track_associator::getHitFromIter(), track_associator::hitsToClusterRefs(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, pixelHitWeight_, FastTimerService_cff::range, and DetId::subdetId().

◆ getDoubleCount() [2/2]

template<typename iter >

double QuickTrackAssociatorByHitsImpl::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 494 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                                             {
   // 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.
  
   // FIXME: It may be that this piece is not fully correct for
   // counting how many times a single *cluster* is matched to many
   // SimTracks of a single TrackingParticle (see comments in
   // getDoubleCount(ClusterTPAssociation) overload). To be verified
   // some time.
  
   double doubleCount = 0.0;
   std::vector<SimHitIdpr> SimTrackIdsDC;
  
   for (iter iHit = startIterator; iHit != endIterator; iHit++) {
     int idcount = 0;
  
     SimTrackIdsDC.clear();
     hitAssociator.associateHitId(*(track_associator::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) {
       const auto subdetId = track_associator::getHitFromIter(iHit)->geographicalId().subdetId();
       const double weight = (subdetId == PixelSubdetector::PixelBarrel || subdetId == PixelSubdetector::PixelEndcap)
                                 ? pixelHitWeight_
                                 : 1.0;
       doubleCount += weight * (idcount - 1);
     }
   }
  
   return doubleCount;
 }

References spr::find(), TrackingRecHit::geographicalId(), track_associator::getHitFromIter(), TrackQuality_cff::hitAssociator, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, pixelHitWeight_, and DetId::subdetId().

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

◆ tpIntPairGreater()

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

inlinestaticprivate

Definition at line 109 of file QuickTrackAssociatorByHitsImpl.h.

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

References mps_fire::i, and dqmiolumiharvest::j.

◆ trackingParticleContainsIdentifier()

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

private

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

Definition at line 476 of file QuickTrackAssociatorByHitsImpl.cc.

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

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

Referenced by associateTrack().

◆ weightedNumberOfTrackClusters() [1/5]

double QuickTrackAssociatorByHitsImpl::weightedNumberOfTrackClusters	(	const reco::Track &	track,
		const ClusterTPAssociation &
	)		const

private

Definition at line 776 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                                         {
   return weightedNumberOfTrackClusters(track.recHitsBegin(), track.recHitsEnd());
 }

References HLT_FULL_cff::track, and weightedNumberOfTrackClusters().

◆ weightedNumberOfTrackClusters() [2/5]

double QuickTrackAssociatorByHitsImpl::weightedNumberOfTrackClusters	(	const reco::Track &	track,
		const TrackerHitAssociator &
	)		const

private

Definition at line 754 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                                         {
   const reco::HitPattern& p = track.hitPattern();
   const auto pixelHits = p.numberOfValidPixelHits();
   const auto otherHits = p.numberOfValidHits() - pixelHits;
   return pixelHits * pixelHitWeight_ + otherHits;
 }

References AlCaHLTBitMon_ParallelJobs::p, pixelHitWeight_, and HLT_FULL_cff::track.

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

◆ weightedNumberOfTrackClusters() [3/5]

double QuickTrackAssociatorByHitsImpl::weightedNumberOfTrackClusters	(	const TrajectorySeed &	seed,
		const ClusterTPAssociation &
	)		const

private

Definition at line 780 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                                         {
   const auto& hitRange = seed.recHits();
   return weightedNumberOfTrackClusters(hitRange.begin(), hitRange.end());
 }

References fileCollector::seed, and weightedNumberOfTrackClusters().

◆ weightedNumberOfTrackClusters() [4/5]

double QuickTrackAssociatorByHitsImpl::weightedNumberOfTrackClusters	(	const TrajectorySeed &	seed,
		const TrackerHitAssociator &
	)		const

private

Definition at line 762 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                                         {
   double sum = 0.0;
   for (auto iHit = seed.recHits().begin(); iHit != seed.recHits().end(); ++iHit) {
     const auto subdetId = track_associator::getHitFromIter(iHit)->geographicalId().subdetId();
     const double weight = (subdetId == PixelSubdetector::PixelBarrel || subdetId == PixelSubdetector::PixelEndcap)
                               ? pixelHitWeight_
                               : 1.0;
     sum += weight;
   }
   return sum;
 }

References TrackingRecHit::geographicalId(), track_associator::getHitFromIter(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, pixelHitWeight_, fileCollector::seed, DetId::subdetId(), and mps_merge::weight.

◆ weightedNumberOfTrackClusters() [5/5]

template<typename iter >

double QuickTrackAssociatorByHitsImpl::weightedNumberOfTrackClusters	(	iter	begin,
		iter	end
	)		const

private

Definition at line 787 of file QuickTrackAssociatorByHitsImpl.cc.

                                                                                                {
   double weightedClusters = 0.0;
   for (iter iRecHit = begin; iRecHit != end; ++iRecHit) {
     const auto subdetId = track_associator::getHitFromIter(iRecHit)->geographicalId().subdetId();
     const double weight = (subdetId == PixelSubdetector::PixelBarrel || subdetId == PixelSubdetector::PixelEndcap)
                               ? pixelHitWeight_
                               : 1.0;
     LogTrace("QuickTrackAssociatorByHitsImpl")
         << "  detId: " << track_associator::getHitFromIter(iRecHit)->geographicalId().rawId();
     LogTrace("QuickTrackAssociatorByHitsImpl") << "  weight: " << weight;
     std::vector<OmniClusterRef> oClusters =
         track_associator::hitsToClusterRefs(iRecHit, iRecHit + 1);  //only for the cluster being checked
     for (std::vector<OmniClusterRef>::const_iterator it = oClusters.begin(); it != oClusters.end(); ++it) {
       weightedClusters += weight;
     }
   }
   LogTrace("QuickTrackAssociatorByHitsImpl") << "  total weighted clusters: " << weightedClusters;
   return weightedClusters;
 }

References mps_fire::end, TrackingRecHit::geographicalId(), track_associator::getHitFromIter(), track_associator::hitsToClusterRefs(), LogTrace, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, pixelHitWeight_, DetId::rawId(), DetId::subdetId(), and mps_merge::weight.

Member Data Documentation

◆ absoluteNumberOfHits_

bool QuickTrackAssociatorByHitsImpl::absoluteNumberOfHits_

private

Definition at line 233 of file QuickTrackAssociatorByHitsImpl.h.

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

◆ clusterToTPMap_

const ClusterTPAssociation* QuickTrackAssociatorByHitsImpl::clusterToTPMap_

private

Definition at line 225 of file QuickTrackAssociatorByHitsImpl.h.

Referenced by associateRecoToSim(), and associateSimToReco().

◆ cutRecoToSim_

double QuickTrackAssociatorByHitsImpl::cutRecoToSim_

private

Definition at line 230 of file QuickTrackAssociatorByHitsImpl.h.

Referenced by associateRecoToSim(), and associateRecoToSimImplementation().

◆ hitAssociator_

std::unique_ptr<const TrackerHitAssociator> QuickTrackAssociatorByHitsImpl::hitAssociator_

private

Definition at line 224 of file QuickTrackAssociatorByHitsImpl.h.

Referenced by associateRecoToSim(), and associateSimToReco().

◆ pixelHitWeight_

double QuickTrackAssociatorByHitsImpl::pixelHitWeight_

private

Definition at line 229 of file QuickTrackAssociatorByHitsImpl.h.

Referenced by associateTrack(), getAllSimTrackIdentifiers(), getDoubleCount(), and weightedNumberOfTrackClusters().

◆ productGetter_

edm::EDProductGetter const* QuickTrackAssociatorByHitsImpl::productGetter_

private

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

A decision is made whether to create a ClusterTPAssociation or a TrackerHitAssociator depending on how this track associator was configured. If the ClusterTPAssociation 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 223 of file QuickTrackAssociatorByHitsImpl.h.

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