reco::GhostTrackVertexFinder Class Reference

#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 reco::Vertex &primaryVertex, const GlobalVector &direction, double coneRadius, 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 reco::Vertex &primaryVertex, 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 reco::BeamSpot &beamSpot, 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 > &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 > &primaries, const std::vector< TransientTrack > &tracks) 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
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 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 GlobalPoint &primaryPosition, const GlobalError &primaryError, const GhostTrack &ghostTrack) 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 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 GhostTrack &ghostTrack, const CachingVertex< 5 > &primary=CachingVertex< 5 >(), const reco::BeamSpot &beamSpot=reco::BeamSpot(), bool hasBeamSpot=false, bool hasPrimaries=false) 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.

{ kAlwaysWithGhostTrack, kSingleTracksWithGhostTrack, kRefitGhostTrackWithVertices };

Constructor & Destructor Documentation

GhostTrackVertexFinder() [1/2]

GhostTrackVertexFinder::GhostTrackVertexFinder

(

)

Definition at line 268 of file GhostTrackVertexFinder.cc.

    : 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 271 of file GhostTrackVertexFinder.cc.

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

~GhostTrackVertexFinder()

GhostTrackVertexFinder::~GhostTrackVertexFinder

(

)

Definition at line 275 of file GhostTrackVertexFinder.cc.

{}

Member Function Documentation

ghostTrackFitter()

GhostTrackFitter & GhostTrackVertexFinder::ghostTrackFitter ( ) const

private

Definition at line 277 of file GhostTrackVertexFinder.cc.

References ghostTrackFitter_.

Referenced by vertices().

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

  return *ghostTrackFitter_;
}

initialVertices()

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

private

Definition at line 647 of file GhostTrackVertexFinder.cc.

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

Referenced by vertices().

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

mergeVertices()

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

private

Definition at line 688 of file GhostTrackVertexFinder.cc.

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

                                                                             {
  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>();
}

reassignTracks()

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

private

Definition at line 792 of file GhostTrackVertexFinder.cc.

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

Referenced by vertices().

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

recursiveMerge()

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

private

Definition at line 720 of file GhostTrackVertexFinder.cc.

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

Referenced by vertices().

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

refitGhostTrack()

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

private

Definition at line 902 of file GhostTrackVertexFinder.cc.

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

Referenced by vertices().

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

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 239 of file GhostTrackVertexFinder.cc.

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

Referenced by recursiveMerge().

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

vertexFitter()

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

private

Definition at line 284 of file GhostTrackVertexFinder.cc.

References primcut_, primVertexFitter_, seccut_, and secVertexFitter_.

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

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

  return **ptr;
}

vertices() [1/16]

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

Definition at line 341 of file GhostTrackVertexFinder.cc.

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

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

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

vertices() [2/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 380 of file GhostTrackVertexFinder.cc.

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

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

vertices() [3/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 352 of file GhostTrackVertexFinder.cc.

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

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

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 399 of file GhostTrackVertexFinder.cc.

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

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

vertices() [5/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 365 of file GhostTrackVertexFinder.cc.

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

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

vertices() [6/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 419 of file GhostTrackVertexFinder.cc.

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

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

vertices() [7/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 549 of file GhostTrackVertexFinder.cc.

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

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

vertices() [8/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 575 of file GhostTrackVertexFinder.cc.

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

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

vertices() [9/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 602 of file GhostTrackVertexFinder.cc.

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 hltDeepSecondaryVertexTagInfosPFPuppi_cfi::weights.

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

vertices() [10/16]

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

Definition at line 454 of file GhostTrackVertexFinder.cc.

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

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

vertices() [11/16]

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

Definition at line 469 of file GhostTrackVertexFinder.cc.

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

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

vertices() [12/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 485 of file GhostTrackVertexFinder.cc.

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

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

vertices() [13/16]

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

Definition at line 516 of file GhostTrackVertexFinder.cc.

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

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

vertices() [14/16]

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

Definition at line 522 of file GhostTrackVertexFinder.cc.

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

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

vertices() [15/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 531 of file GhostTrackVertexFinder.cc.

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

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

vertices() [16/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 1005 of file GhostTrackVertexFinder.cc.

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.

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

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