#include <GhostTrackVertexFinder.h>

Classes
struct	FinderInfo

Public Types
enum	FitType { kAlwaysWithGhostTrack, kSingleTracksWithGhostTrack, kRefitGhostTrackWithVertices }

Public Member Functions
	GhostTrackVertexFinder ()

	GhostTrackVertexFinder (double maxFitChi2, double mergeThreshold, double primcut, double seccut, FitType fitType)

std::vector< TransientVertex >	vertices (const GhostTrack &ghostTrack, const CachingVertex< 5 > &primary=CachingVertex< 5 >(), const reco::BeamSpot &beamSpot=reco::BeamSpot(), bool hasBeamSpot=false, bool hasPrimaries=false) const

std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const GhostTrack &ghostTrack) const

std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const GlobalVector &direction, double coneRadius, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &primaries, const std::vector< TransientTrack > &tracks) const

std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const GlobalVector &direction, double coneRadius, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &tracks) const

std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const GlobalVector &direction, double coneRadius, const std::vector< TransientTrack > &tracks) const

std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const reco::BeamSpot &beamSpot, const GhostTrack &ghostTrack) const

std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &primaries, const GhostTrack &ghostTrack) const

std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const GhostTrack &ghostTrack) const

std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const GlobalVector &direction, double coneRadius, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &primaries, const std::vector< TransientTrack > &tracks) const

std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const GlobalVector &direction, double coneRadius, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &tracks) const

std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const GlobalVector &direction, double coneRadius, const std::vector< TransientTrack > &tracks) const

std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const reco::BeamSpot &beamSpot, const GhostTrack &ghostTrack) const

std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &primaries, const GhostTrack &ghostTrack) const

std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const reco::Track &ghostTrack, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &primaries, const std::vector< TransientTrack > &tracks, const std::vector< float > &weights=std::vector< float >()) const

std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const reco::Track &ghostTrack, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &tracks, const std::vector< float > &weights=std::vector< float >()) const

std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const reco::Track &ghostTrack, const std::vector< TransientTrack > &tracks, const std::vector< float > &weights=std::vector< float >()) const

	~GhostTrackVertexFinder ()

Private Member Functions
GhostTrackFitter &	ghostTrackFitter () const

std::vector< CachingVertex< 5 > >	initialVertices (const FinderInfo &info) const

CachingVertex< 5 >	mergeVertices (const CachingVertex< 5 > &vertex1, const CachingVertex< 5 > &vertex2, const FinderInfo &info, bool isPrimary) const

bool	reassignTracks (std::vector< CachingVertex< 5 > > &vertices, const FinderInfo &info) const

bool	recursiveMerge (std::vector< CachingVertex< 5 > > &vertices, const FinderInfo &info) const

void	refitGhostTrack (std::vector< CachingVertex< 5 > > &vertices, FinderInfo &info) const

VertexFitter< 5 > &	vertexFitter (bool primary) const

Static Private Member Functions
static double	vertexCompat (const CachingVertex< 5 > &vtx1, const CachingVertex< 5 > &vtx2, const FinderInfo &info, double scale1=1.0, double scale2=1.0)

Private Attributes
FitType	fitType_

std::unique_ptr< GhostTrackFitter >	ghostTrackFitter_

double	maxFitChi2_

double	mergeThreshold_

double	primcut_

std::unique_ptr< VertexFitter< 5 > >	primVertexFitter_

double	seccut_

std::unique_ptr< VertexFitter< 5 > >	secVertexFitter_

Detailed Description

Definition at line 29 of file GhostTrackVertexFinder.h.

Member Enumeration Documentation

◆ FitType

enum reco::GhostTrackVertexFinder::FitType

Enumerator
kAlwaysWithGhostTrack
kSingleTracksWithGhostTrack
kRefitGhostTrackWithVertices

Definition at line 31 of file GhostTrackVertexFinder.h.

31 { kAlwaysWithGhostTrack, kSingleTracksWithGhostTrack, kRefitGhostTrackWithVertices };

Constructor & Destructor Documentation

◆ GhostTrackVertexFinder() [1/2]

GhostTrackVertexFinder::GhostTrackVertexFinder ( )

Definition at line 261 of file GhostTrackVertexFinder.cc.

262 : maxFitChi2_(10.0), mergeThreshold_(3.0), primcut_(2.0), seccut_(5.0), fitType_(kAlwaysWithGhostTrack) {}

◆ GhostTrackVertexFinder() [2/2]

GhostTrackVertexFinder::GhostTrackVertexFinder	(	double	maxFitChi2,
		double	mergeThreshold,
		double	primcut,
		double	seccut,
		FitType	fitType
	)

Definition at line 264 of file GhostTrackVertexFinder.cc.

266 : maxFitChi2_(maxFitChi2), mergeThreshold_(mergeThreshold), primcut_(primcut), seccut_(seccut), fitType_(fitType) {}

◆ ~GhostTrackVertexFinder()

GhostTrackVertexFinder::~GhostTrackVertexFinder ( )

Definition at line 268 of file GhostTrackVertexFinder.cc.

268 {}

Member Function Documentation

◆ ghostTrackFitter()

GhostTrackFitter & GhostTrackVertexFinder::ghostTrackFitter ( ) const

private

Definition at line 270 of file GhostTrackVertexFinder.cc.

                                                                  {
   if (!ghostTrackFitter_.get())
     ghostTrackFitter_ = std::make_unique<GhostTrackFitter>();
  
   return *ghostTrackFitter_;
 }

References ghostTrackFitter_.

Referenced by vertices().

◆ initialVertices()

std::vector< CachingVertex< 5 > > GhostTrackVertexFinder::initialVertices ( const FinderInfo & info ) const

private

Definition at line 640 of file GhostTrackVertexFinder.cc.

                                                                                                  {
   std::vector<CachingVertex<5> > vertices;
   for (std::vector<GhostTrackState>::const_iterator iter = info.states.begin(); iter != info.states.end(); ++iter) {
     if (!iter->isValid())
       continue;
  
     GhostTrackState state(*iter);
     state.linearize(info.pred);
  
     if (!state.isValid())
       continue;
  
     CachingVertex<5> vtx = vertexAtState(info.ghostTrack, info.pred, state);
  
     if (vtx.isValid())  // && fitChi2(vtx) < maxFitChi2_)
       vertices.push_back(vtx);
   }
  
   return vertices;
 }

References info(), vertexAtState(), vertices(), and extraflags_cff::vtx.

Referenced by vertices().

◆ mergeVertices()

CachingVertex< 5 > GhostTrackVertexFinder::mergeVertices	(	const CachingVertex< 5 > &	vertex1,
		const CachingVertex< 5 > &	vertex2,
		const FinderInfo &	info,
		bool	isPrimary
	)		const

private

Definition at line 681 of file GhostTrackVertexFinder.cc.

                                                                              {
   VertexTrackFactory<5> vertexTrackFactory;
  
   VertexState state = stateMean(vertex1.vertexState(), vertex2.vertexState());
   std::vector<RefCountedVertexTrack> linTracks;
   VtxTrackIs isGhostTrack(info.ghostTrack);
   RefCountedVertexTrack vtxGhostTrack;
  
   mergeTrackHelper(vertex1.tracks(), linTracks, state, isGhostTrack, vtxGhostTrack, vertexTrackFactory);
   mergeTrackHelper(vertex2.tracks(), linTracks, state, isGhostTrack, vtxGhostTrack, vertexTrackFactory);
  
   if (vtxGhostTrack && (fitType_ == kAlwaysWithGhostTrack || linTracks.size() < 2))
     linTracks.push_back(vertexTrackFactory.vertexTrack(vtxGhostTrack->linearizedTrack(), vtxGhostTrack->vertexState()));
  
   try {
     CachingVertex<5> vtx;
     if (info.hasBeamSpot && isPrimary)
       vtx = vertexFitter(true).vertex(linTracks, info.beamSpot.position(), info.beamSpot.error());
     else
       vtx = vertexFitter(isPrimary).vertex(linTracks);
     if (vtx.isValid())
       return vtx;
   } catch (const VertexException &e) {
     // fit failed
   }
  
   return CachingVertex<5>();
 }

References MillePedeFileConverter_cfg::e, fitType_, info(), phase2tkutil::isPrimary(), kAlwaysWithGhostTrack, mergeTrackHelper(), stateMean(), CachingVertex< N >::tracks(), VertexFitter< N >::vertex(), vertexFitter(), CachingVertex< N >::vertexState(), VertexTrackFactory< N >::vertexTrack(), and extraflags_cff::vtx.

Referenced by recursiveMerge().

◆ reassignTracks()

bool GhostTrackVertexFinder::reassignTracks	(	std::vector< CachingVertex< 5 > > &	vertices,
		const FinderInfo &	info
	)		const

private

Definition at line 785 of file GhostTrackVertexFinder.cc.

                                                                                                                  {
   std::vector<std::pair<RefCountedVertexTrack, std::vector<RefCountedVertexTrack> > > trackBundles(vertices_.size());
  
   VtxTrackIs isGhostTrack(info.ghostTrack);
  
   bool assignmentChanged = false;
   for (std::vector<CachingVertex<5> >::const_iterator iter = vertices_.begin(); iter != vertices_.end(); ++iter) {
     std::vector<RefCountedVertexTrack> vtxTracks = iter->tracks();
  
     if (vtxTracks.empty()) {
       LinearizedTrackStateFactory linTrackFactory;
       VertexTrackFactory<5> vertexTrackFactory;
  
       RefCountedLinearizedTrackState linState = linTrackFactory.linearizedTrackState(iter->position(), info.ghostTrack);
  
       trackBundles[iter - vertices_.begin()].first = vertexTrackFactory.vertexTrack(linState, iter->vertexState());
     }
  
     for (std::vector<RefCountedVertexTrack>::const_iterator track = vtxTracks.begin(); track != vtxTracks.end();
          ++track) {
       if (isGhostTrack(*track)) {
         trackBundles[iter - vertices_.begin()].first = *track;
         continue;
       }
  
       if ((*track)->weight() < 1e-3) {
         trackBundles[iter - vertices_.begin()].second.push_back(*track);
         continue;
       }
  
       unsigned int idx = iter - vertices_.begin();
       double best = 1.0e9;
       for (std::vector<CachingVertex<5> >::const_iterator vtx = vertices_.begin(); vtx != vertices_.end(); ++vtx) {
         if (info.pred.lambda(vtx->position()) < info.pred.lambda(vertices_[0].position()))
           continue;
  
         double compat = sqr(trackVertexCompat(*vtx, *track));
  
         compat /= (vtx == vertices_.begin()) ? primcut_ : seccut_;
  
         if (compat < best) {
           best = compat;
           idx = vtx - vertices_.begin();
         }
       }
  
       if ((int)idx != iter - vertices_.begin())
         assignmentChanged = true;
  
       trackBundles[idx].second.push_back(*track);
     }
   }
  
   if (!assignmentChanged)
     return false;
  
   VertexTrackFactory<5> vertexTrackFactory;
   std::vector<CachingVertex<5> > vertices;
   vertices.reserve(vertices_.size());
  
   for (std::vector<CachingVertex<5> >::const_iterator iter = vertices_.begin(); iter != vertices_.end(); ++iter) {
     const std::vector<RefCountedVertexTrack> &tracks = trackBundles[iter - vertices_.begin()].second;
     if (tracks.empty())
       continue;
  
     CachingVertex<5> vtx;
  
     if (tracks.size() == 1) {
       const TransientTrack &track = tracks[0]->linearizedTrack()->track();
  
       int idx = -1;
       for (std::vector<GhostTrackState>::const_iterator iter = info.states.begin(); iter != info.states.end(); ++iter) {
         if (iter->isTrack() && iter->track() == track) {
           idx = iter - info.states.begin();
           break;
         }
       }
       if (idx < 0)
         continue;
  
       vtx = vertexAtState(info.ghostTrack, info.pred, info.states[idx]);
       if (!vtx.isValid())
         continue;
     } else {
       std::vector<RefCountedVertexTrack> linTracks = relinearizeTracks(tracks, iter->vertexState());
  
       if (fitType_ == kAlwaysWithGhostTrack)
         linTracks.push_back(
             relinearizeTrack(trackBundles[iter - vertices_.begin()].first, iter->vertexState(), vertexTrackFactory));
  
       bool primary = iter == vertices_.begin();
       try {
         if (primary && info.hasBeamSpot)
           vtx = vertexFitter(true).vertex(linTracks, info.beamSpot.position(), info.beamSpot.error());
         else
           vtx = vertexFitter(primary).vertex(linTracks);
       } catch (const VertexException &e) {
         // fit failed;
       }
       if (!vtx.isValid())
         return false;
     }
  
     vertices.push_back(vtx);
   };
  
   std::swap(vertices_, vertices);
   return true;
 }

References MillePedeFileConverter_cfg::e, fitType_, heavyIonCSV_trainingSettings::idx, info(), kAlwaysWithGhostTrack, LinearizedTrackStateFactory::linearizedTrackState(), primcut_, relinearizeTrack(), relinearizeTracks(), seccut_, sqr(), std::swap(), HLT_FULL_cff::track, tracks, trackVertexCompat(), trackerHitRTTI::vector, VertexFitter< N >::vertex(), vertexAtState(), vertexFitter(), VertexTrackFactory< N >::vertexTrack(), vertices(), and extraflags_cff::vtx.

Referenced by vertices().

◆ recursiveMerge()

bool GhostTrackVertexFinder::recursiveMerge	(	std::vector< CachingVertex< 5 > > &	vertices,
		const FinderInfo &	info
	)		const

private

Definition at line 713 of file GhostTrackVertexFinder.cc.

                                                                                                                 {
   typedef std::pair<unsigned int, unsigned int> Indices;
  
   std::multimap<float, Indices> compatMap;
   unsigned int n = vertices.size();
   for (unsigned int i = 0; i < n; i++) {
     const CachingVertex<5> &v1 = vertices[i];
     for (unsigned int j = i + 1; j < n; j++) {
       const CachingVertex<5> &v2 = vertices[j];
  
       float compat = vertexCompat(v1, v2, info, i == 0 ? primcut_ : seccut_, seccut_);
  
       if (compat > mergeThreshold_)
         continue;
  
       compatMap.insert(std::make_pair(compat, Indices(i, j)));
     }
   }
  
   bool changesMade = false;
   bool repeat = true;
   while (repeat) {
     repeat = false;
     for (std::multimap<float, Indices>::const_iterator iter = compatMap.begin(); iter != compatMap.end(); ++iter) {
       unsigned int v1 = iter->second.first;
       unsigned int v2 = iter->second.second;
  
       CachingVertex<5> newVtx = mergeVertices(vertices[v1], vertices[v2], info, v1 == 0);
       if (!newVtx.isValid() || (v1 != 0 && fitChi2(newVtx) > maxFitChi2_))
         continue;
  
       std::swap(vertices[v1], newVtx);
       vertices.erase(vertices.begin() + v2);
       n--;
  
       std::multimap<float, Indices> newCompatMap;
       for (++iter; iter != compatMap.end(); ++iter) {
         if (iter->second.first == v1 || iter->second.first == v2 || iter->second.second == v1 ||
             iter->second.second == v2)
           continue;
  
         Indices indices = iter->second;
         indices.first -= indices.first > v2;
         indices.second -= indices.second > v2;
  
         newCompatMap.insert(std::make_pair(iter->first, indices));
       }
       std::swap(compatMap, newCompatMap);
  
       for (unsigned int i = 0; i < n; i++) {
         if (i == v1)
           continue;
  
         const CachingVertex<5> &other = vertices[i];
         float compat =
             vertexCompat(vertices[v1], other, info, v1 == 0 ? primcut_ : seccut_, i == 0 ? primcut_ : seccut_);
  
         if (compat > mergeThreshold_)
           continue;
  
         compatMap.insert(std::make_pair(compat, Indices(std::min(i, v1), std::max(i, v1))));
       }
  
       changesMade = true;
       repeat = true;
       break;
     }
   }
  
   return changesMade;
 }

References fitChi2(), mps_fire::i, bTagCombinedSVVariables_cff::indices, info(), dqmiolumiharvest::j, SiStripPI::max, maxFitChi2_, mergeThreshold_, mergeVertices(), min(), dqmiodumpmetadata::n, BeamSpotFilterParameters_cfi::newVtx, trackingPlots::other, primcut_, seccut_, std::swap(), vertexCompat(), and vertices().

Referenced by vertices().

◆ refitGhostTrack()

void GhostTrackVertexFinder::refitGhostTrack	(	std::vector< CachingVertex< 5 > > &	vertices,
		FinderInfo &	info
	)		const

private

Definition at line 895 of file GhostTrackVertexFinder.cc.

                                                                                                            {
   VtxTrackIs isGhostTrack(info.ghostTrack);
  
   std::vector<GhostTrackState> states;
   std::vector<unsigned int> oldStates;
   oldStates.reserve(info.states.size());
  
   for (std::vector<CachingVertex<5> >::const_iterator iter = vertices.begin(); iter != vertices.end(); ++iter) {
     std::vector<RefCountedVertexTrack> vtxTracks = iter->tracks();
  
     oldStates.clear();
     for (std::vector<RefCountedVertexTrack>::const_iterator track = vtxTracks.begin(); track != vtxTracks.end();
          ++track) {
       if (isGhostTrack(*track) || (*track)->weight() < 1e-3)
         continue;
  
       const TransientTrack &tt = (*track)->linearizedTrack()->track();
  
       int idx = -1;
       for (std::vector<GhostTrackState>::const_iterator iter = info.states.begin(); iter != info.states.end(); ++iter) {
         if (iter->isTrack() && iter->track() == tt) {
           idx = iter - info.states.begin();
           break;
         }
       }
  
       if (idx >= 0)
         oldStates.push_back(idx);
     }
  
     if (oldStates.size() == 1)
       states.push_back(info.states[oldStates[0]]);
     else
       states.push_back(GhostTrackState(iter->vertexState()));
   }
  
   KalmanGhostTrackUpdater updater;
   SequentialGhostTrackFitter fitter;
   double ndof, chi2;
   info.pred = fitter.fit(updater, info.prior, states, ndof, chi2);
   TransientTrack ghostTrack = transientGhostTrack(info.pred, info.field);
  
   std::swap(info.states, states);
   states.clear();
  
   std::vector<CachingVertex<5> > newVertices;
   for (std::vector<CachingVertex<5> >::const_iterator iter = vertices.begin(); iter != vertices.end(); ++iter) {
     std::vector<RefCountedVertexTrack> vtxTracks = iter->tracks();
  
     int idx = -1;
     bool redo = false;
     for (std::vector<RefCountedVertexTrack>::iterator track = vtxTracks.begin(); track != vtxTracks.end(); ++track) {
       if (isGhostTrack(*track)) {
         LinearizedTrackStateFactory linTrackFactory;
         VertexTrackFactory<5> vertexTrackFactory;
  
         *track = vertexTrackFactory.vertexTrack(linTrackFactory.linearizedTrackState(iter->position(), ghostTrack),
                                                 iter->vertexState());
         redo = true;
         continue;
       }
  
       const TransientTrack &tt = (*track)->linearizedTrack()->track();
  
       if (idx >= 0) {
         idx = -1;
         break;
       }
  
       for (std::vector<GhostTrackState>::const_iterator it = info.states.begin(); it != info.states.end(); ++it) {
         if (!it->isTrack())
           continue;
  
         if (it->track() == tt) {
           idx = it - info.states.begin();
           break;
         }
       }
     }
  
     if (idx >= 0) {
       CachingVertex<5> vtx = vertexAtState(ghostTrack, info.pred, info.states[idx]);
       if (vtx.isValid())
         newVertices.push_back(vtx);
     } else if (redo) {
       bool primary = iter == vertices.begin();
       CachingVertex<5> vtx;
       if (primary && info.hasBeamSpot)
         vtx = vertexFitter(true).vertex(vtxTracks, info.beamSpot.position(), info.beamSpot.error());
       else
         vtx = vertexFitter(primary).vertex(vtxTracks);
       if (vtx.isValid())
         newVertices.push_back(vtx);
     } else
       newVertices.push_back(*iter);
   }
  
   std::swap(newVertices, vertices);
   info.ghostTrack = ghostTrack;
 }

References hltPixelTracks_cff::chi2, MillePedeFileConverter_cfg::e, reco::SequentialGhostTrackFitter::fit(), heavyIonCSV_trainingSettings::idx, info(), LinearizedTrackStateFactory::linearizedTrackState(), ndof, std::swap(), HLT_FULL_cff::track, transientGhostTrack(), groupFilesInBlocks::tt, trackerHitRTTI::vector, VertexFitter< N >::vertex(), vertexAtState(), vertexFitter(), VertexTrackFactory< N >::vertexTrack(), vertices(), and extraflags_cff::vtx.

Referenced by vertices().

◆ vertexCompat()

double GhostTrackVertexFinder::vertexCompat	(	const CachingVertex< 5 > &	vtx1,
		const CachingVertex< 5 > &	vtx2,
		const FinderInfo &	info,
		double	scale1 = `1.0`,
		double	scale2 = `1.0`
	)

staticprivate

Definition at line 232 of file GhostTrackVertexFinder.cc.

                                                                                                                       {
   Vector3 diff = conv(vtx2.position() - vtx1.position());
   Matrix3S cov = scale1 * vtx1.error().matrix() + scale2 * vtx2.error().matrix();
  
   return sqr(ROOT::Math::Dot(diff, diff)) / ROOT::Math::Similarity(cov, diff);
 }

References conv, change_name::diff, CachingVertex< N >::error(), GlobalErrorBase< T, ErrorWeightType >::matrix(), CachingVertex< N >::position(), and sqr().

Referenced by recursiveMerge().

◆ vertexFitter()

VertexFitter< 5 > & GhostTrackVertexFinder::vertexFitter ( bool primary ) const

private

Definition at line 277 of file GhostTrackVertexFinder.cc.

                                                                         {
   std::unique_ptr<VertexFitter<5> > *ptr = primary ? &primVertexFitter_ : &secVertexFitter_;
   if (!ptr->get())
     *ptr = std::make_unique<AdaptiveVertexFitter>(GeometricAnnealing(primary ? primcut_ : seccut_));
  
   return **ptr;
 }

References primcut_, primVertexFitter_, seccut_, and secVertexFitter_.

Referenced by mergeVertices(), reassignTracks(), and refitGhostTrack().

◆ vertices() [1/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GhostTrack &	ghostTrack,
		const CachingVertex< 5 > &	primary = `CachingVertex<5>()`,
		const reco::BeamSpot &	beamSpot = `reco::BeamSpot()`,
		bool	hasBeamSpot = `false`,
		bool	hasPrimaries = `false`
	)		const

Definition at line 998 of file GhostTrackVertexFinder.cc.

                                                                                        {
   FinderInfo info(primary, ghostTrack, beamSpot, hasBeamSpot, hasPrimaries);
  
   std::vector<TransientVertex> result;
   if (info.states.empty())
     return result;
  
   info.field = info.states[0].track().field();
   info.ghostTrack = transientGhostTrack(info.pred, info.field);
  
   std::vector<CachingVertex<5> > vertices = initialVertices(info);
   if (primary.isValid()) {
     vertices.push_back(primary);
     if (vertices.size() > 1)
       std::swap(vertices.front(), vertices.back());
   }
  
   unsigned int reassigned = 0;
   while (reassigned < 3) {
     if (vertices.size() < 2)
       break;
  
 #ifdef DEBUG
     for (std::vector<CachingVertex<5> >::const_iterator iter = vertices.begin(); iter != vertices.end(); ++iter)
  
       debugVertex(*iter, ghostTrack.prediction());
  
     std::cout << "----- recursive merging: ---------" << std::endl;
 #endif
  
     bool changed = recursiveMerge(vertices, info);
     if ((!changed && !reassigned) || vertices.size() < 2)
       break;
     if (changed)
       reassigned = 0;
  
     if (fitType_ == kRefitGhostTrackWithVertices) {
       refitGhostTrack(vertices, info);
       changed = true;
     }
  
     try {
 #ifdef DEBUG
       for (std::vector<CachingVertex<5> >::const_iterator iter = vertices.begin(); iter != vertices.end(); ++iter)
         debugVertex(*iter, ghostTrack.prediction());
       std::cout << "----- reassignment: ---------" << std::endl;
 #endif
       if (reassignTracks(vertices, info)) {
         reassigned++;
         changed = true;
       } else
         reassigned = 0;
     } catch (const VertexException &e) {
       // just keep vertices as they are
     }
  
     if (!changed)
       break;
   }
  
   for (std::vector<CachingVertex<5> >::const_iterator iter = vertices.begin(); iter != vertices.end(); ++iter) {
     std::vector<RefCountedVertexTrack> tracks = iter->tracks();
     std::vector<RefCountedVertexTrack> newTracks;
     newTracks.reserve(tracks.size());
  
     std::remove_copy_if(tracks.begin(), tracks.end(), std::back_inserter(newTracks), VtxTrackIs(info.ghostTrack));
  
     if (newTracks.empty())
       continue;
  
     CachingVertex<5> vtx(iter->vertexState(), newTracks, iter->totalChiSquared());
     result.push_back(vtx);
   }
  
   return result;
 }

References pwdgSkimBPark_cfi::beamSpot, gather_cfg::cout, MillePedeFileConverter_cfg::e, fitType_, info(), initialVertices(), CachingVertex< N >::isValid(), kRefitGhostTrackWithVertices, reco::GhostTrack::prediction(), reassignTracks(), recursiveMerge(), refitGhostTrack(), mps_fire::result, std::swap(), tracks, transientGhostTrack(), trackerHitRTTI::vector, vertices(), and extraflags_cff::vtx.

◆ vertices() [2/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 447 of file GhostTrackVertexFinder.cc.

                                                                                                   {
   CachingVertex<5> primary(primaryPosition, primaryError, std::vector<RefCountedVertexTrack>(), 0.);
  
   std::vector<TransientVertex> result = vertices(ghostTrack, primary);
  
 #ifdef DEBUG
   for (std::vector<TransientVertex>::const_iterator iter = result.begin(); iter != result.end(); ++iter)
     debugVertex(*iter, ghostTrack.prediction());
 #endif
  
   return result;
 }

References reco::GhostTrack::prediction(), mps_fire::result, and vertices().

◆ vertices() [3/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const GlobalVector &	direction,
		double	coneRadius,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	primaries,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 412 of file GhostTrackVertexFinder.cc.

                                                                                                              {
   GhostTrack ghostTrack = ghostTrackFitter().fit(primaryPosition, primaryError, direction, coneRadius, tracks);
  
   std::vector<RefCountedVertexTrack> primaryVertexTracks;
   if (!primaries.empty()) {
     LinearizedTrackStateFactory linTrackFactory;
     VertexTrackFactory<5> vertexTrackFactory;
  
     VertexState state(primaryPosition, primaryError);
  
     for (std::vector<TransientTrack>::const_iterator iter = primaries.begin(); iter != primaries.end(); ++iter) {
       RefCountedLinearizedTrackState linState = linTrackFactory.linearizedTrackState(primaryPosition, *iter);
  
       primaryVertexTracks.push_back(vertexTrackFactory.vertexTrack(linState, state));
     }
   }
  
   CachingVertex<5> primary(primaryPosition, primaryError, primaryVertexTracks, 0.);
  
   std::vector<TransientVertex> result = vertices(ghostTrack, primary, beamSpot, true, true);
  
 #ifdef DEBUG
   for (std::vector<TransientVertex>::const_iterator iter = result.begin(); iter != result.end(); ++iter)
     debugVertex(*iter, ghostTrack.prediction());
 #endif
  
   return result;
 }

References pwdgSkimBPark_cfi::beamSpot, reco::GhostTrackFitter::fit(), ghostTrackFitter(), LinearizedTrackStateFactory::linearizedTrackState(), reco::GhostTrack::prediction(), mps_fire::result, tracks, VertexTrackFactory< N >::vertexTrack(), and vertices().

◆ vertices() [4/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const GlobalVector &	direction,
		double	coneRadius,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 392 of file GhostTrackVertexFinder.cc.

                                                                                                              {
   GhostTrack ghostTrack = ghostTrackFitter().fit(primaryPosition, primaryError, direction, coneRadius, tracks);
  
   CachingVertex<5> primary(primaryPosition, primaryError, std::vector<RefCountedVertexTrack>(), 0.);
  
   std::vector<TransientVertex> result = vertices(ghostTrack, primary, beamSpot, true);
  
 #ifdef DEBUG
   for (std::vector<TransientVertex>::const_iterator iter = result.begin(); iter != result.end(); ++iter)
     debugVertex(*iter, ghostTrack.prediction());
 #endif
  
   return result;
 }

References pwdgSkimBPark_cfi::beamSpot, reco::GhostTrackFitter::fit(), ghostTrackFitter(), reco::GhostTrack::prediction(), mps_fire::result, tracks, and vertices().

◆ vertices() [5/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const GlobalVector &	direction,
		double	coneRadius,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 373 of file GhostTrackVertexFinder.cc.

                                                                                                              {
   GhostTrack ghostTrack = ghostTrackFitter().fit(primaryPosition, primaryError, direction, coneRadius, tracks);
  
   CachingVertex<5> primary(primaryPosition, primaryError, std::vector<RefCountedVertexTrack>(), 0.);
  
   std::vector<TransientVertex> result = vertices(ghostTrack, primary);
  
 #ifdef DEBUG
   for (std::vector<TransientVertex>::const_iterator iter = result.begin(); iter != result.end(); ++iter)
     debugVertex(*iter, ghostTrack.prediction());
 #endif
  
   return result;
 }

References reco::GhostTrackFitter::fit(), ghostTrackFitter(), reco::GhostTrack::prediction(), mps_fire::result, tracks, and vertices().

◆ vertices() [6/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const reco::BeamSpot &	beamSpot,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 462 of file GhostTrackVertexFinder.cc.

                                                                                                   {
   CachingVertex<5> primary(primaryPosition, primaryError, std::vector<RefCountedVertexTrack>(), 0.);
  
   std::vector<TransientVertex> result = vertices(ghostTrack, primary, beamSpot, true);
  
 #ifdef DEBUG
   for (std::vector<TransientVertex>::const_iterator iter = result.begin(); iter != result.end(); ++iter)
     debugVertex(*iter, ghostTrack.prediction());
 #endif
  
   return result;
 }

References pwdgSkimBPark_cfi::beamSpot, reco::GhostTrack::prediction(), mps_fire::result, and vertices().

◆ vertices() [7/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	primaries,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 478 of file GhostTrackVertexFinder.cc.

                                                                                                   {
   std::vector<RefCountedVertexTrack> primaryVertexTracks;
   if (!primaries.empty()) {
     LinearizedTrackStateFactory linTrackFactory;
     VertexTrackFactory<5> vertexTrackFactory;
  
     VertexState state(primaryPosition, primaryError);
  
     for (std::vector<TransientTrack>::const_iterator iter = primaries.begin(); iter != primaries.end(); ++iter) {
       RefCountedLinearizedTrackState linState = linTrackFactory.linearizedTrackState(primaryPosition, *iter);
  
       primaryVertexTracks.push_back(vertexTrackFactory.vertexTrack(linState, state));
     }
   }
  
   CachingVertex<5> primary(primaryPosition, primaryError, primaryVertexTracks, 0.);
  
   std::vector<TransientVertex> result = vertices(ghostTrack, primary, beamSpot, true, true);
  
 #ifdef DEBUG
   for (std::vector<TransientVertex>::const_iterator iter = result.begin(); iter != result.end(); ++iter)
     debugVertex(*iter, ghostTrack.prediction());
 #endif
  
   return result;
 }

References pwdgSkimBPark_cfi::beamSpot, LinearizedTrackStateFactory::linearizedTrackState(), reco::GhostTrack::prediction(), mps_fire::result, VertexTrackFactory< N >::vertexTrack(), and vertices().

◆ vertices() [8/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 509 of file GhostTrackVertexFinder.cc.

                                                                                                   {
   return vertices(
       RecoVertex::convertPos(primaryVertex.position()), RecoVertex::convertError(primaryVertex.error()), ghostTrack);
 }

References RecoVertex::convertError(), RecoVertex::convertPos(), BeamMonitor_cff::primaryVertex, and vertices().

◆ vertices() [9/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const GlobalVector &	direction,
		double	coneRadius,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	primaries,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 358 of file GhostTrackVertexFinder.cc.

                                                                                                              {
   return vertices(RecoVertex::convertPos(primaryVertex.position()),
                   RecoVertex::convertError(primaryVertex.error()),
                   direction,
                   coneRadius,
                   beamSpot,
                   primaries,
                   tracks);
 }

References pwdgSkimBPark_cfi::beamSpot, RecoVertex::convertError(), RecoVertex::convertPos(), BeamMonitor_cff::primaryVertex, tracks, and vertices().

◆ vertices() [10/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const GlobalVector &	direction,
		double	coneRadius,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 345 of file GhostTrackVertexFinder.cc.

                                                                                                              {
   return vertices(RecoVertex::convertPos(primaryVertex.position()),
                   RecoVertex::convertError(primaryVertex.error()),
                   direction,
                   coneRadius,
                   beamSpot,
                   tracks);
 }

References pwdgSkimBPark_cfi::beamSpot, RecoVertex::convertError(), RecoVertex::convertPos(), BeamMonitor_cff::primaryVertex, tracks, and vertices().

◆ vertices() [11/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const GlobalVector &	direction,
		double	coneRadius,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 334 of file GhostTrackVertexFinder.cc.

                                                                                                              {
   return vertices(RecoVertex::convertPos(primaryVertex.position()),
                   RecoVertex::convertError(primaryVertex.error()),
                   direction,
                   coneRadius,
                   tracks);
 }

References RecoVertex::convertError(), RecoVertex::convertPos(), BeamMonitor_cff::primaryVertex, and tracks.

Referenced by initialVertices(), reassignTracks(), recursiveMerge(), refitGhostTrack(), and vertices().

◆ vertices() [12/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const reco::BeamSpot &	beamSpot,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 515 of file GhostTrackVertexFinder.cc.

                                                                                                   {
   return vertices(RecoVertex::convertPos(primaryVertex.position()),
                   RecoVertex::convertError(primaryVertex.error()),
                   beamSpot,
                   ghostTrack);
 }

References pwdgSkimBPark_cfi::beamSpot, RecoVertex::convertError(), RecoVertex::convertPos(), BeamMonitor_cff::primaryVertex, and vertices().

◆ vertices() [13/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	primaries,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 524 of file GhostTrackVertexFinder.cc.

                                                                                                   {
   return vertices(RecoVertex::convertPos(primaryVertex.position()),
                   RecoVertex::convertError(primaryVertex.error()),
                   beamSpot,
                   primaries,
                   ghostTrack);
 }

References pwdgSkimBPark_cfi::beamSpot, RecoVertex::convertError(), RecoVertex::convertPos(), BeamMonitor_cff::primaryVertex, and vertices().

◆ vertices() [14/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const reco::Track &	ghostTrack,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	primaries,
		const std::vector< TransientTrack > &	tracks,
		const std::vector< float > &	weights = `std::vector<float>()`
	)		const

Definition at line 595 of file GhostTrackVertexFinder.cc.

                                                                                                      {
   GhostTrack ghostTrack_(ghostTrack,
                          tracks,
                          weights,
                          dummyPrediction(primaryVertex, ghostTrack),
                          RecoVertex::convertPos(primaryVertex.position()),
                          true);
  
   std::vector<RefCountedVertexTrack> primaryVertexTracks;
   if (!primaries.empty()) {
     LinearizedTrackStateFactory linTrackFactory;
     VertexTrackFactory<5> vertexTrackFactory;
  
     VertexState state(RecoVertex::convertPos(primaryVertex.position()),
                       RecoVertex::convertError(primaryVertex.error()));
  
     for (std::vector<TransientTrack>::const_iterator iter = primaries.begin(); iter != primaries.end(); ++iter) {
       RefCountedLinearizedTrackState linState = linTrackFactory.linearizedTrackState(state.position(), *iter);
  
       primaryVertexTracks.push_back(vertexTrackFactory.vertexTrack(linState, state));
     }
   }
  
   CachingVertex<5> primary(RecoVertex::convertPos(primaryVertex.position()),
                            RecoVertex::convertError(primaryVertex.error()),
                            primaryVertexTracks,
                            0.);
  
   std::vector<TransientVertex> result = vertices(ghostTrack_, primary, beamSpot, true, true);
  
 #ifdef DEBUG
   for (std::vector<TransientVertex>::const_iterator iter = result.begin(); iter != result.end(); ++iter)
     debugVertex(*iter, ghostTrack_.prediction());
 #endif
  
   return result;
 }

References pwdgSkimBPark_cfi::beamSpot, RecoVertex::convertError(), RecoVertex::convertPos(), dummyPrediction(), LinearizedTrackStateFactory::linearizedTrackState(), reco::GhostTrack::prediction(), BeamMonitor_cff::primaryVertex, mps_fire::result, tracks, VertexTrackFactory< N >::vertexTrack(), vertices(), and HLT_FULL_cff::weights.

◆ vertices() [15/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const reco::Track &	ghostTrack,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	tracks,
		const std::vector< float > &	weights = `std::vector<float>()`
	)		const

Definition at line 568 of file GhostTrackVertexFinder.cc.

                                                                                                      {
   GhostTrack ghostTrack_(ghostTrack,
                          tracks,
                          weights,
                          dummyPrediction(primaryVertex, ghostTrack),
                          RecoVertex::convertPos(primaryVertex.position()),
                          true);
  
   CachingVertex<5> primary(RecoVertex::convertPos(primaryVertex.position()),
                            RecoVertex::convertError(primaryVertex.error()),
                            std::vector<RefCountedVertexTrack>(),
                            0.);
  
   std::vector<TransientVertex> result = vertices(ghostTrack_, primary, beamSpot, true);
  
 #ifdef DEBUG
   for (std::vector<TransientVertex>::const_iterator iter = result.begin(); iter != result.end(); ++iter)
     debugVertex(*iter, ghostTrack_.prediction());
 #endif
  
   return result;
 }

References pwdgSkimBPark_cfi::beamSpot, RecoVertex::convertError(), RecoVertex::convertPos(), dummyPrediction(), reco::GhostTrack::prediction(), BeamMonitor_cff::primaryVertex, mps_fire::result, tracks, vertices(), and HLT_FULL_cff::weights.

◆ vertices() [16/16]

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const reco::Track &	ghostTrack,
		const std::vector< TransientTrack > &	tracks,
		const std::vector< float > &	weights = `std::vector<float>()`
	)		const

Definition at line 542 of file GhostTrackVertexFinder.cc.

                                                                                                      {
   GhostTrack ghostTrack_(ghostTrack,
                          tracks,
                          weights,
                          dummyPrediction(primaryVertex, ghostTrack),
                          RecoVertex::convertPos(primaryVertex.position()),
                          true);
  
   CachingVertex<5> primary(RecoVertex::convertPos(primaryVertex.position()),
                            RecoVertex::convertError(primaryVertex.error()),
                            std::vector<RefCountedVertexTrack>(),
                            0.);
  
   std::vector<TransientVertex> result = vertices(ghostTrack_, primary);
  
 #ifdef DEBUG
   for (std::vector<TransientVertex>::const_iterator iter = result.begin(); iter != result.end(); ++iter)
     debugVertex(*iter, ghostTrack_.prediction());
 #endif
  
   return result;
 }

References RecoVertex::convertError(), RecoVertex::convertPos(), dummyPrediction(), reco::GhostTrack::prediction(), BeamMonitor_cff::primaryVertex, mps_fire::result, tracks, vertices(), and HLT_FULL_cff::weights.

Member Data Documentation

◆ fitType_

FitType reco::GhostTrackVertexFinder::fitType_

private

Definition at line 155 of file GhostTrackVertexFinder.h.

Referenced by mergeVertices(), reassignTracks(), and vertices().

◆ ghostTrackFitter_

std::unique_ptr<GhostTrackFitter> reco::GhostTrackVertexFinder::ghostTrackFitter_

mutableprivate

Definition at line 157 of file GhostTrackVertexFinder.h.

Referenced by ghostTrackFitter().

◆ maxFitChi2_

double reco::GhostTrackVertexFinder::maxFitChi2_

private

Definition at line 151 of file GhostTrackVertexFinder.h.

Referenced by recursiveMerge().

◆ mergeThreshold_

double reco::GhostTrackVertexFinder::mergeThreshold_

private

Definition at line 152 of file GhostTrackVertexFinder.h.

Referenced by recursiveMerge().

◆ primcut_

double reco::GhostTrackVertexFinder::primcut_

private

Definition at line 153 of file GhostTrackVertexFinder.h.

Referenced by reassignTracks(), recursiveMerge(), and vertexFitter().

◆ primVertexFitter_

std::unique_ptr<VertexFitter<5> > reco::GhostTrackVertexFinder::primVertexFitter_

mutableprivate

Definition at line 158 of file GhostTrackVertexFinder.h.

Referenced by vertexFitter().

◆ seccut_

double reco::GhostTrackVertexFinder::seccut_

private

Definition at line 154 of file GhostTrackVertexFinder.h.

Referenced by reassignTracks(), recursiveMerge(), and vertexFitter().

◆ secVertexFitter_

std::unique_ptr<VertexFitter<5> > reco::GhostTrackVertexFinder::secVertexFitter_

mutableprivate

Definition at line 159 of file GhostTrackVertexFinder.h.

Referenced by vertexFitter().

Classes

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ FitType

Constructor & Destructor Documentation

◆ GhostTrackVertexFinder() [1/2]

◆ GhostTrackVertexFinder() [2/2]

◆ ~GhostTrackVertexFinder()

Member Function Documentation

◆ ghostTrackFitter()

◆ initialVertices()

◆ mergeVertices()

◆ reassignTracks()

◆ recursiveMerge()

◆ refitGhostTrack()

◆ vertexCompat()

◆ vertexFitter()

◆ vertices() [1/16]

◆ vertices() [2/16]

◆ vertices() [3/16]

◆ vertices() [4/16]

◆ vertices() [5/16]

◆ vertices() [6/16]

◆ vertices() [7/16]

◆ vertices() [8/16]

◆ vertices() [9/16]

◆ vertices() [10/16]

◆ vertices() [11/16]

◆ vertices() [12/16]

◆ vertices() [13/16]

◆ vertices() [14/16]

◆ vertices() [15/16]

◆ vertices() [16/16]

Member Data Documentation

◆ fitType_

◆ ghostTrackFitter_

◆ maxFitChi2_

◆ mergeThreshold_

◆ primcut_

◆ primVertexFitter_

◆ seccut_

◆ secVertexFitter_