GsfVertexSmoother Class Reference

#include <GsfVertexSmoother.h>

Inheritance diagram for GsfVertexSmoother:

Public Member Functions
VertexSmoother< 5 > *	clone () const override
	GsfVertexSmoother (bool limit, const GsfVertexMerger *merger)
CachingVertex< 5 >	smooth (const CachingVertex< 5 > &vertex) const override
const VertexUpdator< 5 > *	vertexUpdator () const
	~GsfVertexSmoother () override
Public Member Functions inherited from VertexSmoother< 5 >
virtual CachingVertex< N >	smooth (const CachingVertex< N > &vertex) const=0
	VertexSmoother ()
virtual	~VertexSmoother ()

Private Types
typedef VertexTrack< 5 >::AlgebraicMatrix3M	AlgebraicMatrix3M
typedef VertexTrack< 5 >::AlgebraicSymMatrixOO	AlgebraicSymMatrixOO
typedef std::vector< RefCountedLinearizedTrackState >	LTC
typedef VertexTrack< 5 >::RefCountedLinearizedTrackState	RefCountedLinearizedTrackState
typedef VertexTrack< 5 >::RefCountedRefittedTrackState	RefCountedRefittedTrackState
typedef CachingVertex< 5 >::RefCountedVertexTrack	RefCountedVertexTrack
typedef std::pair< TrackWeightPair, VtxTrkChi2Pair >	RefittedTrackComponent
typedef std::pair< RefCountedRefittedTrackState, VtxTrkChi2Pair >	TrackChi2Pair
typedef std::pair< RefCountedRefittedTrackState, double >	TrackWeightPair
typedef std::vector< VertexState >	VSC
typedef std::pair< double, double >	VtxTrkChi2Pair

Private Member Functions
TrackChi2Pair	assembleTrackComponents (const std::vector< RefittedTrackComponent > &trackComponents, const GlobalPoint &referencePosition) const
RefittedTrackComponent	createNewComponent (const VertexState &oldVertex, const RefCountedLinearizedTrackState linTrack, float weight) const
VertexState	meanVertex (const VertexState &vertexA, const VertexState &vertexB) const
double	priorVertexChi2 (const VertexState priorVertex, const VertexState fittedVertex) const
TrackChi2Pair	vertexAndTrackUpdate (const VertexState &oldVertex, const RefCountedVertexTrack track, const GlobalPoint &referencePosition) const

Private Attributes
KVFHelper< 5 >	helper
KalmanVertexUpdator< 5 >	kalmanVertexUpdator
bool	limitComponents
KalmanSmoothedVertexChi2Estimator< 5 >	smoothedChi2Estimator
DeepCopyPointerByClone< GsfVertexMerger >	theMerger
GsfVertexUpdator	theUpdator
KalmanVertexTrackUpdator< 5 >	theVertexTrackUpdator
VertexTrackFactory< 5 >	theVTFactory
GsfVertexWeightCalculator	theWeightCalculator

Detailed Description

The class which handles the track-refit and smoothed chi**2 calculations for the Gaussian Sum vertex fit. The track-to-track covariance matrix calculation is not yet done.

Definition at line 21 of file GsfVertexSmoother.h.

Member Typedef Documentation

AlgebraicMatrix3M

typedef VertexTrack<5>::AlgebraicMatrix3M GsfVertexSmoother::AlgebraicMatrix3M

private

Definition at line 57 of file GsfVertexSmoother.h.

AlgebraicSymMatrixOO

typedef VertexTrack<5>::AlgebraicSymMatrixOO GsfVertexSmoother::AlgebraicSymMatrixOO

private

Definition at line 58 of file GsfVertexSmoother.h.

LTC

typedef std::vector<RefCountedLinearizedTrackState> GsfVertexSmoother::LTC

private

Definition at line 61 of file GsfVertexSmoother.h.

RefCountedLinearizedTrackState

typedef VertexTrack<5>::RefCountedLinearizedTrackState GsfVertexSmoother::RefCountedLinearizedTrackState

private

Definition at line 55 of file GsfVertexSmoother.h.

RefCountedRefittedTrackState

typedef VertexTrack<5>::RefCountedRefittedTrackState GsfVertexSmoother::RefCountedRefittedTrackState

private

Definition at line 56 of file GsfVertexSmoother.h.

RefCountedVertexTrack

typedef CachingVertex<5>::RefCountedVertexTrack GsfVertexSmoother::RefCountedVertexTrack

private

Definition at line 54 of file GsfVertexSmoother.h.

RefittedTrackComponent

typedef std::pair<TrackWeightPair, VtxTrkChi2Pair> GsfVertexSmoother::RefittedTrackComponent

private

Definition at line 65 of file GsfVertexSmoother.h.

TrackChi2Pair

typedef std::pair<RefCountedRefittedTrackState, VtxTrkChi2Pair> GsfVertexSmoother::TrackChi2Pair

private

Definition at line 64 of file GsfVertexSmoother.h.

TrackWeightPair

typedef std::pair<RefCountedRefittedTrackState, double> GsfVertexSmoother::TrackWeightPair

private

Definition at line 63 of file GsfVertexSmoother.h.

VSC

typedef std::vector<VertexState> GsfVertexSmoother::VSC

private

Definition at line 60 of file GsfVertexSmoother.h.

VtxTrkChi2Pair

typedef std::pair<double, double> GsfVertexSmoother::VtxTrkChi2Pair

private

Definition at line 62 of file GsfVertexSmoother.h.

Constructor & Destructor Documentation

GsfVertexSmoother()

GsfVertexSmoother::GsfVertexSmoother	(	bool	limit,
		const GsfVertexMerger *	merger
	)

The constructor

Parameters

limit

Specifies whether the number of components of the vertex should be limited

Definition at line 6 of file GsfVertexSmoother.cc.

References GsfVertexMerger::clone(), limitComponents, and theMerger.

Referenced by clone().

                                                                              : limitComponents(limit) {
  if (limitComponents)
    theMerger = merger->clone();
}

~GsfVertexSmoother()

GsfVertexSmoother::~GsfVertexSmoother ( )

inlineoverride

Definition at line 31 of file GsfVertexSmoother.h.

{}

Member Function Documentation

assembleTrackComponents()

GsfVertexSmoother::TrackChi2Pair GsfVertexSmoother::assembleTrackComponents ( const std::vector< RefittedTrackComponent > &  trackComponents, const GlobalPoint &  referencePosition  ) const

private

This method assembles all the components of the refitted track into one refitted track state, normalizing the components. Also, it adds the chi2 track-components increments.

Definition at line 124 of file GsfVertexSmoother.cc.

References generateEDF::totalWeight.

Referenced by vertexAndTrackUpdate().

                                                {
  //renormalize weights

  double totalWeight = 0.;
  double totalVtxChi2 = 0., totalTrkChi2 = 0.;

  for (std::vector<RefittedTrackComponent>::const_iterator iter = trackComponents.begin();
       iter != trackComponents.end();
       ++iter) {
    totalWeight += iter->first.second;
    totalVtxChi2 += iter->second.first * iter->first.second;
    totalTrkChi2 += iter->second.second * iter->first.second;
  }

  totalVtxChi2 /= totalWeight;
  totalTrkChi2 /= totalWeight;

  std::vector<RefCountedRefittedTrackState> reWeightedRTSC;
  reWeightedRTSC.reserve(trackComponents.size());

  for (std::vector<RefittedTrackComponent>::const_iterator iter = trackComponents.begin();
       iter != trackComponents.end();
       ++iter) {
    if (iter->second.first != 0) {
      reWeightedRTSC.push_back(iter->first.first->stateWithNewWeight(iter->second.first / totalWeight));
    }
  }

  RefCountedRefittedTrackState finalRTS =
      RefCountedRefittedTrackState(new MultiRefittedTS(reWeightedRTSC, referencePosition));
  return TrackChi2Pair(finalRTS, VtxTrkChi2Pair(totalVtxChi2, totalTrkChi2));
}

clone()

VertexSmoother<5>* GsfVertexSmoother::clone ( void  ) const

inlineoverridevirtual

Clone method

Implements VertexSmoother< 5 >.

Definition at line 51 of file GsfVertexSmoother.h.

References GsfVertexSmoother().

{ return new GsfVertexSmoother(*this); }

createNewComponent()

GsfVertexSmoother::RefittedTrackComponent GsfVertexSmoother::createNewComponent ( const VertexState &  oldVertex, const RefCountedLinearizedTrackState  linTrack, float  trackWeight  ) const

private

This method does the smoothing of one track component with one vertex component. And the track-component-chi2 increment and weight of new component in mixture.

Definition at line 164 of file GsfVertexSmoother.cc.

References GsfVertexWeightCalculator::calculate(), kalmanVertexUpdator, KalmanVertexUpdator< N >::positionUpdate(), Validation_hcalonly_cfi::sign, theVertexTrackUpdator, theWeightCalculator, KalmanVertexTrackUpdator< N >::trackRefit(), trackWeight(), and allConversions_cfi::vtxChi2.

Referenced by vertexAndTrackUpdate().

                                                                                                          {
  int sign = +1;

  // Weight of the component in the mixture (non-normalized)
  double weightInMixture = theWeightCalculator.calculate(oldVertex, linTrack, 1000000000.);

  // position estimate of the component
  VertexState newVertex = kalmanVertexUpdator.positionUpdate(oldVertex, linTrack, trackWeight, sign);

  KalmanVertexTrackUpdator<5>::trackMatrixPair thePair =
      theVertexTrackUpdator.trackRefit(newVertex, linTrack, trackWeight);

  //Chi**2 contribution of the track component
  double vtxChi2 = helper.vertexChi2(oldVertex, newVertex);
  std::pair<bool, double> trkCi2 = helper.trackParameterChi2(linTrack, thePair.first);

  return RefittedTrackComponent(TrackWeightPair(thePair.first, weightInMixture),
                                VtxTrkChi2Pair(vtxChi2, trkCi2.second));
}

meanVertex()

VertexState GsfVertexSmoother::meanVertex ( const VertexState &  vertexA, const VertexState &  vertexB  ) const

private

Definition at line 185 of file GsfVertexSmoother.cc.

References VertexState::components().

Referenced by smooth().

                                                                                                      {
  std::vector<VertexState> vsCompA = vertexA.components();
  std::vector<VertexState> vsCompB = vertexB.components();
  std::vector<VertexState> finalVS;
  finalVS.reserve(vsCompA.size() * vsCompB.size());
  for (std::vector<VertexState>::iterator iA = vsCompA.begin(); iA != vsCompA.end(); ++iA) {
    for (std::vector<VertexState>::iterator iB = vsCompB.begin(); iB != vsCompB.end(); ++iB) {
      AlgebraicSymMatrix33 newWeight = iA->weight().matrix() + iB->weight().matrix();
      AlgebraicVector3 newWtP = iA->weightTimesPosition() + iB->weightTimesPosition();
      double newWeightInMixture = iA->weightInMixture() * iB->weightInMixture();
      finalVS.push_back(VertexState(newWtP, newWeight, newWeightInMixture));
    }
  }
#ifndef CMS_NO_COMPLEX_RETURNS
  return VertexState(new BasicMultiVertexState(finalVS));
#else
  VertexState theFinalVM(new BasicMultiVertexState(finalVS));
  return theFinalVM;
#endif
}

priorVertexChi2()

double GsfVertexSmoother::priorVertexChi2 ( const VertexState  priorVertex, const VertexState  fittedVertex  ) const

private

Methode which calculates the chi**2 between the prior and the fitted vertex. This method takes into account multiple states.

Parameters

priorVertex	The prior vertex state
fittedVertex	The fitted vertex state

Definition at line 206 of file GsfVertexSmoother.cc.

References VertexState::components().

Referenced by smooth().

                                                                                                             {
  std::vector<VertexState> priorVertexComp = priorVertex.components();
  std::vector<VertexState> fittedVertexComp = fittedVertex.components();
  double vetexChi2 = 0.;
  for (std::vector<VertexState>::iterator pvI = priorVertexComp.begin(); pvI != priorVertexComp.end(); ++pvI) {
    for (std::vector<VertexState>::iterator fvI = fittedVertexComp.begin(); fvI != fittedVertexComp.end(); ++fvI) {
      vetexChi2 += (pvI->weightInMixture()) * (fvI->weightInMixture()) * helper.vertexChi2(*pvI, *fvI);
    }
  }
  return vetexChi2;
}

smooth()

CachingVertex< 5 > GsfVertexSmoother::smooth ( const CachingVertex< 5 > &  vertex ) const

override

Methode which will refit the tracks with the vertex constraint and calculate the smoothed vertex chi**2

Parameters

vertex

is the final estimate of the vertex, as given by the last update.

Returns

the final vertex estimate, with all the supplementary information

Definition at line 11 of file GsfVertexSmoother.cc.

References GsfVertexUpdator::add(), mps_fire::i, limitComponents, meanVertex(), GsfVertexMerger::merge(), priorVertexChi2(), theMerger, theUpdator, theVTFactory, tracks, bphysicsOniaDQM_cfi::vertex, vertexAndTrackUpdate(), and VertexTrackFactory< N >::vertexTrack().

                                                                               {
  std::vector<RefCountedVertexTrack> tracks = vertex.tracks();
  int numberOfTracks = tracks.size();
  if (numberOfTracks < 1)
    return vertex;

  // Initial vertex for ascending fit
  GlobalPoint priorVertexPosition = tracks[0]->linearizedTrack()->linearizationPoint();
  AlgebraicSymMatrix33 we = ROOT::Math::SMatrixIdentity();
  GlobalError priorVertexError(we * 10000);

  std::vector<RefCountedVertexTrack> initialTracks;
  CachingVertex<5> fitVertex(priorVertexPosition, priorVertexError, initialTracks, 0);
  //In case prior vertex was used.
  if (vertex.hasPrior()) {
    const VertexState& priorVertexState = vertex.priorVertexState();
    fitVertex = CachingVertex<5>(priorVertexState, priorVertexState, initialTracks, 0);
  }

  // vertices from ascending fit
  std::vector<CachingVertex<5> > ascendingFittedVertices;
  ascendingFittedVertices.reserve(numberOfTracks);
  ascendingFittedVertices.push_back(fitVertex);

  // ascending fit
  for (std::vector<RefCountedVertexTrack>::const_iterator i = tracks.begin(); i != (tracks.end() - 1); ++i) {
    fitVertex = theUpdator.add(fitVertex, *i);
    if (limitComponents)
      fitVertex = theMerger->merge(fitVertex);
    ascendingFittedVertices.push_back(fitVertex);
  }

  // Initial vertex for descending fit
  priorVertexPosition = tracks[0]->linearizedTrack()->linearizationPoint();
  priorVertexError = GlobalError(we * 10000);
  fitVertex = CachingVertex<5>(priorVertexPosition, priorVertexError, initialTracks, 0);

  // vertices from descending fit
  std::vector<CachingVertex<5> > descendingFittedVertices;
  descendingFittedVertices.reserve(numberOfTracks);
  descendingFittedVertices.push_back(fitVertex);

  // descending fit
  for (std::vector<RefCountedVertexTrack>::const_iterator i = (tracks.end() - 1); i != (tracks.begin()); --i) {
    fitVertex = theUpdator.add(fitVertex, *i);
    if (limitComponents)
      fitVertex = theMerger->merge(fitVertex);
    descendingFittedVertices.insert(descendingFittedVertices.begin(), fitVertex);
  }

  std::vector<RefCountedVertexTrack> newTracks;
  double smoothedChi2 = 0.;  // Smoothed chi2

  // Track refit
  for (std::vector<RefCountedVertexTrack>::const_iterator i = tracks.begin(); i != tracks.end(); i++) {
    int indexNumber = i - tracks.begin();
    //First, combine the vertices:
    VertexState meanedVertex = meanVertex(ascendingFittedVertices[indexNumber].vertexState(),
                                          descendingFittedVertices[indexNumber].vertexState());
    if (limitComponents)
      meanedVertex = theMerger->merge(meanedVertex);
    // Add the vertex and smooth the track:
    TrackChi2Pair thePair = vertexAndTrackUpdate(meanedVertex, *i, vertex.position());
    smoothedChi2 += thePair.second.second;
    newTracks.push_back(theVTFactory.vertexTrack((**i).linearizedTrack(),
                                                 vertex.vertexState(),
                                                 thePair.first,
                                                 thePair.second.second,
                                                 AlgebraicSymMatrixOO(),
                                                 (**i).weight()));
  }

  if (vertex.hasPrior()) {
    smoothedChi2 += priorVertexChi2(vertex.priorVertexState(), vertex.vertexState());
    return CachingVertex<5>(vertex.priorVertexState(), vertex.vertexState(), newTracks, smoothedChi2);
  } else {
    return CachingVertex<5>(vertex.vertexState(), newTracks, smoothedChi2);
  }
}

vertexAndTrackUpdate()

GsfVertexSmoother::TrackChi2Pair GsfVertexSmoother::vertexAndTrackUpdate ( const VertexState &  oldVertex, const RefCountedVertexTrack  track, const GlobalPoint &  referencePosition  ) const

private

Definition at line 91 of file GsfVertexSmoother.cc.

References assembleTrackComponents(), VertexState::components(), createNewComponent(), HLT_2022v11_cff::track, and trackWeight().

Referenced by smooth().

                                                                                                                     {
  VSC prevVtxComponents = oldVertex.components();

  if (prevVtxComponents.empty()) {
    throw VertexException("GsfVertexSmoother::(Previous) Vertex to update has no components");
  }

  LTC ltComponents = track->linearizedTrack()->components();
  if (ltComponents.empty()) {
    throw VertexException("GsfVertexSmoother::Track to add to vertex has no components");
  }
  float trackWeight = track->weight();

  std::vector<RefittedTrackComponent> newTrackComponents;
  newTrackComponents.reserve(prevVtxComponents.size() * ltComponents.size());

  for (VSC::iterator vertexCompIter = prevVtxComponents.begin(); vertexCompIter != prevVtxComponents.end();
       vertexCompIter++) {
    for (LTC::iterator trackCompIter = ltComponents.begin(); trackCompIter != ltComponents.end(); trackCompIter++) {
      newTrackComponents.push_back(createNewComponent(*vertexCompIter, *trackCompIter, trackWeight));
    }
  }

  return assembleTrackComponents(newTrackComponents, referencePosition);
}

vertexUpdator()

const VertexUpdator<5>* GsfVertexSmoother::vertexUpdator ( ) const

inline

Access methods

Definition at line 46 of file GsfVertexSmoother.h.

References theUpdator.

{ return &theUpdator; }

Member Data Documentation

helper

KVFHelper<5> GsfVertexSmoother::helper

private

Definition at line 97 of file GsfVertexSmoother.h.

kalmanVertexUpdator

KalmanVertexUpdator<5> GsfVertexSmoother::kalmanVertexUpdator

private

Definition at line 92 of file GsfVertexSmoother.h.

Referenced by createNewComponent().

limitComponents

bool GsfVertexSmoother::limitComponents

private

Definition at line 89 of file GsfVertexSmoother.h.

Referenced by GsfVertexSmoother(), and smooth().

smoothedChi2Estimator

KalmanSmoothedVertexChi2Estimator<5> GsfVertexSmoother::smoothedChi2Estimator

private

Definition at line 93 of file GsfVertexSmoother.h.

theMerger

DeepCopyPointerByClone<GsfVertexMerger> GsfVertexSmoother::theMerger

private

Definition at line 90 of file GsfVertexSmoother.h.

Referenced by GsfVertexSmoother(), and smooth().

theUpdator

GsfVertexUpdator GsfVertexSmoother::theUpdator

private

Definition at line 91 of file GsfVertexSmoother.h.

Referenced by smooth(), and vertexUpdator().

theVertexTrackUpdator

KalmanVertexTrackUpdator<5> GsfVertexSmoother::theVertexTrackUpdator

private

Definition at line 94 of file GsfVertexSmoother.h.

Referenced by createNewComponent().

theVTFactory

VertexTrackFactory<5> GsfVertexSmoother::theVTFactory

private

Definition at line 96 of file GsfVertexSmoother.h.

Referenced by smooth().

theWeightCalculator

GsfVertexWeightCalculator GsfVertexSmoother::theWeightCalculator

private

Definition at line 95 of file GsfVertexSmoother.h.

Referenced by createNewComponent().