#include <VertexAssociatorByPositionAndTracks.h>

Inheritance diagram for VertexAssociatorByPositionAndTracks:

Public Member Functions
virtual reco::VertexRecoToSimCollection	associateRecoToSim (const edm::Handle< edm::View< reco::Vertex > > &vCH, const edm::Handle< TrackingVertexCollection > &tVCH) const
	compare reco to sim the handle of reco::Vertex and TrackingVertex collections More...

virtual reco::VertexSimToRecoCollection	associateSimToReco (const edm::Handle< edm::View< reco::Vertex > > &vCH, const edm::Handle< TrackingVertexCollection > &tVCH) const
	compare reco to sim the handle of reco::Vertex and TrackingVertex collections More...

	VertexAssociatorByPositionAndTracks (const edm::EDProductGetter productGetter, double absZ, double sigmaZ, double maxRecoZ, double absT, double sigmaT, double maxRecoT, double sharedTrackFraction, const reco::RecoToSimCollection trackRecoToSimAssociation, const reco::SimToRecoCollection *trackSimToRecoAssociation)

	VertexAssociatorByPositionAndTracks (const edm::EDProductGetter productGetter, double absZ, double sigmaZ, double maxRecoZ, double sharedTrackFraction, const reco::RecoToSimCollection trackRecoToSimAssociation, const reco::SimToRecoCollection *trackSimToRecoAssociation)

virtual	~VertexAssociatorByPositionAndTracks ()

Public Member Functions inherited from reco::VertexToTrackingVertexAssociatorBaseImpl
	VertexToTrackingVertexAssociatorBaseImpl ()
	Constructor. More...

virtual	~VertexToTrackingVertexAssociatorBaseImpl ()
	Destructor. More...

Private Attributes
const double	absT_

const double	absZ_

const double	maxRecoT_

const double	maxRecoZ_

const edm::EDProductGetter *	productGetter_

const double	sharedTrackFraction_

const double	sigmaT_

const double	sigmaZ_

const reco::RecoToSimCollection *	trackRecoToSimAssociation_

const reco::SimToRecoCollection *	trackSimToRecoAssociation_

Detailed Description

This class associates reco::Vertices and TrackingVertices by their position (maximum distance in Z should be smaller than absZ and sigmaZ*zError of reco::Vertex), and (optionally) by the fraction of tracks shared by reco::Vertex and TrackingVertex divided by the number of tracks in reco::Vertex. This fraction is always used as the quality in the association, i.e. multiple associations are sorted by it in descending order.

Definition at line 16 of file VertexAssociatorByPositionAndTracks.h.

Constructor & Destructor Documentation

VertexAssociatorByPositionAndTracks::VertexAssociatorByPositionAndTracks	(	const edm::EDProductGetter *	productGetter,
		double	absZ,
		double	sigmaZ,
		double	maxRecoZ,
		double	absT,
		double	sigmaT,
		double	maxRecoT,
		double	sharedTrackFraction,
		const reco::RecoToSimCollection *	trackRecoToSimAssociation,
		const reco::SimToRecoCollection *	trackSimToRecoAssociation
	)

Definition at line 7 of file VertexAssociatorByPositionAndTracks.cc.

                                                                                                                                   :
   productGetter_(productGetter),
   absZ_(absZ),
   sigmaZ_(sigmaZ),
   maxRecoZ_(maxRecoZ),
   absT_(absT),
   sigmaT_(sigmaT),
   maxRecoT_(maxRecoT),
   sharedTrackFraction_(sharedTrackFraction),
   trackRecoToSimAssociation_(trackRecoToSimAssociation),
   trackSimToRecoAssociation_(trackSimToRecoAssociation)
 {}

VertexAssociatorByPositionAndTracks::VertexAssociatorByPositionAndTracks	(	const edm::EDProductGetter *	productGetter,
		double	absZ,
		double	sigmaZ,
		double	maxRecoZ,
		double	sharedTrackFraction,
		const reco::RecoToSimCollection *	trackRecoToSimAssociation,
		const reco::SimToRecoCollection *	trackSimToRecoAssociation
	)

Definition at line 29 of file VertexAssociatorByPositionAndTracks.cc.

                                                                                                                                   :
   productGetter_(productGetter),
   absZ_(absZ),
   sigmaZ_(sigmaZ),
   maxRecoZ_(maxRecoZ),
   absT_(std::numeric_limits<double>::max()),
   sigmaT_(std::numeric_limits<double>::max()),
   maxRecoT_(std::numeric_limits<double>::max()),
   sharedTrackFraction_(sharedTrackFraction),
   trackRecoToSimAssociation_(trackRecoToSimAssociation),
   trackSimToRecoAssociation_(trackSimToRecoAssociation)
 {}

VertexAssociatorByPositionAndTracks::~VertexAssociatorByPositionAndTracks ( )

virtual

Definition at line 48 of file VertexAssociatorByPositionAndTracks.cc.

48 {}

Member Function Documentation

reco::VertexRecoToSimCollection VertexAssociatorByPositionAndTracks::associateRecoToSim	(	const edm::Handle< edm::View< reco::Vertex > > &	vCH,
		const edm::Handle< TrackingVertexCollection > &	tVCH
	)		const

virtual

compare reco to sim the handle of reco::Vertex and TrackingVertex collections

Implements reco::VertexToTrackingVertexAssociatorBaseImpl.

Definition at line 50 of file VertexAssociatorByPositionAndTracks.cc.

References funct::abs(), absT_, absZ_, EncodedEventId::bunchCrossing(), calculateVertexSharedTracks(), EncodedEventId::event(), TrackingVertex::eventId(), dedxEstimators_cff::fraction, edm::AssociationMap< Tag >::insert(), reco::Vertex::isFake(), reco::Vertex::isValid(), LogDebug, LogTrace, hpstanc_transforms::max, maxRecoZ_, TrackingVertex::nDaughterTracks(), reco::Vertex::ndof(), TrackingVertex::position(), edm::AssociationMap< Tag >::post_insert(), productGetter_, ecalDetailedTimeRecHit_cfi::recoVertex, edm::second(), sharedTrackFraction_, sigmaT_, sigmaZ_, ecalDetailedTimeRecHit_cfi::simVertex, edm::View< T >::size(), reco::Vertex::t(), reco::Vertex::tError(), trackRecoToSimAssociation_, reco::Vertex::tracksSize(), RecoVertex_cff::useTiming, reco::Vertex::z(), and reco::Vertex::zError().

                                                                                                                                                {
   reco::VertexRecoToSimCollection ret(productGetter_);
 
   const edm::View<reco::Vertex>& recoVertices = *vCH;
   const TrackingVertexCollection& simVertices = *tVCH;
 
   LogDebug("VertexAssociation") << "VertexAssociatorByPositionAndTracks::associateRecoToSim(): associating "
                                 << recoVertices.size() << " reco::Vertices to" << simVertices.size() << " TrackingVertices";
 
   // filter sim PVs
   std::vector<size_t> simPVindices;
   simPVindices.reserve(recoVertices.size());
   {
     int current_event = -1;
     for(size_t iSim=0; iSim != simVertices.size(); ++iSim) {
       const TrackingVertex& simVertex = simVertices[iSim];
 
       // Associate only to primary vertices of the in-time pileup
       // events (BX=0, first vertex in each of the events)
       if(simVertex.eventId().bunchCrossing() != 0) continue;
       if(simVertex.eventId().event() != current_event) {
         current_event = simVertex.eventId().event();
         simPVindices.push_back(iSim);
       }
     }
   }
 
   for(size_t iReco=0; iReco != recoVertices.size(); ++iReco) {
     const reco::Vertex& recoVertex = recoVertices[iReco];
 
     // skip fake vertices
     if(std::abs(recoVertex.z()) > maxRecoZ_ || recoVertex.isFake() || !recoVertex.isValid() || recoVertex.ndof() < 0.)
       continue;
 
     LogTrace("VertexAssociation") << " reco::Vertex at Z " << recoVertex.z();
 
     for(const size_t iSim: simPVindices) {
       const TrackingVertex& simVertex = simVertices[iSim];
       LogTrace("VertexAssociation") << "  Considering TrackingVertex at Z " << simVertex.position().z();
 
       //  recoVertex.t() == 0.  is a special value
       // need to change this to std::numeric_limits<double>::max() or something more clear
       const bool useTiming = ( absT_ != std::numeric_limits<double>::max() && recoVertex.t() != 0. );
       if( useTiming ) {
     LogTrace("VertexAssociation") << " and T " << recoVertex.t()*CLHEP::second << std::endl;
       }
 
       const double tdiff = std::abs(recoVertex.t() - simVertex.position().t()*CLHEP::second);
       const double zdiff = std::abs(recoVertex.z() - simVertex.position().z());
       if( zdiff < absZ_ && zdiff / recoVertex.zError() < sigmaZ_ &&
       ( !useTiming || ( tdiff < absT_ && tdiff / recoVertex.tError() < sigmaT_ ) ) ) {
         auto sharedTracks = calculateVertexSharedTracks(recoVertex, simVertex, *trackRecoToSimAssociation_);
         auto fraction = double(sharedTracks)/recoVertex.tracksSize();
         if(sharedTrackFraction_ < 0 || fraction > sharedTrackFraction_) {
           LogTrace("VertexAssociation") << "   Matched with significance " << zdiff/recoVertex.zError() << " " << tdiff/recoVertex.tError()
                                         << " shared tracks " << sharedTracks << " reco Tracks " << recoVertex.tracksSize() << " TrackingParticles " << simVertex.nDaughterTracks();
 
           ret.insert(reco::VertexBaseRef(vCH, iReco), std::make_pair(TrackingVertexRef(tVCH, iSim), sharedTracks));
         }
       }
     }
   }
 
   ret.post_insert();
 
   LogDebug("VertexAssociation") << "VertexAssociatorByPositionAndTracks::associateRecoToSim(): finished";
 
   return ret;
 }

reco::VertexSimToRecoCollection VertexAssociatorByPositionAndTracks::associateSimToReco	(	const edm::Handle< edm::View< reco::Vertex > > &	vCH,
		const edm::Handle< TrackingVertexCollection > &	tVCH
	)		const

virtual

compare reco to sim the handle of reco::Vertex and TrackingVertex collections

Implements reco::VertexToTrackingVertexAssociatorBaseImpl.

Definition at line 121 of file VertexAssociatorByPositionAndTracks.cc.

References funct::abs(), absT_, absZ_, EncodedEventId::bunchCrossing(), calculateVertexSharedTracks(), EncodedEventId::event(), TrackingVertex::eventId(), dedxEstimators_cff::fraction, edm::AssociationMap< Tag >::insert(), reco::Vertex::isFake(), reco::Vertex::isValid(), LogDebug, LogTrace, hpstanc_transforms::max, maxRecoZ_, TrackingVertex::nDaughterTracks(), reco::Vertex::ndof(), TrackingVertex::position(), edm::AssociationMap< Tag >::post_insert(), productGetter_, ecalDetailedTimeRecHit_cfi::recoVertex, edm::second(), sharedTrackFraction_, sigmaT_, sigmaZ_, ecalDetailedTimeRecHit_cfi::simVertex, edm::View< T >::size(), reco::Vertex::t(), reco::Vertex::tError(), trackSimToRecoAssociation_, reco::Vertex::tracksSize(), RecoVertex_cff::useTiming, reco::Vertex::z(), and reco::Vertex::zError().

                                                                                                                                                {
   reco::VertexSimToRecoCollection ret(productGetter_);
 
   const edm::View<reco::Vertex>& recoVertices = *vCH;
   const TrackingVertexCollection& simVertices = *tVCH;
 
   LogDebug("VertexAssociation") << "VertexAssociatorByPositionAndTracks::associateSimToReco(): associating "
                                 << simVertices.size() << " TrackingVertices to " << recoVertices.size() << " reco::Vertices";
 
   int current_event = -1;
   for(size_t iSim=0; iSim != simVertices.size(); ++iSim) {
     const TrackingVertex& simVertex = simVertices[iSim];
 
     // Associate only primary vertices of the in-time pileup
     // events (BX=0, first vertex in each of the events)
     if(simVertex.eventId().bunchCrossing() != 0) continue;
     if(simVertex.eventId().event() != current_event) {
       current_event = simVertex.eventId().event();
     }
     else {
       continue;
     }
 
     LogTrace("VertexAssociation") << " TrackingVertex at Z " << simVertex.position().z();
 
     for(size_t iReco=0; iReco != recoVertices.size(); ++iReco) {
       const reco::Vertex& recoVertex = recoVertices[iReco];
 
       // skip fake vertices
       if(std::abs(recoVertex.z()) > maxRecoZ_ || recoVertex.isFake() || !recoVertex.isValid() || recoVertex.ndof() < 0.)
         continue;
 
       LogTrace("VertexAssociation") << "  Considering reco::Vertex at Z " << recoVertex.z();
       const bool useTiming = ( absT_ != std::numeric_limits<double>::max() && recoVertex.t() != 0. );
       if( useTiming ) {
     LogTrace("VertexAssociation") << " and T " << recoVertex.t()*CLHEP::second << std::endl;
       }
 
       const double tdiff = std::abs(recoVertex.t() - simVertex.position().t()*CLHEP::second);
       const double zdiff = std::abs(recoVertex.z() - simVertex.position().z());
       if( zdiff < absZ_ && zdiff / recoVertex.zError() < sigmaZ_ &&
       ( !useTiming || ( tdiff < absT_ && tdiff / recoVertex.tError() < sigmaT_ ) ) ) {
         auto sharedTracks = calculateVertexSharedTracks(simVertex, recoVertex, *trackSimToRecoAssociation_);
         auto fraction = double(sharedTracks)/recoVertex.tracksSize();
         if(sharedTrackFraction_ < 0 || fraction > sharedTrackFraction_) {
           LogTrace("VertexAssociation") << "   Matched with significance " << zdiff/recoVertex.zError() << " " << tdiff/recoVertex.tError()
                                         << " shared tracks " << sharedTracks << " reco Tracks " << recoVertex.tracksSize() << " TrackingParticles " << simVertex.nDaughterTracks();
 
           ret.insert(TrackingVertexRef(tVCH, iSim), std::make_pair(reco::VertexBaseRef(vCH, iReco), sharedTracks));
         }
       }
     }
   }
 
   ret.post_insert();
 
   LogDebug("VertexAssociation") << "VertexAssociatorByPositionAndTracks::associateSimToReco(): finished";
 
   return ret;
 }