GhostTrackVertexFinder.cc File Reference

#include <algorithm>
#include <iterator>
#include <vector>
#include <map>
#include <set>
#include <Math/SVector.h>
#include <Math/SMatrix.h>
#include <Math/MatrixFunctions.h>
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/GlobalError.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "TrackingTools/TrajectoryParametrization/interface/GlobalTrajectoryParameters.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h"
#include "TrackingTools/GeomPropagators/interface/AnalyticalImpactPointExtrapolator.h"
#include "TrackingTools/TransientTrack/interface/TransientTrack.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackFromFTSFactory.h"
#include "RecoVertex/VertexPrimitives/interface/TransientVertex.h"
#include "RecoVertex/VertexPrimitives/interface/VertexFitter.h"
#include "RecoVertex/VertexPrimitives/interface/VertexState.h"
#include "RecoVertex/VertexPrimitives/interface/CachingVertex.h"
#include "RecoVertex/VertexPrimitives/interface/LinearizedTrackState.h"
#include "RecoVertex/VertexPrimitives/interface/ConvertError.h"
#include "RecoVertex/VertexPrimitives/interface/ConvertToFromReco.h"
#include "RecoVertex/VertexTools/interface/LinearizedTrackStateFactory.h"
#include "RecoVertex/VertexTools/interface/VertexTrackFactory.h"
#include "RecoVertex/VertexTools/interface/VertexDistance3D.h"
#include "RecoVertex/VertexTools/interface/GeometricAnnealing.h"
#include "RecoVertex/KalmanVertexFit/interface/KalmanVertexFitter.h"
#include "RecoVertex/AdaptiveVertexFit/interface/AdaptiveVertexFitter.h"
#include "RecoVertex/GhostTrackFitter/interface/GhostTrack.h"
#include "RecoVertex/GhostTrackFitter/interface/GhostTrackState.h"
#include "RecoVertex/GhostTrackFitter/interface/GhostTrackFitter.h"
#include "RecoVertex/GhostTrackFitter/interface/GhostTrackPrediction.h"
#include "RecoVertex/GhostTrackFitter/interface/SequentialGhostTrackFitter.h"
#include "RecoVertex/GhostTrackFitter/interface/KalmanGhostTrackUpdater.h"
#include "RecoVertex/GhostTrackFitter/interface/GhostTrackVertexFinder.h"

Go to the source code of this file.

Classes
struct	reco::GhostTrackVertexFinder::FinderInfo

Functions
static bool	covarianceUpdate (Matrix3S &cov, const Vector3 &residual, const Matrix3S &error, double &chi2, double theta, double phi)
static GhostTrackPrediction	dummyPrediction (const Vertex &primaryVertex, const Track &ghostTrack)
static double	fitChi2 (const CachingVertex< 5 > &vtx)
static void	mergeTrackHelper (const std::vector< RefCountedVertexTrack > &tracks, std::vector< RefCountedVertexTrack > &newTracks, const VertexState &state, const VtxTrackIs &ghostTrackFinder, RefCountedVertexTrack &ghostTrack, const VertexTrackFactory< 5 > &factory)
static RefCountedVertexTrack	relinearizeTrack (const RefCountedVertexTrack &track, const VertexState &state, const VertexTrackFactory< 5 > factory)
static std::vector< RefCountedVertexTrack >	relinearizeTracks (const std::vector< RefCountedVertexTrack > &tracks, const VertexState &state)
static VertexState	stateMean (const VertexState &v1, const VertexState &v2)
static double	trackVertexCompat (const CachingVertex< 5 > &vtx, const RefCountedVertexTrack &vertexTrack)
static TransientTrack	transientGhostTrack (const GhostTrackPrediction &pred, const MagneticField *field)
static CachingVertex< 5 >	vertexAtState (const TransientTrack &ghostTrack, const GhostTrackPrediction &pred, const GhostTrackState &state)
static double	vtxErrorLong (const GlobalError &error, const GlobalVector &dir)
static GlobalPoint	vtxMean (const GlobalPoint &p1, const GlobalError &e1, const GlobalPoint &p2, const GlobalError &e2)

Function Documentation

covarianceUpdate()

static bool covarianceUpdate ( Matrix3S &  cov, const Vector3 &  residual, const Matrix3S &  error, double &  chi2, double  theta, double  phi  )

static

Definition at line 136 of file GhostTrackVertexFinder.cc.

                                                                                                           {
  using namespace ROOT::Math;
 
  Matrix23 jacobian;
  jacobian(0, 0) = std::cos(phi) * std::cos(theta);
  jacobian(0, 1) = std::sin(phi) * std::cos(theta);
  jacobian(0, 2) = -std::sin(theta);
  jacobian(1, 0) = -std::sin(phi);
  jacobian(1, 1) = std::cos(phi);
 
  Matrix2S measErr = Similarity(jacobian, error);
  Matrix2S combErr = Similarity(jacobian, cov) + measErr;
  if (!measErr.Invert() || !combErr.Invert())
    return false;
 
  cov -= SimilarityT(jacobian * cov, combErr);
  chi2 += Similarity(jacobian * residual, measErr);
 
  return true;
}

References hltPixelTracks_cff::chi2, funct::cos(), relativeConstraints::error, funct::sin(), and theta().

Referenced by vertexAtState().

dummyPrediction()

static GhostTrackPrediction dummyPrediction ( const Vertex &  primaryVertex, const Track &  ghostTrack  )

static

Definition at line 533 of file GhostTrackVertexFinder.cc.

                                                                                                  {
  return GhostTrackPrediction(RecoVertex::convertPos(primaryVertex.position()),
                              RecoVertex::convertError(primaryVertex.error()),
                              GlobalVector(ghostTrack.px(), ghostTrack.py(), ghostTrack.pz()),
                              0.05);
}

References RecoVertex::convertError(), RecoVertex::convertPos(), BeamMonitor_cff::primaryVertex, reco::TrackBase::px(), reco::TrackBase::py(), and reco::TrackBase::pz().

Referenced by reco::GhostTrackVertexFinder::vertices().

fitChi2()

static double fitChi2 ( const CachingVertex< 5 > &  vtx )

static

Definition at line 636 of file GhostTrackVertexFinder.cc.

{ return vtx.totalChiSquared() / vtx.degreesOfFreedom(); }

References badGlobalMuonTaggersAOD_cff::vtx.

Referenced by PFGsfHelper::PFGsfHelper(), TtEvtBuilder< C >::produce(), and reco::GhostTrackVertexFinder::recursiveMerge().

mergeTrackHelper()

static void mergeTrackHelper ( const std::vector< RefCountedVertexTrack > &  tracks, std::vector< RefCountedVertexTrack > &  newTracks, const VertexState &  state, const VtxTrackIs &  ghostTrackFinder, RefCountedVertexTrack &  ghostTrack, const VertexTrackFactory< 5 > &  factory  )

static

Definition at line 659 of file GhostTrackVertexFinder.cc.

                                                                   {
  for (std::vector<RefCountedVertexTrack>::const_iterator iter = tracks.begin(); iter != tracks.end(); ++iter) {
    bool gt = ghostTrackFinder(*iter);
    if (gt && ghostTrack)
      continue;
 
    RefCountedVertexTrack track = relinearizeTrack(*iter, state, factory);
 
    if (gt)
      ghostTrack = *iter;
    else
      newTracks.push_back(*iter);
  }
}

References relinearizeTrack(), HLT_2018_cff::track, and PDWG_EXOHSCP_cff::tracks.

Referenced by reco::GhostTrackVertexFinder::mergeVertices().

relinearizeTrack()

static RefCountedVertexTrack relinearizeTrack ( const RefCountedVertexTrack &  track, const VertexState &  state, const VertexTrackFactory< 5 >  factory  )

static

Definition at line 209 of file GhostTrackVertexFinder.cc.

                                                                                   {
  RefCountedLinearizedTrackState linTrack = track->linearizedTrack();
  linTrack = linTrack->stateWithNewLinearizationPoint(state.position());
  return factory.vertexTrack(linTrack, state);
}

References VertexState::position(), HLT_2018_cff::track, and VertexTrackFactory< N >::vertexTrack().

Referenced by mergeTrackHelper(), reco::GhostTrackVertexFinder::reassignTracks(), and relinearizeTracks().

relinearizeTracks()

static std::vector<RefCountedVertexTrack> relinearizeTracks ( const std::vector< RefCountedVertexTrack > &  tracks, const VertexState &  state  )

static

Definition at line 217 of file GhostTrackVertexFinder.cc.

                                                                                      {
  VertexTrackFactory<5> vertexTrackFactory;
 
  std::vector<RefCountedVertexTrack> finalTracks;
  finalTracks.reserve(tracks.size());
 
  for (std::vector<RefCountedVertexTrack>::const_iterator iter = tracks.begin(); iter != tracks.end(); ++iter)
    finalTracks.push_back(relinearizeTrack(*iter, state, vertexTrackFactory));
 
  return finalTracks;
}

References relinearizeTrack(), and PDWG_EXOHSCP_cff::tracks.

Referenced by reco::GhostTrackVertexFinder::reassignTracks().

stateMean()

static VertexState stateMean ( const VertexState &  v1, const VertexState &  v2  )

static

Definition at line 132 of file GhostTrackVertexFinder.cc.

                                                                           {
  return VertexState(vtxMean(v1.position(), v1.error(), v2.position(), v2.error()), v1.error() + v2.error());
}

References VertexState::error(), VertexState::position(), and vtxMean().

Referenced by reco::GhostTrackVertexFinder::mergeVertices().

trackVertexCompat()

static double trackVertexCompat ( const CachingVertex< 5 > &  vtx, const RefCountedVertexTrack &  vertexTrack  )

static

Definition at line 238 of file GhostTrackVertexFinder.cc.

                                                                                                       {
  using namespace ROOT::Math;
 
  TransientTrack track = vertexTrack->linearizedTrack()->track();
  GlobalPoint point = vtx.position();
  AnalyticalImpactPointExtrapolator extrap(track.field());
  TrajectoryStateOnSurface tsos = extrap.extrapolate(track.impactPointState(), point);
 
  if (!tsos.isValid())
    return 1.0e6;
 
  GlobalPoint point1 = vtx.position();
  GlobalPoint point2 = tsos.globalPosition();
  Vector3 dir = conv(point2 - point1);
  Matrix3S error = vtx.error().matrix() + tsos.cartesianError().matrix().Sub<Matrix3S>(0, 0);
  if (!error.Invert())
    return 1.0e6;
 
  return ROOT::Math::Similarity(error, dir);
}

References conv, DeadROC_duringRun::dir, relativeConstraints::error, point, HLT_2018_cff::track, and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by reco::GhostTrackVertexFinder::reassignTracks().

transientGhostTrack()

static TransientTrack transientGhostTrack ( const GhostTrackPrediction &  pred, const MagneticField *  field  )

static

Definition at line 113 of file GhostTrackVertexFinder.cc.

                                                                                                        {
  return TransientTrackFromFTSFactory().build(pred.fts(field));
}

References TransientTrackFromFTSFactory::build(), and reco::GhostTrackPrediction::fts().

Referenced by reco::GhostTrackVertexFinder::refitGhostTrack(), and reco::GhostTrackVertexFinder::vertices().

vertexAtState()

static CachingVertex<5> vertexAtState ( const TransientTrack &  ghostTrack, const GhostTrackPrediction &  pred, const GhostTrackState &  state  )

static

Definition at line 158 of file GhostTrackVertexFinder.cc.

                                                                    {
  LinearizedTrackStateFactory linTrackFactory;
  VertexTrackFactory<5> vertexTrackFactory;
 
  if (!state.isValid())
    return CachingVertex<5>();
 
  GlobalPoint pca1 = pred.position(state.lambda());
  GlobalError err1 = pred.positionError(state.lambda());
 
  GlobalPoint pca2 = state.globalPosition();
  GlobalError err2 = state.cartesianError();
 
  GlobalPoint point = vtxMean(pca1, err1, pca2, err2);
 
  const TransientTrack &recTrack = state.track();
 
  RefCountedLinearizedTrackState linState[2] = {linTrackFactory.linearizedTrackState(point, ghostTrack),
                                                linTrackFactory.linearizedTrackState(point, recTrack)};
  if (!linState[0]->isValid() || !linState[1]->isValid())
    return CachingVertex<5>();
 
  Matrix3S cov = SMatrixIdentity();
  cov *= 10000;
  double chi2 = 0.;
  if (!covarianceUpdate(cov,
                        conv(pca1 - point),
                        err1.matrix(),
                        chi2,
                        linState[0]->predictedStateParameters()[1],
                        linState[0]->predictedStateParameters()[2]) ||
      !covarianceUpdate(cov,
                        conv(pca2 - point),
                        err2.matrix(),
                        chi2,
                        linState[1]->predictedStateParameters()[1],
                        linState[1]->predictedStateParameters()[2]))
    return CachingVertex<5>();
 
  GlobalError error(cov);
  VertexState vtxState(point, error);
 
  std::vector<RefCountedVertexTrack> linTracks(2);
  linTracks[0] = vertexTrackFactory.vertexTrack(linState[0], vtxState);
  linTracks[1] = vertexTrackFactory.vertexTrack(linState[1], vtxState);
 
  return CachingVertex<5>(point, error, linTracks, chi2);
}

References reco::GhostTrackState::cartesianError(), hltPixelTracks_cff::chi2, conv, covarianceUpdate(), relativeConstraints::error, reco::GhostTrackState::globalPosition(), reco::GhostTrackState::isValid(), reco::GhostTrackState::lambda(), LinearizedTrackStateFactory::linearizedTrackState(), GlobalErrorBase< T, ErrorWeightType >::matrix(), point, reco::GhostTrackPrediction::position(), reco::GhostTrackPrediction::positionError(), reco::GhostTrackState::track(), VertexTrackFactory< N >::vertexTrack(), and vtxMean().

Referenced by reco::GhostTrackVertexFinder::initialVertices(), reco::GhostTrackVertexFinder::reassignTracks(), and reco::GhostTrackVertexFinder::refitGhostTrack().

vtxErrorLong()

static double vtxErrorLong ( const GlobalError &  error, const GlobalVector &  dir  )

static

Definition at line 117 of file GhostTrackVertexFinder.cc.

                                                                              {
  return ROOT::Math::Similarity(conv(dir), error.matrix());
}

References conv, DeadROC_duringRun::dir, and relativeConstraints::error.

Referenced by vtxMean().

vtxMean()

static GlobalPoint vtxMean ( const GlobalPoint &  p1, const GlobalError &  e1, const GlobalPoint &  p2, const GlobalError &  e2  )

static

Definition at line 121 of file GhostTrackVertexFinder.cc.

                                                                                                                       {
  GlobalVector diff = p2 - p1;
 
  double err1 = vtxErrorLong(e1, diff);
  double err2 = vtxErrorLong(e2, diff);
 
  double weight = err1 / (err1 + err2);
 
  return p1 + weight * diff;
}

References change_name::diff, StorageManager_cfg::e1, p1, p2, and vtxErrorLong().

Referenced by GlobalTrackingRegion::checkRZ(), RectangularEtaPhiTrackingRegion::checkRZOld(), stateMean(), and vertexAtState().