---

SequentialVertexSmoother.cc

Go to the documentation of this file.

#include "RecoVertex/VertexTools/interface/SequentialVertexSmoother.h"


template <unsigned int N>
SequentialVertexSmoother<N>::SequentialVertexSmoother(
  const VertexTrackUpdator<N> & vtu, 
  const VertexSmoothedChiSquaredEstimator<N> & vse, 
  const TrackToTrackCovCalculator<N> & covCalc) :
  theVertexTrackUpdator(vtu.clone()), 
  theVertexSmoothedChiSquaredEstimator(vse.clone()), 
  theTrackToTrackCovCalculator(covCalc.clone()) 
{}


template <unsigned int N>
SequentialVertexSmoother<N>::~SequentialVertexSmoother() 
{
  delete theVertexTrackUpdator;
  delete theVertexSmoothedChiSquaredEstimator;
  delete theTrackToTrackCovCalculator;
}


template <unsigned int N>
SequentialVertexSmoother<N>::SequentialVertexSmoother(
  const SequentialVertexSmoother & smoother) 
{
  theVertexTrackUpdator = smoother.vertexTrackUpdator()->clone();
  theVertexSmoothedChiSquaredEstimator 
    = smoother.vertexSmoothedChiSquaredEstimator()->clone();
  theTrackToTrackCovCalculator = smoother.trackToTrackCovCalculator()->clone();
}


template <unsigned int N>
CachingVertex<N>
SequentialVertexSmoother<N>::smooth(const CachingVertex<N> & vertex) const
{

  // Track refit

  vector<RefCountedVertexTrack> newTracks;
  if (theVertexTrackUpdator != 0) {
    const vector<RefCountedVertexTrack>&  vOut=vertex.tracks();
    for(typename vector<RefCountedVertexTrack>::const_iterator i = vOut.begin();
          i != vOut.end();i++)
    {
      RefCountedVertexTrack nTrack = theVertexTrackUpdator->update(vertex, *i);
      newTracks.push_back(nTrack);
    }
  } else {
    newTracks = vertex.tracks();
  }

  // intermediate vertex for chi2 calculation and TktoTkcovariance map
  CachingVertex<N> interVertex(vertex.position(), vertex.weight(),
                                newTracks, 0.);

  // Smoothed chi2

  float smChi2 = vertex.totalChiSquared();
  if (theVertexSmoothedChiSquaredEstimator != 0) {
    smChi2 = theVertexSmoothedChiSquaredEstimator->estimate(interVertex);
  }

  if (theTrackToTrackCovCalculator == 0) {
    if  (vertex.hasPrior()) {
      return CachingVertex<N>(vertex.priorVertexState(), vertex.vertexState(),
                  newTracks, smChi2);
    } else {
      return CachingVertex<N>(vertex.vertexState(), newTracks, smChi2);
    }
  }
  
  //TktoTkcovariance map
  typename CachingVertex<N>::TrackToTrackMap tkMap = (*theTrackToTrackCovCalculator)(interVertex);

//   CachingVertex<N> finalVertex(vertex.position(), vertex.error(),
//                          newTracks, smChi2, tkMap);
  if  (vertex.hasPrior()) {
    CachingVertex<N> finalVertex(vertex.priorVertexState(), vertex.vertexState(),
                newTracks, smChi2, tkMap);
    return finalVertex;
  }

  CachingVertex<N> finalVertex(vertex.vertexState(), newTracks, smChi2, tkMap);
  return finalVertex;

}

template class SequentialVertexSmoother<5>;
template class SequentialVertexSmoother<6>;

---