Trk::AdaptiveVertexFitter Class Reference

#include <AdaptiveVertexFitter.h>

Inheritance diagram for Trk::AdaptiveVertexFitter:

Collaboration diagram for Trk::AdaptiveVertexFitter:

Public Member Functions
virtual StatusCode	initialize () override
	AdaptiveVertexFitter (const std::string &t, const std::string &n, const IInterface *p)
	default constructor due to Athena interface
virtual	~AdaptiveVertexFitter ()
	destructor
virtual xAOD::Vertex *	fit (const std::vector< const xAOD::TrackParticle * > &vectorTrk, const std::vector< const xAOD::NeutralParticle * > &vectorNeut, const Amg::Vector3D &startingPoint) const override
	Interface for xAOD::TrackParticle with starting point.
virtual xAOD::Vertex *	fit (const std::vector< const xAOD::TrackParticle * > &vectorTrk, const Amg::Vector3D &startingPoint) const override
virtual xAOD::Vertex *	fit (const std::vector< const xAOD::TrackParticle * > &vectorTrk, const std::vector< const xAOD::NeutralParticle * > &vectorNeut, const xAOD::Vertex &constraint) const override
	Interface for xAOD::TrackParticle with vertex constraint the position of the constraint is ALWAYS the starting point.
virtual xAOD::Vertex *	fit (const std::vector< const xAOD::TrackParticle * > &vectorTrk, const xAOD::Vertex &constraint) const override
virtual xAOD::Vertex *	fit (const std::vector< const Trk::TrackParameters * > &perigeeList, const std::vector< const Trk::NeutralParameters * > &neutralPerigeeList, const Amg::Vector3D &startingPoint) const override
	Interface for MeasuredPerigee with starting point.
virtual xAOD::Vertex *	fit (const std::vector< const Trk::TrackParameters * > &perigeeList, const Amg::Vector3D &startingPoint) const override
virtual xAOD::Vertex *	fit (const std::vector< const Trk::TrackParameters * > &perigeeList, const std::vector< const Trk::NeutralParameters * > &neutralPerigeeList, const xAOD::Vertex &constraint) const override
	Interface for MeasuredPerigee with vertex constraint.
virtual xAOD::Vertex *	fit (const std::vector< const Trk::TrackParameters * > &perigeeList, const xAOD::Vertex &constraint) const override
xAOD::Vertex *	fit (const std::vector< const Trk::Track * > &Vectortrk, const xAOD::Vertex &constraint, const Amg::Vector3D &startingPoint) const
	fit providing vector of tracks, constraint and startingPoint
xAOD::Vertex *	fit (const std::vector< const Trk::TrackParameters * > &perigeeList, const std::vector< const Trk::NeutralParameters * > &neutralPerigeeList, const xAOD::Vertex &constraint, const Amg::Vector3D &startingPoint) const
	fit providing vector of ParametersBase, constraint and startingPoint
xAOD::Vertex *	fit (const std::vector< const Trk::TrackParameters * > &perigeeList, const xAOD::Vertex &constraint, const Amg::Vector3D &startingPoint) const
xAOD::Vertex *	fit (const std::vector< const Trk::TrackParameters * > &perigeeList, const std::vector< const Trk::NeutralParameters * > &neutralPerigeeList) const override
	fit providing vector of TrackParameters and NeutralParameters
xAOD::Vertex *	fit (const std::vector< const Trk::TrackParameters * > &perigeeList) const override
xAOD::Vertex *	fit (const std::vector< const Trk::TrackParticleBase * > &perigeeList) const
	fit providing vector of TrackParticleBase
virtual std::unique_ptr< xAOD::Vertex >	fit (const EventContext &ctx, const std::vector< const xAOD::TrackParticle * > &vectorTrk, const Amg::Vector3D &startingPoint) const
	Interface for xAOD::TrackParticle with starting point Event Context aware interface.
virtual std::unique_ptr< xAOD::Vertex >	fit (const EventContext &ctx, const std::vector< const xAOD::TrackParticle * > &vectorTrk, const std::vector< const xAOD::NeutralParticle * > &vectorNeu, const Amg::Vector3D &startingPoint) const
	Interface for xAOD::TrackParticle and xAOD::NeutralParticle with starting point.
virtual std::unique_ptr< xAOD::Vertex >	fit (const EventContext &ctx, const std::vector< const xAOD::TrackParticle * > &vectorTrk, const std::vector< const xAOD::NeutralParticle * > &vectorNeu, const xAOD::Vertex &constraint) const
	Interface for xAOD::TrackParticle and xAOD::NeutralParticle with vertex constraint the position of the constraint is ALWAYS the starting point Event Context aware method.
virtual std::unique_ptr< xAOD::Vertex >	fit (const EventContext &ctx, const std::vector< const xAOD::TrackParticle * > &vectorTrk, const xAOD::Vertex &constraint) const
	Interface for xAOD::TrackParticle with vertex constraint the position of the constraint is ALWAYS the starting point Event Context aware method.
virtual std::unique_ptr< xAOD::Vertex >	fit (const EventContext &ctx, const std::vector< const Trk::TrackParameters * > &perigeeList, const std::vector< const Trk::NeutralParameters * > &neutralPerigeeList, const Amg::Vector3D &startingPoint) const
	Interface for TrackParameters and NeutralParameters with starting point Event Context aware method.
virtual std::unique_ptr< xAOD::Vertex >	fit (const EventContext &ctx, const std::vector< const Trk::TrackParameters * > &perigeeList, const Amg::Vector3D &startingPoint) const
	Interface for TrackParameters with starting point Event Context aware method.
virtual std::unique_ptr< xAOD::Vertex >	fit (const EventContext &ctx, const std::vector< const Trk::TrackParameters * > &perigeeList, const std::vector< const Trk::NeutralParameters * > &neutralPerigeeList, const xAOD::Vertex &constraint) const
	Interface for TrackParameters and NeutralParameters with vertex constraint the position of the constraint is ALWAYS the starting point EventContext aware method.
virtual std::unique_ptr< xAOD::Vertex >	fit (const EventContext &ctx, const std::vector< const Trk::TrackParameters * > &perigeeList, const xAOD::Vertex &constraint) const
	Interface for TrackParameters with vertex constraint the position of the constraint is ALWAYS the starting point EventContext aware method.
virtual std::unique_ptr< xAOD::Vertex >	fit (const EventContext &ctx, const std::vector< const Trk::TrackParameters * > &perigeeList, const std::vector< const Trk::NeutralParameters * > &neutralPerigeeList) const
	Fit method using the VertexSeedFinder to estimate initial position of the vertex and taking it as a first linearization point (in iterative fitters).
virtual std::unique_ptr< xAOD::Vertex >	fit (const EventContext &ctx, const std::vector< const Trk::TrackParameters * > &perigeeList) const
	Fit method using the VertexSeedFinder to estimate initial position of the vertex and taking it as a first linearization point (in iterative fitters).

Private Member Functions
xAOD::Vertex *	_fit (const std::vector< const Trk::TrackParameters * > &perigeeList, const std::vector< const Trk::NeutralParameters * > &neutralPerigeeList=std::vector< const Trk::NeutralParameters * >(), const xAOD::Vertex &constraint=xAOD::Vertex(), const Amg::Vector3D &startingPoint=Amg::Vector3D(), bool IsConstraint=false, bool IsStartingPoint=false) const
	Internal method for fitting a list of TrackParameters and NeutralParameters, with or without constraint and starting point.
xAOD::Vertex *	_fit (const std::vector< const Trk::TrackParameters * > &perigeeList, const xAOD::Vertex &constraint=xAOD::Vertex(), const Amg::Vector3D &startingPoint=Amg::Vector3D(), bool IsConstraint=false, bool IsStartingPoint=false) const
xAOD::Vertex *	_fit (const std::vector< const Trk::Track * > &VectorTrk, const xAOD::Vertex &constraint=xAOD::Vertex(), const Amg::Vector3D &startingPoint=Amg::Vector3D(), bool IsConstraint=false, bool IsStartingPoint=false) const
	Internal method for fitting a list of Tracks, with or without constraint and starting point.
xAOD::Vertex *	dothefit (const xAOD::Vertex &ConstraintVertex, const Amg::Vector3D &SeedVertex, std::vector< VxTrackAtVertex > &myLinTracks) const
	Internal method, called by the two _fit internal functions, in order to perform the fit, after having initialized the input (constraint + seed).

Private Attributes
ToolHandle< Trk::IVertexSeedFinder >	m_SeedFinder
ToolHandle< Trk::IVertexLinearizedTrackFactory >	m_LinearizedTrackFactory
ToolHandle< Trk::IVertexTrackCompatibilityEstimator >	m_TrackCompatibilityEstimator
ToolHandle< Trk::IImpactPoint3dEstimator >	m_ImpactPoint3dEstimator
ToolHandle< Trk::IVertexUpdator >	m_VertexUpdator
ToolHandle< Trk::IVertexSmoother >	m_VertexSmoother
ToolHandle< Trk::IVertexAnnealingMaker >	m_AnnealingMaker
long int	m_maxIterations
	Number of maximum iterations.
double	m_maxDistToLinPoint
	Maximum distance of linearization point of track to actual fitted vertex before needing to relinearize (in mm)
double	m_initialError
	Initial error in form of diagonal elements of the inverse of the covariance matrix (name is misleading: take the error, square it and initialize the variable with its inverse)
bool	m_onlyzseed
	Variable is true if seeding has to be performed only on the z direction.
bool	m_doSmoothing
	True if smoothing after fit iterations has to be performed: otherwise the Smoother AlgoTool provided to the fitter will be ignored.

Detailed Description

Author

N. Giacinto Piacquadio (Freiburg ATLAS Group)

This class implements a vertexing fitting algorithm which is adaptive and robust, quite insensitive to the presence of outliers.

The vertex algorithm is based on the typical Kalman-Filtering approach, with the difference that the inverse of the covariance matrices of the track parameters of the tracks which enter the fit are reweighted according to the probability of the tracks to be compatible with the vertex to be fit. In this way outliers/tracks which do not belong to the vertex are smoothly rejected.

Since the estimation of the vertex position during the first fit iterations is not particularly good and the compatiblity estimation of the tracks not always reliable, an annealing technique is also implemented, in order to make the rejection of outliers soft in the beginning and harder towards the end of the fit (for this the Annealing Maker class is responsible: as a default the Temperature of this thermodinamical procedure is lowered according to few predefined steps)

For greater modularity the algorithm is divided into 6 modules (AlgTools in Athena):

1. SeedFinder
2. LinearizedTrackFactory
3. TrackCompatibilityEstimator 3b. ImpactPoint3dEstimator
4. VertexUpdator
5. VertexSmoother plus another one, which is responsible for letting the temperature go down (the so called "annealing technique")
6. AnnealingMaker

This kind of algorithm was implemented for the first time by CMS: for information about the theoretical motivations a good reference is Wolfgang Waltenberger's PhD Thesis and many of the calculations implemented have been extensively shown in theoretical & experimental papers by Fruehwirth, Waltenberger, Strandlie et al.

---

Changes:

David Shope david.nosp@m..ric.nosp@m.hard..nosp@m.shop.nosp@m.e@cer.nosp@m.n.ch (2016-04-19) EDM Migration to xAOD - from Trk::VxCandidate to xAOD::Vertex, from Trk::RecVertex to xAOD::Vertex, from Trk::Vertex to Amg::Vector3D

Definition at line 86 of file AdaptiveVertexFitter.h.

Constructor & Destructor Documentation

AdaptiveVertexFitter()

Trk::AdaptiveVertexFitter::AdaptiveVertexFitter	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

default constructor due to Athena interface

Definition at line 29 of file AdaptiveVertexFitter.cxx.

                                                                                                         : 
    base_class(t,n,p),
    m_maxIterations(50),
    m_maxDistToLinPoint(0.5),
    m_initialError(0.0001),
    m_onlyzseed(false),
    m_doSmoothing(true)
  {
    declareProperty("MaxIterations",        m_maxIterations);
    declareProperty("MaxDistToLinPoint",    m_maxDistToLinPoint);
    declareProperty("InitialError",m_initialError);
    declareProperty("onlyzseed",m_onlyzseed);
    declareProperty("DoSmoothing",m_doSmoothing);
    declareInterface<IVertexFitter>(this);
  }

~AdaptiveVertexFitter()

Trk::AdaptiveVertexFitter::~AdaptiveVertexFitter ( )

virtualdefault

destructor

Member Function Documentation

_fit() [1/3]

xAOD::Vertex * Trk::AdaptiveVertexFitter::_fit ( const std::vector< const Trk::Track * > & VectorTrk, const xAOD::Vertex & constraint = xAOD::Vertex(), const Amg::Vector3D & startingPoint = Amg::Vector3D(), bool IsConstraint = false, bool IsStartingPoint = false ) const

private

Internal method for fitting a list of Tracks, with or without constraint and starting point.

Definition at line 257 of file AdaptiveVertexFitter.cxx.

  { // initialized to false
 
    ATH_MSG_DEBUG("Called Adaptive vertex with Trk::Track. N. Tracks = " << VectorTrk.size());
 
    std::vector<const Trk::TrackParameters*> perigeeList;
    for (const auto *iter : VectorTrk) {
      if (std::isnan(iter->perigeeParameters()->parameters()[Trk::d0])) {
        continue;
      }
      perigeeList.push_back(iter->perigeeParameters());
    }
 
    xAOD::Vertex * FittedVertex = _fit(perigeeList,constraint,startingPoint,IsConstraint,IsStartingPoint);
 
    if (FittedVertex==nullptr) {
      return FittedVertex;
    }
 
    //these following lines are really absurd... Why has this to be the case... <19-06-2006>
    //We need a link which can be dynamically to a Track or a TrackParticle....... )-:
 
    const std::vector<const Trk::Track*>::const_iterator trkbegin=VectorTrk.begin();
    const std::vector<const Trk::Track*>::const_iterator trkend=VectorTrk.end();
 
    const std::vector<VxTrackAtVertex>::iterator vtxbegin=FittedVertex->vxTrackAtVertex().begin();
    const std::vector<VxTrackAtVertex>::iterator vtxend=FittedVertex->vxTrackAtVertex().end();
 
    for (std::vector<const Trk::Track*>::const_iterator trkiter=trkbegin;trkiter!=trkend;++trkiter)
    {
      for (std::vector<Trk::VxTrackAtVertex>::iterator vtxiter=vtxbegin;vtxiter!=vtxend;++vtxiter)
      {
        if(((*trkiter)->perigeeParameters()->momentum() -
            (*vtxiter).initialPerigee()->momentum()).mag()< 1e-8  &&
            ((*trkiter)->perigeeParameters()->position() -
            (*vtxiter).initialPerigee()->position()).mag()< 1e-8)
        {
 
          ElementLink<TrackCollection> link;
          link.setElement(*trkiter);
          LinkToTrack * linkTT = new LinkToTrack(link);
          (*vtxiter).setOrigTrack(linkTT);
        }
      }
    }
 
    //*******************************************************************
    // TODO: Starting from a vector of Trk::Tracks, can't store
    // separately from the vxTrackAtVertex vector the links to the
    // original tracks in xAOD::Vertex (only links to xAOD::TrackParticles and
    // xAOD::NeutralParticles can be stored)
    //*******************************************************************
 
    return FittedVertex;
  }

_fit() [2/3]

xAOD::Vertex * Trk::AdaptiveVertexFitter::_fit ( const std::vector< const Trk::TrackParameters * > & perigeeList, const std::vector< const Trk::NeutralParameters * > & neutralPerigeeList = std::vector<const Trk::NeutralParameters*>(), const xAOD::Vertex & constraint = xAOD::Vertex(), const Amg::Vector3D & startingPoint = Amg::Vector3D(), bool IsConstraint = false, bool IsStartingPoint = false ) const

private

Internal method for fitting a list of TrackParameters and NeutralParameters, with or without constraint and starting point.

Definition at line 113 of file AdaptiveVertexFitter.cxx.

  {
 
    //check the number of tracks
    if ( (perigeeList.size() + neutralPerigeeList.size())<2 && !IsConstraint ) {
      msg(MSG::WARNING) << "Not enough tracks (>2) to fit in this event (without constraint)." << endmsg;
      return nullptr;
    }
    if ((perigeeList.size() + neutralPerigeeList.size())<1 && IsConstraint) {
      msg(MSG::WARNING) << "Not enough tracks (>1) to fit in this event (with constraint)." << endmsg;
      return nullptr;
    }
 
 
    Amg::Vector3D SeedPoint;
    //now find the best point for seeding and linearization of the tracks
    if (IsStartingPoint) {
      SeedPoint=startingPoint;
    } else {
      if (perigeeList.size()>1) {
        if (IsConstraint) {
          SeedPoint=m_SeedFinder->findSeed(perigeeList,&constraint);
        } else {
          SeedPoint=m_SeedFinder->findSeed(perigeeList);
        }
      }
      else if (IsConstraint) {
        SeedPoint=constraint.position();
      }
      else {
        SeedPoint.setZero();
      }
    }
 
    //in case m_onlyzseed is on, just use only the z component given by the seed finder
    if (m_onlyzseed&&IsConstraint) {
      SeedPoint=constraint.position();
    }
    
 
    //now create a Global Position with the linearized track and the linearization point 
    //which in this case is taken from the found seed for the vertex
    //use the linPoint to linearize tracks
    
    std::vector<VxTrackAtVertex> theLinTracks;
 
    std::vector<const Trk::TrackParameters*>::const_iterator perigeesBegin=perigeeList.begin();
    std::vector<const Trk::TrackParameters*>::const_iterator perigeesEnd=perigeeList.end();
 
    ATH_MSG_DEBUG("Inside fitter with track perigee parameters.");
    ATH_MSG_DEBUG("Seed point: " << SeedPoint);
    int myDebugNTrk(0);
 
    for (std::vector<const Trk::TrackParameters*>::const_iterator perigeesIter=perigeesBegin;perigeesIter!=perigeesEnd;++perigeesIter) {
      //      const MeasuredPerigee* castToMP=dynamic_cast<const MeasuredPerigee*>(*perigeesIter);
      //      if (castToMP==0) {
      //        msg << MSG::ERROR << "Cast to MeasuredPerigee not successfull. Treatment of neutrals not supported. Skipping track..." << endmsg;
      //        continue;
      //      }
 
      ATH_MSG_DEBUG("Track #" << myDebugNTrk++ << ". TrackParameters: x = "  << (*perigeesIter)->position().x() << ", y = "<< (*perigeesIter)->position().y() <<", z = "<< (*perigeesIter)->position().z() << ". Covariance: " << *(*perigeesIter)->covariance());
     
      VxTrackAtVertex* LinTrackToAdd = new VxTrackAtVertex(0., nullptr, nullptr, (*perigeesIter), nullptr); //TODO: Must think now about when to delete this memory! -David S.
      
      //m_LinearizedTrackFactory->linearize(*LinTrackToAdd,SeedPoint); why linearize it? maybe you don't need it at all!!!!! <19-05-2006>
      bool success=m_ImpactPoint3dEstimator->addIP3dAtaPlane(*LinTrackToAdd,SeedPoint);
      if (!success)
      {
    msg(MSG::DEBUG) << "Adding compatibility to vertex information failed. Newton distance finder didn't converge..." << endmsg;
      }
 
      theLinTracks.push_back(*LinTrackToAdd);
     
      delete LinTrackToAdd; //TODO: is here ok?
 
    }
 
    std::vector<const Trk::NeutralParameters*>::const_iterator neutralPerigeesBegin=neutralPerigeeList.begin();
    std::vector<const Trk::NeutralParameters*>::const_iterator neutralPerigeesEnd  =neutralPerigeeList.end();
 
    ATH_MSG_DEBUG("Inside fitter with neutral perigee parameters.");
    ATH_MSG_DEBUG("Seed point: " << SeedPoint);
    int myDebugNNeutral(0);
    for (std::vector<const Trk::NeutralParameters*>::const_iterator neutralPerigeesIter=neutralPerigeesBegin;neutralPerigeesIter!=neutralPerigeesEnd;++neutralPerigeesIter) {
 
      ATH_MSG_DEBUG("Neutral #" << myDebugNNeutral++ << ". NeutralParameters: x = "  << (*neutralPerigeesIter)->position().x() << ", y = "<< (*neutralPerigeesIter)->position().y() <<", z = "<< (*neutralPerigeesIter)->position().z());
      ATH_MSG_DEBUG("     Covariance: " << *(*neutralPerigeesIter)->covariance());
      ATH_MSG_DEBUG("     Momentum: x = "  << (*neutralPerigeesIter)->momentum().x() << ", y = "<< (*neutralPerigeesIter)->momentum().y() <<", z = "<< (*neutralPerigeesIter)->momentum().z());
 
      VxTrackAtVertex* LinTrackToAdd = new VxTrackAtVertex(0., nullptr, nullptr, nullptr, (*neutralPerigeesIter) ); //TODO: Must think now about when to delete this memory! -David S.
     
      bool success = m_ImpactPoint3dEstimator->addIP3dAtaPlane(*LinTrackToAdd,SeedPoint);
      if (!success)
      {
    msg(MSG::DEBUG) << "Adding compatibility to vertex information failed. Newton distance finder didn't converge..." << endmsg;
      }
      
      theLinTracks.push_back(*LinTrackToAdd);
 
      delete LinTrackToAdd; //TODO: is here ok?
    }
 
 
 
    //Initialize the vertex seed with an arbitrary great error matrix (just starting point,
    //not really prior information in it)
    if(msgLvl(MSG::VERBOSE))
    {
      msg(MSG::VERBOSE) << "Error at the beginning is set to " << m_initialError << endmsg;
    }
 
 
 
   
    xAOD::Vertex ConstraintVertex;
    ConstraintVertex.makePrivateStore();
    //use the previous prior vertex info for the initial vertex if there
    if (IsConstraint ) {
      ConstraintVertex.setPosition( constraint.position() );
      ConstraintVertex.setCovariancePosition( constraint.covariancePosition() );
      ConstraintVertex.setFitQuality( 0., 0. );
    } else {
      AmgSymMatrix(3) startingCovMatrix;
      startingCovMatrix.setIdentity();
      startingCovMatrix = startingCovMatrix / m_initialError;
      //now initialize with starting position and covariance matrix
      ConstraintVertex.setPosition( SeedPoint );
      ConstraintVertex.setCovariancePosition( startingCovMatrix );
      ConstraintVertex.setFitQuality( 0., -3. );
    }
 
    //now put the linearizedtracks into VxTrackAtVertex
    return dothefit(ConstraintVertex,SeedPoint,theLinTracks);
 
 
  }

_fit() [3/3]

xAOD::Vertex * Trk::AdaptiveVertexFitter::_fit ( const std::vector< const Trk::TrackParameters * > & perigeeList, const xAOD::Vertex & constraint = xAOD::Vertex(), const Amg::Vector3D & startingPoint = Amg::Vector3D(), bool IsConstraint = false, bool IsStartingPoint = false ) const

private

Definition at line 591 of file AdaptiveVertexFitter.cxx.

                                                    {
    const std::vector<const Trk::NeutralParameters*> neutralPerigeeList;
    return _fit(perigeeList, neutralPerigeeList, constraint, startingPoint, IsConstraint, IsStartingPoint);
  }

dothefit()

xAOD::Vertex * Trk::AdaptiveVertexFitter::dothefit ( const xAOD::Vertex & ConstraintVertex, const Amg::Vector3D & SeedVertex, std::vector< VxTrackAtVertex > & myLinTracks ) const

private

Internal method, called by the two _fit internal functions, in order to perform the fit, after having initialized the input (constraint + seed).

The real fit happens here.

Definition at line 319 of file AdaptiveVertexFitter.cxx.

  {
  
    //now reset the annealing maker
    Trk::IVertexAnnealingMaker::AnnealingState astate;
    m_AnnealingMaker->reset(astate);
 
    //Count the steps for the fit and the number of relinearizations needed in the fit
    int num_steps(0);
 
 
    xAOD::Vertex* ActualVertex = new xAOD::Vertex();
    ActualVertex->makePrivateStore(); // xAOD::VertexContainer will take ownership of AuxStore when ActualVertex is added to it
    ActualVertex->setPosition( ConstraintVertex.position() );
    ActualVertex->setCovariancePosition( ConstraintVertex.covariancePosition() / m_AnnealingMaker->getWeight(astate, 1.) );
    ActualVertex->setFitQuality( ConstraintVertex.chiSquared(), ConstraintVertex.numberDoF() );
    ActualVertex->vxTrackAtVertex() = myLinTracks;
    ActualVertex->setVertexType(xAOD::VxType::NotSpecified); // to mimic the initialization present in the old EDM constructor
 
    Amg::Vector3D NewVertex = SeedVertex;
 
    Amg::Vector3D ActualSeedPosition = SeedVertex;
 
    if(msgLvl(MSG::VERBOSE))
    {
      msg(MSG::VERBOSE) << "Num max of steps is " << m_maxIterations << endmsg;
      msg(MSG::VERBOSE) << "m_AnnealingMaker->isEquilibrium() is " << m_AnnealingMaker->isEquilibrium(astate) << endmsg;
    }
 
    std::vector<Trk::VxTrackAtVertex>::iterator lintracksBegin = ActualVertex->vxTrackAtVertex().begin();
    std::vector<Trk::VxTrackAtVertex>::iterator lintracksEnd   = ActualVertex->vxTrackAtVertex().end();
 
    std::vector<Trk::VxTrackAtVertex>::iterator iter;
 
    bool relinearization = false;
 
    do {
 
      ActualVertex->setPosition( ConstraintVertex.position() );
      ActualVertex->setCovariancePosition( ConstraintVertex.covariancePosition() / m_AnnealingMaker->getWeight(astate, 1.) );
      ActualVertex->setFitQuality( ConstraintVertex.chiSquared(), ConstraintVertex.numberDoF() );
 
      if(msgLvl(MSG::DEBUG))
      {
        msg(MSG::DEBUG) << "Correction applied to constraint weight is: " << m_AnnealingMaker->getWeight(astate, 1.) << endmsg;
      }
 
      //To reweight here through an extrapolation is not ideal, but maybe I'll change this in the future...
      if(msgLvl(MSG::DEBUG))
      {
        msg(MSG::DEBUG) << "New fit step: step number " << num_steps << endmsg;
      }
 
      //consider relinearization if you are too far away from the old lin point
 
 
      relinearization=false;
      if ( (ActualSeedPosition - SeedVertex).perp() > m_maxDistToLinPoint ) {
        relinearization=true;
        if(msgLvl(MSG::DEBUG))
        {
          msg(MSG::DEBUG) << "Actual vertex too far away from linearization point: have to linearize tracks again" << endmsg;
        }
 
        //collect all measured perigees
        
        for (iter=lintracksBegin;iter!=lintracksEnd;++iter) {
          //m_LinearizedTrackFactory->linearize(*iter,ActualPosition);
          bool success=m_ImpactPoint3dEstimator->addIP3dAtaPlane(*iter,NewVertex);
          if (!success)
          {
            msg(MSG::DEBUG) << "Adding compatibility to vertex information failed. Newton distance finder didn't converge..." << endmsg;
          }
        }
        
      }
 
 
      lintracksBegin=ActualVertex->vxTrackAtVertex().begin();
      lintracksEnd=ActualVertex->vxTrackAtVertex().end();
 
      //now reweight tracks (find chi2 compatibility with actual vertex position)
      for (iter=lintracksBegin;iter!=lintracksEnd;++iter) {
 
        //estimate the compatibility of the track to the vertex and store it in iter->linState()->m_vtxCompatibility
        m_TrackCompatibilityEstimator->estimate(*iter,NewVertex);
 
        //use the obtained estimate and ask the Annealing Maker what is the corresponding weight at the actual temperature step
        iter->setWeight( m_AnnealingMaker->getWeight( astate, iter->vtxCompatibility() ) );
        if(msgLvl(MSG::VERBOSE))
        {
          msg(MSG::VERBOSE) << "Before annealing: " << iter->vtxCompatibility() <<
              " Annealing RESULT is:" << iter->weight() << " at T: " <<
              m_AnnealingMaker->actualTemp(astate) << endmsg;
        }
 
 
      }
 
      //now update with all the tracks info
      for (iter=lintracksBegin;iter!=lintracksEnd;++iter) {
        if(msgLvl(MSG::VERBOSE))
        {
          msg(MSG::VERBOSE) << "Updating vertex with a new track" << endmsg;
        }
        try {
 
          if ( iter->weight() > 1e-3 ) {
            //now take care if linearization has been done at least once 
            //or if vertex has changed so much so that you need relinearization!
            if ( iter->linState() == nullptr) {
              //linearization has not been done so far: do it now!
              if(msgLvl(MSG::VERBOSE))
              {
                msg(MSG::VERBOSE) << "Linearizing track for the first time" << endmsg;
              }
 
              m_LinearizedTrackFactory->linearize( *iter, ActualVertex->position() );
              ATH_MSG_DEBUG( "Linearized track to Seed Point. " << *iter );
            } else if (relinearization) {
              //do it again in case of updated vertex too far from previous one 
              if(msgLvl(MSG::VERBOSE))
              {
                msg(MSG::VERBOSE) << "Relinearizing track " << endmsg;
              }
 
              m_LinearizedTrackFactory->linearize( *iter, NewVertex );
              ActualSeedPosition=NewVertex;
              ATH_MSG_DEBUG("Linearized track to new seed Point " << NewVertex << ". " << *iter );
            }
            ActualVertex=m_VertexUpdator->add(*ActualVertex,*iter);
          } else {
            if(msgLvl(MSG::VERBOSE))
            {
              msg(MSG::VERBOSE) << "Weight lower than 1e-3, so the track will not be considered anymore" << endmsg;
            }
 
          }
        } catch (...) {
          msg(MSG::WARNING) << "You have just lost a track" << endmsg;
        }
      }
 
      //show some info about the position
      if(msgLvl(MSG::DEBUG))
      {
        msg(MSG::DEBUG) << "New position x: " << ActualVertex->position().x() << " y: " << ActualVertex->position().y()
                        << " z: " << ActualVertex->position().z() << endmsg;
      }
 
 
      NewVertex = ActualVertex->position();
 
      //now go one step down in the annealing process (lower the temperature - single step)
      if(msgLvl(MSG::VERBOSE))
      {
        msg(MSG::VERBOSE) << "Now calling one step of annealing" << endmsg;
      }
 
      m_AnnealingMaker->anneal(astate);
      num_steps+=1;
 
      //continue to fit until max iteration number has been reached or "thermal equilibrium"
      //has been obtained in the annealing process
 
    } while (num_steps<m_maxIterations && !(m_AnnealingMaker->isEquilibrium(astate)) );
 
    //Here smooth the vertex (refitting of the track)
    
    //without smoothing... for the moment...
    if(m_doSmoothing) {
      m_VertexSmoother->smooth(*ActualVertex);
    } else {
      for (iter=lintracksBegin;iter!=lintracksEnd;++iter) {
        //      const MeasuredPerigee* castToMP=dynamic_cast<const MeasuredPerigee*>(iter->initialPerigee());
        //      if (castToMP==0) {
        //        msg(MSG::WARNING) << "Couldn't cast a track to MeasuredPerigee to smooth it. Neutrals not supported. " <<
        //          " Skipping track. .. " << endmsg;
        //        continue;
        //      }
        if ( iter->initialPerigee() )
          iter->setPerigeeAtVertex( ( iter->initialPerigee() )->clone() );
        else if ( iter->initialNeutralPerigee() )
          iter->setPerigeeAtVertex( ( iter->initialNeutralPerigee() )->clone() );
      }
    }
 
    if(msgLvl(MSG::DEBUG))
    {
      msg(MSG::DEBUG) << "chi2: " << ActualVertex->chiSquared()
                      << "the ndf of the vertex is at fit end: " << ActualVertex->numberDoF() << endmsg;
    }
 
 
    //Give back all info into the ActualVertex xAOD::Vertex
    return ActualVertex;
  }

fit() [1/24]

virtual std::unique_ptr< xAOD::Vertex > Trk::IVertexFitter::fit ( const EventContext & ctx, const std::vector< const Trk::TrackParameters * > & perigeeList ) const

inline

Fit method using the VertexSeedFinder to estimate initial position of the vertex and taking it as a first linearization point (in iterative fitters).

EventContext aware method.

Definition at line 215 of file IVertexFitter.h.

  {
    (void)(ctx);
    return std::unique_ptr<xAOD::Vertex>(fit(perigeeList));
  }

fit() [2/24]

virtual std::unique_ptr< xAOD::Vertex > Trk::IVertexFitter::fit ( const EventContext & ctx, const std::vector< const Trk::TrackParameters * > & perigeeList, const Amg::Vector3D & startingPoint ) const

inline

Interface for TrackParameters with starting point Event Context aware method.

Definition at line 154 of file IVertexFitter.h.

  {
    (void)(ctx);
    return std::unique_ptr<xAOD::Vertex>(fit(perigeeList, startingPoint));
  }

fit() [3/24]

virtual std::unique_ptr< xAOD::Vertex > Trk::IVertexFitter::fit ( const EventContext & ctx, const std::vector< const Trk::TrackParameters * > & perigeeList, const std::vector< const Trk::NeutralParameters * > & neutralPerigeeList ) const

inline

Fit method using the VertexSeedFinder to estimate initial position of the vertex and taking it as a first linearization point (in iterative fitters).

EventContext aware method.

Definition at line 200 of file IVertexFitter.h.

  {
    (void)(ctx);
    return std::unique_ptr<xAOD::Vertex>(fit(perigeeList, neutralPerigeeList));
  }

fit() [4/24]

virtual std::unique_ptr< xAOD::Vertex > Trk::IVertexFitter::fit ( const EventContext & ctx, const std::vector< const Trk::TrackParameters * > & perigeeList, const std::vector< const Trk::NeutralParameters * > & neutralPerigeeList, const Amg::Vector3D & startingPoint ) const

inline

Interface for TrackParameters and NeutralParameters with starting point Event Context aware method.

Definition at line 138 of file IVertexFitter.h.

  {
    (void)(ctx);
    return std::unique_ptr<xAOD::Vertex>(
      fit(perigeeList, neutralPerigeeList, startingPoint));
  }

fit() [5/24]

virtual std::unique_ptr< xAOD::Vertex > Trk::IVertexFitter::fit ( const EventContext & ctx, const std::vector< const Trk::TrackParameters * > & perigeeList, const std::vector< const Trk::NeutralParameters * > & neutralPerigeeList, const xAOD::Vertex & constraint ) const

inline

Interface for TrackParameters and NeutralParameters with vertex constraint the position of the constraint is ALWAYS the starting point EventContext aware method.

Definition at line 169 of file IVertexFitter.h.

  {
    (void)(ctx);
    return std::unique_ptr<xAOD::Vertex>(
      fit(perigeeList, neutralPerigeeList, constraint));
  }

fit() [6/24]

virtual std::unique_ptr< xAOD::Vertex > Trk::IVertexFitter::fit ( const EventContext & ctx, const std::vector< const Trk::TrackParameters * > & perigeeList, const xAOD::Vertex & constraint ) const

inline

Interface for TrackParameters with vertex constraint the position of the constraint is ALWAYS the starting point EventContext aware method.

Definition at line 185 of file IVertexFitter.h.

  {
    (void)(ctx);
    return std::unique_ptr<xAOD::Vertex>(fit(perigeeList, constraint));
  }

fit() [7/24]

virtual std::unique_ptr< xAOD::Vertex > Trk::IVertexFitter::fit ( const EventContext & ctx, const std::vector< const xAOD::TrackParticle * > & vectorTrk, const Amg::Vector3D & startingPoint ) const

inline

Interface for xAOD::TrackParticle with starting point Event Context aware interface.

Definition at line 77 of file IVertexFitter.h.

  {
    (void)(ctx);
    return std::unique_ptr<xAOD::Vertex>(fit(vectorTrk, startingPoint));
  }

fit() [8/24]

virtual std::unique_ptr< xAOD::Vertex > Trk::IVertexFitter::fit ( const EventContext & ctx, const std::vector< const xAOD::TrackParticle * > & vectorTrk, const std::vector< const xAOD::NeutralParticle * > & vectorNeu, const Amg::Vector3D & startingPoint ) const

inline

Interface for xAOD::TrackParticle and xAOD::NeutralParticle with starting point.

Event Context aware method

Definition at line 91 of file IVertexFitter.h.

  {
    (void)(ctx);
    return std::unique_ptr<xAOD::Vertex>(
      fit(vectorTrk, vectorNeu, startingPoint));
  }

fit() [9/24]

virtual std::unique_ptr< xAOD::Vertex > Trk::IVertexFitter::fit ( const EventContext & ctx, const std::vector< const xAOD::TrackParticle * > & vectorTrk, const std::vector< const xAOD::NeutralParticle * > & vectorNeu, const xAOD::Vertex & constraint ) const

inline

Interface for xAOD::TrackParticle and xAOD::NeutralParticle with vertex constraint the position of the constraint is ALWAYS the starting point Event Context aware method.

Definition at line 108 of file IVertexFitter.h.

  {
    (void)(ctx);
    return std::unique_ptr<xAOD::Vertex>(fit(vectorTrk, vectorNeu, constraint));
  }

fit() [10/24]

virtual std::unique_ptr< xAOD::Vertex > Trk::IVertexFitter::fit ( const EventContext & ctx, const std::vector< const xAOD::TrackParticle * > & vectorTrk, const xAOD::Vertex & constraint ) const

inline

Interface for xAOD::TrackParticle with vertex constraint the position of the constraint is ALWAYS the starting point Event Context aware method.

Definition at line 124 of file IVertexFitter.h.

  {
    (void)(ctx);
    return std::unique_ptr<xAOD::Vertex>(fit(vectorTrk, constraint));
  }

fit() [11/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit	(	const std::vector< const Trk::Track * > &	Vectortrk,
		const xAOD::Vertex &	constraint,
		const Amg::Vector3D &	startingPoint ) const

fit providing vector of tracks, constraint and startingPoint

fit() [12/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit ( const std::vector< const Trk::TrackParameters * > & perigeeList ) const

override

Definition at line 585 of file AdaptiveVertexFitter.cxx.

  {
    const std::vector<const Trk::NeutralParameters*> neutralPerigeeList; 
    return fit(perigeeList,neutralPerigeeList);
  }

fit() [13/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit ( const std::vector< const Trk::TrackParameters * > & perigeeList, const Amg::Vector3D & startingPoint ) const

overridevirtual

Definition at line 558 of file AdaptiveVertexFitter.cxx.

  {
    const std::vector<const Trk::NeutralParameters*> neutralPerigeeList;
    return fit(perigeeList, neutralPerigeeList, startingPoint);
  }

fit() [14/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit ( const std::vector< const Trk::TrackParameters * > & perigeeList, const std::vector< const Trk::NeutralParameters * > & neutralPerigeeList ) const

override

fit providing vector of TrackParameters and NeutralParameters

Definition at line 550 of file AdaptiveVertexFitter.cxx.

  {
    return _fit(perigeeList,neutralPerigeeList,xAOD::Vertex(),Amg::Vector3D(),false,false);
  }

fit() [15/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit ( const std::vector< const Trk::TrackParameters * > & perigeeList, const std::vector< const Trk::NeutralParameters * > & neutralPerigeeList, const Amg::Vector3D & startingPoint ) const

overridevirtual

Interface for MeasuredPerigee with starting point.

Definition at line 521 of file AdaptiveVertexFitter.cxx.

  {
 
    return _fit(perigeeList,neutralPerigeeList,xAOD::Vertex(),startingPoint,false,true);
  }

fit() [16/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit ( const std::vector< const Trk::TrackParameters * > & perigeeList, const std::vector< const Trk::NeutralParameters * > & neutralPerigeeList, const xAOD::Vertex & constraint ) const

overridevirtual

Interface for MeasuredPerigee with vertex constraint.

Definition at line 531 of file AdaptiveVertexFitter.cxx.

  {
    return _fit(perigeeList,neutralPerigeeList,constraint,Amg::Vector3D::Zero(),true);
  }

fit() [17/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit	(	const std::vector< const Trk::TrackParameters * > &	perigeeList,
		const std::vector< const Trk::NeutralParameters * > &	neutralPerigeeList,
		const xAOD::Vertex &	constraint,
		const Amg::Vector3D &	startingPoint ) const

fit providing vector of ParametersBase, constraint and startingPoint

Definition at line 540 of file AdaptiveVertexFitter.cxx.

  {
    return _fit(perigeeList,neutralPerigeeList,constraint,startingPoint,true,true);
  }

fit() [18/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit ( const std::vector< const Trk::TrackParameters * > & perigeeList, const xAOD::Vertex & constraint ) const

overridevirtual

Definition at line 567 of file AdaptiveVertexFitter.cxx.

  {
    const std::vector<const Trk::NeutralParameters*> neutralPerigeeList;
    return fit(perigeeList, neutralPerigeeList, constraint);
  }

fit() [19/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit	(	const std::vector< const Trk::TrackParameters * > &	perigeeList,
		const xAOD::Vertex &	constraint,
		const Amg::Vector3D &	startingPoint ) const

Definition at line 576 of file AdaptiveVertexFitter.cxx.

  {
    const std::vector<const Trk::NeutralParameters*> neutralPerigeeList;
    return fit(perigeeList, neutralPerigeeList, constraint, startingPoint);
  }

fit() [20/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit

(

const std::vector< const Trk::TrackParticleBase * > &

perigeeList

)

const

fit providing vector of TrackParticleBase

fit() [21/24]

virtual xAOD::Vertex * Trk::AdaptiveVertexFitter::fit ( const std::vector< const xAOD::TrackParticle * > & vectorTrk, const Amg::Vector3D & startingPoint ) const

inlineoverridevirtual

Definition at line 116 of file AdaptiveVertexFitter.h.

  {
    return fit(vectorTrk, std::vector<const xAOD::NeutralParticle*>(), startingPoint);
  };

fit() [22/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit ( const std::vector< const xAOD::TrackParticle * > & vectorTrk, const std::vector< const xAOD::NeutralParticle * > & vectorNeut, const Amg::Vector3D & startingPoint ) const

overridevirtual

Interface for xAOD::TrackParticle with starting point.

Definition at line 604 of file AdaptiveVertexFitter.cxx.

  {
 
    if (vectorTrk.empty()) {
      msg(MSG::INFO) << "Empty vector of tracks passed" << endmsg;
      return nullptr;
    }
 
    if (vectorNeut.empty()) {
      msg(MSG::VERBOSE) << "Empty vector of neutrals passed" << endmsg;
    }
 
    // making a list of perigee out of the vector of tracks
    std::vector<const Trk::TrackParameters*> measuredPerigees;
 
    for (const auto *i : vectorTrk) {
      const Trk::TrackParameters* tmpMeasPer = &(i->perigeeParameters());
 
      if (tmpMeasPer != nullptr)
        measuredPerigees.push_back(tmpMeasPer);
      else
        msg(MSG::INFO)
          << "Failed to dynamic_cast this track parameters to perigee"
          << endmsg; // TODO: Failed to implicit cast the perigee parameters to
                     // track parameters?
    }
 
    // making a list of perigee out of the vector of neutrals
    std::vector<const Trk::NeutralParameters*> measuredNeutralPerigees;
 
    for (const auto *i : vectorNeut) {
      const Trk::NeutralParameters* tmpMeasPer = &(i->perigeeParameters());
 
      if (tmpMeasPer != nullptr)
        measuredNeutralPerigees.push_back(tmpMeasPer);
      else
        msg(MSG::INFO)
          << "Failed to dynamic_cast this neutral parameters to perigee"
          << endmsg; // TODO: Failed to implicit cast the perigee parameters to
                     // neutral parameters?
    }
 
    xAOD::Vertex* fittedVertex = _fit(measuredPerigees,
                                      measuredNeutralPerigees,
                                      xAOD::Vertex(),
                                      startingPoint,
                                      false,
                                      true);
 
    // assigning the input tracks to the fitted vertex through VxTrackAtVertices
    if (fittedVertex == nullptr) {
      return fittedVertex;
    }
 
    if (fittedVertex
          ->vxTrackAtVertexAvailable()) // TODO: I don't think
                                        // vxTrackAtVertexAvailable() does the
                                        // same thing as a null pointer check!
    {
      if (!fittedVertex->vxTrackAtVertex().empty()) {
        for (unsigned int i = 0; i < vectorTrk.size(); ++i) {
 
          LinkToXAODTrackParticle* linkTT = new LinkToXAODTrackParticle();
          const xAOD::TrackParticleContainer* cont =
            dynamic_cast<const xAOD::TrackParticleContainer*>(
              vectorTrk[i]->container());
          if (cont) {
            if (!linkTT->toIndexedElement(*cont, vectorTrk[i]->index())) {
              msg(MSG::WARNING)
                << "Failed to set the EL for this particle correctly" << endmsg;
            }
          } else {
            msg(MSG::WARNING)
              << "Failed to identify a  container for this TP" << endmsg;
          } // end of the dynamic cast check
 
          // vxtrackatvertex takes ownership!
          (fittedVertex->vxTrackAtVertex())[i].setOrigTrack(linkTT);
        } // end of loop for setting orig tracks in.
 
        for (unsigned int i = 0; i < vectorNeut.size(); ++i) {
          LinkToXAODNeutralParticle* linkTT = new LinkToXAODNeutralParticle();
          const xAOD::NeutralParticleContainer* cont =
            dynamic_cast<const xAOD::NeutralParticleContainer*>(
              vectorNeut[i]->container());
          if (cont) {
            if (!linkTT->toIndexedElement(*cont, vectorNeut[i]->index())) {
              msg(MSG::WARNING)
                << "Failed to set the EL for this particle correctly" << endmsg;
            }
          } else {
            msg(MSG::WARNING)
              << "Failed to identify a  container for this TP" << endmsg;
          } // end of the dynamic cast check
 
          // vxtrackatvertex takes ownership!
          (fittedVertex->vxTrackAtVertex())[i + vectorTrk.size()].setOrigTrack(
            linkTT);
        } // end of loop for setting orig neutrals in.
 
      } // end of protection against unsuccessfull updates (no tracks were
        // added)
    } // end of vector of tracks check
 
    // now set links to xAOD::TrackParticles directly in the xAOD::Vertex
    unsigned int VTAVsize = fittedVertex->vxTrackAtVertex().size();
    for (unsigned int i = 0; i < VTAVsize; ++i) {
      Trk::VxTrackAtVertex* VTAV = &(fittedVertex->vxTrackAtVertex().at(i));
      // TODO: Will this pointer really hold 0 if no VxTrackAtVertex is found?
      if (not VTAV) {
        ATH_MSG_WARNING(" Trying to set link to xAOD::TrackParticle. The "
                        "VxTrackAtVertex is not found");
        continue;
      }
 
      Trk::ITrackLink* trklink = VTAV->trackOrParticleLink();
 
      // See if the trklink is to an xAOD::TrackParticle
      Trk::LinkToXAODTrackParticle* linkToXAODTP =
        dynamic_cast<Trk::LinkToXAODTrackParticle*>(trklink);
      if (linkToXAODTP) {
 
        // Now set the new link to the xAOD vertex
        fittedVertex->addTrackAtVertex(*linkToXAODTP, VTAV->weight());
 
      } else {
 
        // See if the trklink is to an xAOD::NeutralParticle
        Trk::LinkToXAODNeutralParticle* linkToXAODTPneutral =
          dynamic_cast<Trk::LinkToXAODNeutralParticle*>(trklink);
        if (!linkToXAODTPneutral) {
          ATH_MSG_WARNING(
            "Skipping track. Trying to set link to something else than "
            "xAOD::TrackParticle or xAOD::NeutralParticle.");
        } else {
          // Now set the newlink to the new xAOD vertex
          fittedVertex->addNeutralAtVertex(*linkToXAODTPneutral,
                                           VTAV->weight());
        }
      }
    } // end of loop
 
    return fittedVertex;
   
 }//end of the xAOD starting point fit method

fit() [23/24]

xAOD::Vertex * Trk::AdaptiveVertexFitter::fit ( const std::vector< const xAOD::TrackParticle * > & vectorTrk, const std::vector< const xAOD::NeutralParticle * > & vectorNeut, const xAOD::Vertex & constraint ) const

overridevirtual

Interface for xAOD::TrackParticle with vertex constraint the position of the constraint is ALWAYS the starting point.

Definition at line 754 of file AdaptiveVertexFitter.cxx.

 {
 
   if(vectorTrk.empty())
   {
     msg(MSG::INFO)<<"Empty vector of tracks passed"<<endmsg;
     return nullptr;
   }
 
   if(vectorNeut.empty())
   {
     msg(MSG::INFO)<<"Empty vector of neutrals passed"<<endmsg;
   }
   
   //making a list of perigee out of the vector of tracks
   std::vector<const Trk::TrackParameters*> measuredPerigees;
   
   for(const auto *i : vectorTrk)
   {
     const Trk::TrackParameters * tmpMeasPer = &(i->perigeeParameters());
  
     if(tmpMeasPer!=nullptr) measuredPerigees.push_back(tmpMeasPer);
     else  msg(MSG::INFO)<<"Failed to dynamic_cast this track parameters to perigee"<<endmsg; //TODO: Failed to implicit cast the perigee parameters to track parameters?
   }
 
   //making a list of perigee out of the vector of neutrals
   std::vector<const Trk::NeutralParameters*> measuredNeutralPerigees;
 
   for(const auto *i : vectorNeut)
   {
     const Trk::NeutralParameters * tmpMeasPer = &(i->perigeeParameters());
  
     if(tmpMeasPer!=nullptr) measuredNeutralPerigees.push_back(tmpMeasPer);
     else  msg(MSG::INFO)<<"Failed to dynamic_cast this neutral parameters to perigee"<<endmsg; //TODO: Failed to implicit cast the perigee parameters to neutral parameters?
   }
   
   
   xAOD::Vertex* fittedVertex = _fit(measuredPerigees, measuredNeutralPerigees, constraint, Amg::Vector3D(),true);
 
 
   //assigning the input tracks to the fitted vertex through VxTrackAtVertices
   {
     if( fittedVertex->vxTrackAtVertexAvailable() ) // TODO: I don't think vxTrackAtVertexAvailable() does the same thing as a null pointer check
     {
       if(!fittedVertex->vxTrackAtVertex().empty())
       {
         for(unsigned int i = 0; i <vectorTrk.size(); ++i)
         {
 
           LinkToXAODTrackParticle* linkTT = new LinkToXAODTrackParticle();
           const xAOD::TrackParticleContainer* cont = dynamic_cast< const xAOD::TrackParticleContainer* >( vectorTrk[ i ]->container() );
           if(  cont )
           {
             if( ! linkTT->toIndexedElement( *cont, vectorTrk[ i ]->index() ) )
             {
           msg(MSG::WARNING)<<"Failed to set the EL for this particle correctly"<<endmsg;
             }
           } else {
             msg(MSG::WARNING)<<"Failed to identify a  container for this TP"<<endmsg;
           }//end of the dynamic cast check 
 
 
           // vxtrackatvertex takes ownership!
           ( fittedVertex->vxTrackAtVertex() )[i].setOrigTrack(linkTT);
         }//end of loop for setting orig tracks in.
 
         for(unsigned int i = 0; i <vectorNeut.size(); ++i)
         {
           LinkToXAODNeutralParticle* linkTT = new LinkToXAODNeutralParticle();
           const xAOD::NeutralParticleContainer* cont = dynamic_cast< const xAOD::NeutralParticleContainer* >( vectorNeut[ i ]->container() );
           if(  cont )
           {
             if( ! linkTT->toIndexedElement( *cont, vectorNeut[ i ]->index() ) )
             {
           msg(MSG::WARNING)<<"Failed to set the EL for this particle correctly"<<endmsg;
         }
           } else {
             msg(MSG::WARNING)<<"Failed to identify a  container for this NP"<<endmsg;
           }//end of the dynamic cast check 
 
           // vxtrackatvertex takes ownership!
           ( fittedVertex->vxTrackAtVertex() )[vectorTrk.size()+i].setOrigTrack(linkTT);
         }//end of loop for setting orig neutrals in.
 
       }//end of protection against unsuccessfull updates (no tracks were added)
     }//end of vector of tracks check
   }
 
 
   //now set links to xAOD::TrackParticles directly in the xAOD::Vertex
   unsigned int VTAVsize = fittedVertex->vxTrackAtVertex().size();
   for (unsigned int i = 0 ; i < VTAVsize ; ++i)
   {
     Trk::VxTrackAtVertex* VTAV = &( fittedVertex->vxTrackAtVertex().at(i) );
     //TODO: Will this pointer really hold 0 if no VxTrackAtVertex is found?
     if (not VTAV){
       ATH_MSG_WARNING (" Trying to set link to xAOD::TrackParticle. The VxTrackAtVertex is not found");
       continue;
     }
 
     Trk::ITrackLink* trklink = VTAV->trackOrParticleLink();
 
     // See if the trklink is to an xAOD::TrackParticle
     Trk::LinkToXAODTrackParticle* linkToXAODTP = dynamic_cast<Trk::LinkToXAODTrackParticle*>(trklink);
     if (linkToXAODTP)
     {
 
       //Now set the new link to the xAOD vertex
       fittedVertex->addTrackAtVertex(*linkToXAODTP, VTAV->weight());
 
     } else {
 
       // See if the trklink is to an xAOD::NeutralParticle
       Trk::LinkToXAODNeutralParticle* linkToXAODTPneutral = dynamic_cast<Trk::LinkToXAODNeutralParticle*>(trklink);
       if (!linkToXAODTPneutral) {
         ATH_MSG_WARNING ("Skipping track. Trying to set link to something else than xAOD::TrackParticle or xAOD::NeutralParticle.");
       } else {
         //Now set the new link to the new xAOD vertex
         fittedVertex->addNeutralAtVertex(*linkToXAODTPneutral, VTAV->weight());
       }
 
     }
   } //end of loop
 
   return fittedVertex;
 
 }//end of the xAOD constrained fit method

fit() [24/24]

virtual xAOD::Vertex * Trk::AdaptiveVertexFitter::fit ( const std::vector< const xAOD::TrackParticle * > & vectorTrk, const xAOD::Vertex & constraint ) const

inlineoverridevirtual

Definition at line 129 of file AdaptiveVertexFitter.h.

  {
    return fit(vectorTrk, std::vector<const xAOD::NeutralParticle*>(), constraint);
  };

initialize()

StatusCode Trk::AdaptiveVertexFitter::initialize ( )

overridevirtual

Definition at line 47 of file AdaptiveVertexFitter.cxx.

  {
    StatusCode s = AlgTool::initialize();
    if (s.isFailure()) 
    {
      msg(MSG::FATAL) << "AlgTool::initialize() failed" << endmsg;
      return StatusCode::FAILURE;
    }
    if ( m_SeedFinder.retrieve().isFailure() ) {
      msg(MSG::FATAL) << "Failed to retrieve tool " << m_SeedFinder << endmsg;
      return StatusCode::FAILURE;
    } 
      msg(MSG::INFO) << "Retrieved tool " << m_SeedFinder << endmsg;
    
 
    if ( m_LinearizedTrackFactory.retrieve().isFailure() ) {
      msg(MSG::FATAL) << "Failed to retrieve tool " << m_LinearizedTrackFactory << endmsg;
      return StatusCode::FAILURE;
    } 
      msg(MSG::INFO) << "Retrieved tool " << m_LinearizedTrackFactory << endmsg;
    
 
    if ( m_TrackCompatibilityEstimator.retrieve().isFailure() ) {
      msg(MSG::FATAL) << "Failed to retrieve tool " << m_TrackCompatibilityEstimator << endmsg;
      return StatusCode::FAILURE;
    } 
      msg(MSG::INFO) << "Retrieved tool " << m_TrackCompatibilityEstimator << endmsg;
    
    
    if ( m_ImpactPoint3dEstimator.retrieve().isFailure() ) {
      msg(MSG::FATAL) << "Failed to retrieve tool " << m_ImpactPoint3dEstimator << endmsg;
      return StatusCode::FAILURE;
    } 
      msg(MSG::INFO) << "Retrieved tool " << m_ImpactPoint3dEstimator << endmsg;
    
    
    if ( m_VertexUpdator.retrieve().isFailure() ) {
      msg(MSG::FATAL) << "Failed to retrieve tool " << m_VertexUpdator << endmsg;
      return StatusCode::FAILURE;
    } 
      msg(MSG::INFO) << "Retrieved tool " << m_VertexUpdator << endmsg;
    
    
   //loading smoother in case required   
   if(m_doSmoothing)
   {
    if ( m_VertexSmoother.retrieve().isFailure() ) {
      msg(MSG::FATAL) << "Failed to retrieve tool " << m_VertexSmoother << endmsg;
      return StatusCode::FAILURE;
    } 
      msg(MSG::INFO) << "Retrieved tool " << m_VertexSmoother << endmsg;
    
   }//end of smoothing options
   
  if ( m_AnnealingMaker.retrieve().isFailure() ) {
    msg(MSG::FATAL) << "Failed to retrieve tool " << m_AnnealingMaker << endmsg;
    return StatusCode::FAILURE;
  } 
    msg(MSG::INFO) << "Retrieved tool " << m_AnnealingMaker << endmsg;
  
 
    return StatusCode::SUCCESS;
  }

Member Data Documentation

m_AnnealingMaker

ToolHandle<Trk::IVertexAnnealingMaker> Trk::AdaptiveVertexFitter::m_AnnealingMaker

private

Initial value:

{
    this,
    "AnnealingMaker",
    "Trk::DetAnnealingMaker"
  }

Definition at line 254 of file AdaptiveVertexFitter.h.

                                                       {
    this,
    "AnnealingMaker",
    "Trk::DetAnnealingMaker"
  };

m_doSmoothing

bool Trk::AdaptiveVertexFitter::m_doSmoothing

private

True if smoothing after fit iterations has to be performed: otherwise the Smoother AlgoTool provided to the fitter will be ignored.

Definition at line 294 of file AdaptiveVertexFitter.h.

m_ImpactPoint3dEstimator

ToolHandle<Trk::IImpactPoint3dEstimator> Trk::AdaptiveVertexFitter::m_ImpactPoint3dEstimator

private

Initial value:

{
    this,
    "ImpactPoint3dEstimator",
    "Trk::ImpactPoint3dEstimator/ImpactPoint3dEstimator"
  }

Definition at line 241 of file AdaptiveVertexFitter.h.

                                                                 {
    this,
    "ImpactPoint3dEstimator",
    "Trk::ImpactPoint3dEstimator/ImpactPoint3dEstimator"
  };

m_initialError

double Trk::AdaptiveVertexFitter::m_initialError

private

Initial error in form of diagonal elements of the inverse of the covariance matrix (name is misleading: take the error, square it and initialize the variable with its inverse)

Definition at line 279 of file AdaptiveVertexFitter.h.

m_LinearizedTrackFactory

ToolHandle<Trk::IVertexLinearizedTrackFactory> Trk::AdaptiveVertexFitter::m_LinearizedTrackFactory

private

Initial value:

{
    this,
    "LinearizedTrackFactory",
    "Trk::FullLinearizedTrackFactory"
  }

Definition at line 232 of file AdaptiveVertexFitter.h.

                                                                       {
    this,
    "LinearizedTrackFactory",
    "Trk::FullLinearizedTrackFactory"
  };

m_maxDistToLinPoint

double Trk::AdaptiveVertexFitter::m_maxDistToLinPoint

private

Maximum distance of linearization point of track to actual fitted vertex before needing to relinearize (in mm)

Definition at line 271 of file AdaptiveVertexFitter.h.

m_maxIterations

long int Trk::AdaptiveVertexFitter::m_maxIterations

private

Number of maximum iterations.

Definition at line 264 of file AdaptiveVertexFitter.h.

m_onlyzseed

bool Trk::AdaptiveVertexFitter::m_onlyzseed

private

Variable is true if seeding has to be performed only on the z direction.

In this case, as a guess of the initial position in the transverse plane, the x and y position of the beam spot are used.

Definition at line 287 of file AdaptiveVertexFitter.h.

m_SeedFinder

ToolHandle<Trk::IVertexSeedFinder> Trk::AdaptiveVertexFitter::m_SeedFinder

private

Initial value:

{
    this,
    "SeedFinder",
    "Trk::CrossDistancesSeedFinder"
  }

Definition at line 227 of file AdaptiveVertexFitter.h.

                                               {
    this,
    "SeedFinder",
    "Trk::CrossDistancesSeedFinder"
  };

m_TrackCompatibilityEstimator

ToolHandle<Trk::IVertexTrackCompatibilityEstimator> Trk::AdaptiveVertexFitter::m_TrackCompatibilityEstimator

private

Initial value:

{ this,
                                   "TrackCompatibilityEstimato",
                                   "Trk::Chi2TrackCompatibilityEstimator" }

Definition at line 238 of file AdaptiveVertexFitter.h.

                                 { this,
                                   "TrackCompatibilityEstimato",
                                   "Trk::Chi2TrackCompatibilityEstimator" };

m_VertexSmoother

ToolHandle<Trk::IVertexSmoother> Trk::AdaptiveVertexFitter::m_VertexSmoother

private

Initial value:

{
    this,
    "VertexSmoother",
    "Trk::DummyVertexSmoother"
  }

Definition at line 249 of file AdaptiveVertexFitter.h.

                                                 {
    this,
    "VertexSmoother",
    "Trk::DummyVertexSmoother"
  };

m_VertexUpdator

ToolHandle<Trk::IVertexUpdator> Trk::AdaptiveVertexFitter::m_VertexUpdator

private

Initial value:

{ this,
                                                   "VertexUpdator",
                                                   "Trk::KalmanVertexUpdator" }

Definition at line 246 of file AdaptiveVertexFitter.h.

                                               { this,
                                                   "VertexUpdator",
                                                   "Trk::KalmanVertexUpdator" };

---

The documentation for this class was generated from the following files:

• AdaptiveVertexFitter.h
• AdaptiveVertexFitter.cxx