#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.

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

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

Referenced by clone().

◆ ~GsfVertexSmoother()

GsfVertexSmoother::~GsfVertexSmoother ( )

inlineoverride

Definition at line 31 of file GsfVertexSmoother.h.

31 {}

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.

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

References generateEDF::totalWeight.

Referenced by vertexAndTrackUpdate().

◆ clone()

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

inlineoverridevirtual

Clone method

Implements VertexSmoother< 5 >.

Definition at line 51 of file GsfVertexSmoother.h.

51 { return new GsfVertexSmoother(*this); }

References GsfVertexSmoother().

◆ 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.

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

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

Referenced by vertexAndTrackUpdate().

◆ meanVertex()

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

private

Definition at line 185 of file GsfVertexSmoother.cc.

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

References VertexState::components().

Referenced by smooth().

◆ 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.

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

References VertexState::components().

Referenced by smooth().

◆ 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.

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

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

◆ vertexAndTrackUpdate()

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

private

Definition at line 91 of file GsfVertexSmoother.cc.

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

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

Referenced by smooth().

◆ vertexUpdator()

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

inline

Access methods

Definition at line 46 of file GsfVertexSmoother.h.

46 { return &theUpdator; }

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ AlgebraicMatrix3M

◆ AlgebraicSymMatrixOO

◆ LTC

◆ RefCountedLinearizedTrackState

◆ RefCountedRefittedTrackState

◆ RefCountedVertexTrack

◆ RefittedTrackComponent

◆ TrackChi2Pair

◆ TrackWeightPair

◆ VSC

◆ VtxTrkChi2Pair

Constructor & Destructor Documentation

◆ GsfVertexSmoother()

◆ ~GsfVertexSmoother()

Member Function Documentation

◆ assembleTrackComponents()

◆ clone()

◆ createNewComponent()

◆ meanVertex()

◆ priorVertexChi2()

◆ smooth()

◆ vertexAndTrackUpdate()

◆ vertexUpdator()

Member Data Documentation

◆ helper

◆ kalmanVertexUpdator

◆ limitComponents

◆ smoothedChi2Estimator

◆ theMerger

◆ theUpdator

◆ theVertexTrackUpdator

◆ theVTFactory

◆ theWeightCalculator