#include <VertexAssociatorByPositionAndTracks.h>

Inheritance diagram for VertexAssociatorByPositionAndTracks:

Public Member Functions
reco::VertexRecoToSimCollection	associateRecoToSim (const edm::Handle< edm::View< reco::Vertex >> &vCH, const edm::Handle< TrackingVertexCollection > &tVCH) const override

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

	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)

	~VertexAssociatorByPositionAndTracks () override

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 ( )

override

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

overridevirtual

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, SiStripPI::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, HGCalValidator_cfi::simVertices, edm::View< T >::size(), reco::Vertex::t(), reco::Vertex::tError(), trackRecoToSimAssociation_, reco::Vertex::tracksSize(), RecoVertex_phase2_timing_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

overridevirtual

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

Implements reco::VertexToTrackingVertexAssociatorBaseImpl.

Definition at line 127 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, SiStripPI::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, HGCalValidator_cfi::simVertices, edm::View< T >::size(), reco::Vertex::t(), reco::Vertex::tError(), trackSimToRecoAssociation_, reco::Vertex::tracksSize(), RecoVertex_phase2_timing_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;
 }