---

VertexAssociatorByTracks Class Reference

#include <SimTracker/VertexAssociation/interface/VertexAssociatorByTracks.h>

Inheritance diagram for VertexAssociatorByTracks:

List of all members.

Public Member Functions
reco::VertexRecoToSimCollection	associateRecoToSim (edm::Handle< reco::VertexCollection > &vc, edm::Handle< TrackingVertexCollection > &tvc, const edm::Event &event, reco::RecoToSimCollection &trackAssocResult) const
reco::VertexSimToRecoCollection	associateSimToReco (edm::Handle< reco::VertexCollection > &vc, edm::Handle< TrackingVertexCollection > &tvc, const edm::Event &event, reco::SimToRecoCollection &trackAssocResult) const
	VertexAssociatorByTracks (const edm::ParameterSet &)
	~VertexAssociatorByTracks ()
Private Attributes
const edm::ParameterSet &	conf_

---

Detailed Description

Definition at line 6 of file VertexAssociatorByTracks.h.

---

Constructor & Destructor Documentation

VertexAssociatorByTracks::VertexAssociatorByTracks

(

const edm::ParameterSet &

conf

)

[explicit]

Definition at line 25 of file VertexAssociatorByTracks.cc.

                                                                               :
  conf_(conf) {}

VertexAssociatorByTracks::~VertexAssociatorByTracks

(

)

Definition at line 30 of file VertexAssociatorByTracks.cc.

                                                    {
  //do cleanup here
}

---

Member Function Documentation

VertexRecoToSimCollection VertexAssociatorByTracks::associateRecoToSim	(	edm::Handle< reco::VertexCollection > &	vc,
		edm::Handle< TrackingVertexCollection > &	tvc,
		const edm::Event &	event,
		reco::RecoToSimCollection &	trackAssocResult
	)			const [virtual]

Implements VertexAssociatorBase.

Definition at line 38 of file VertexAssociatorByTracks.cc.

References edm::AssociationMap< Tag >::insert(), edm::match(), edm::Handle< T >::product(), size, and tp.

                                                     {

//  const double minHitFraction = theMinHitFraction;
//  int nshared =0;
//  float fraction=0;
//  std::vector<unsigned int> SimTrackIds;
//  std::vector<unsigned int> matchedIds;

  using reco::VertexRef;

  VertexRecoToSimCollection  outputCollection;

  const TrackingVertexCollection tVC = *(TVCollectionH.product());
  const   reco::VertexCollection  vC = *(vertexCollectionH.product());

//  double minFraction = 0.01;
//  double fraction = 0.8;

  std::map<TrackingVertexRef,int> tVCount;

  int iv = 0;

  // Loop over reco::Vertex

  for (reco::VertexCollection::const_iterator vertex = vC.begin();
       vertex != vC.end(); ++vertex, ++iv) {
    tVCount.clear();
    VertexRef rVertexR = VertexRef(vertexCollectionH,iv);
    double nRecoTracks = vertex->tracksSize();

    // Loop over daughter tracks of reco::Vertex

    for (reco::Vertex::trackRef_iterator recoDaughter = vertex->tracks_begin();
         recoDaughter != vertex->tracks_end(); ++recoDaughter) {
      RefToBase<reco::Track>  tr = recoDaughter->castTo<RefToBase<reco::Track> >();
      if (trackAssocResult[tr].size() > 0) {
        std::vector<std::pair<TrackingParticleRef, double> > tpV = trackAssocResult[tr];

        // Loop over TrackingParticles associated with reco::Track

        for (std::vector<std::pair<TrackingParticleRef, double> >::const_iterator match = tpV.begin();
             match != tpV.end(); ++match) {
          // ... and keep count of it's parent vertex
          TrackingParticleRef tp = match->first;
//          double trackFraction = match->second;
          TrackingVertexRef   tv = tp->parentVertex();
          ++tVCount[tv]; // Count matches to this reco:Vertex for this TrackingVertex
        }
      }
    }

    // Loop over map, set score, add to outputCollection

    for (std::map<TrackingVertexRef,int>::const_iterator match = tVCount.begin();
         match != tVCount.end(); ++match) {
      TrackingVertexRef tV = match->first;
      double nMatches      = match->second;
      outputCollection.insert(rVertexR,std::make_pair(tV,nMatches/nRecoTracks));
    }
  } // Loop on reco::Vertex

  return outputCollection;
}

VertexSimToRecoCollection VertexAssociatorByTracks::associateSimToReco	(	edm::Handle< reco::VertexCollection > &	vc,
		edm::Handle< TrackingVertexCollection > &	tvc,
		const edm::Event &	event,
		reco::SimToRecoCollection &	trackAssocResult
	)			const [virtual]

Implements VertexAssociatorBase.

Definition at line 107 of file VertexAssociatorByTracks.cc.

References edm::AssociationMap< Tag >::end(), edm::AssociationMap< Tag >::find(), edm::AssociationMap< Tag >::insert(), edm::match(), edm::Handle< T >::product(), size, tp, track, and v.

                                                     {

  const TrackingVertexCollection tVC = *(TVCollectionH.product());
  const   reco::VertexCollection  vC = *(vertexCollectionH.product());

  VertexSimToRecoCollection  outputCollection; // return value

  // Loop over TrackingVertexes

  std::map<VertexRef,int> vCount;
  int iTV = 0;
  for (TrackingVertexCollection::const_iterator tV = tVC.begin();
       tV != tVC.end(); ++tV, ++iTV) {
    vCount.clear();
    TrackingVertexRef tVertexR = TrackingVertexRef(TVCollectionH,iTV);
    double nSimTracks = (tV->daughterTracks()).size();

    // Loop over daughter tracks of TrackingVertex
    for (TrackingVertex::tp_iterator simDaughter = tV->daughterTracks_begin();
         simDaughter != tV->daughterTracks_end(); ++simDaughter) {
      TrackingParticleRef tp = *simDaughter;

      SimToRecoCollection::const_iterator daughterPosition = trackAssocResult.find(*simDaughter);
      if (daughterPosition != trackAssocResult.end()) {
        std::vector<std::pair<RefToBase<reco::Track> , double> > recoTracks = trackAssocResult[*simDaughter];

       // Loop over reco::Tracks associated with TrackingParticle
        for (std::vector<std::pair<RefToBase<reco::Track> , double> >::const_iterator match = recoTracks.begin();
             match != recoTracks.end(); ++match) {
          // ... and keep count of it's parent vertex

          TrackBaseRef track(match->first);
//          double   trackQuality = match->second;

          // Find vertex if any where this track comes from
          int iv = 0;
          for (reco::VertexCollection::const_iterator vertex = vC.begin();
              vertex != vC.end(); ++vertex,++iv) {
            VertexRef rVertexR = VertexRef(vertexCollectionH,iv);
            for (reco::Vertex::trackRef_iterator recoDaughter = vertex->tracks_begin();
                 recoDaughter != vertex->tracks_end(); ++recoDaughter) {
              if (*recoDaughter == track) {
                ++vCount[rVertexR]; // Count matches to this TrackingVertex for this reco:Vertex
              }
            }
          }
        }
      }
    }

    // Loop over map, set score, add to outputCollection
    for (std::map<VertexRef,int>::const_iterator match = vCount.begin(); match != vCount.end(); ++match) {
      VertexRef v = match->first;
      double nMatches      = match->second;
      outputCollection.insert(tVertexR,std::make_pair(v,nMatches/nSimTracks));
    }
  }

  return outputCollection;
}

---

Member Data Documentation

const edm::ParameterSet& VertexAssociatorByTracks::conf_ [private]

Definition at line 28 of file VertexAssociatorByTracks.h.

---

The documentation for this class was generated from the following files:

• SimTracker/VertexAssociation/interface/VertexAssociatorByTracks.h
• SimTracker/VertexAssociation/src/VertexAssociatorByTracks.cc

---