Trk::AdaptiveMultiVertexFitter Class Reference

#include <AdaptiveMultiVertexFitter.h>

Inheritance diagram for Trk::AdaptiveMultiVertexFitter:

Collaboration diagram for Trk::AdaptiveMultiVertexFitter:

Public Member Functions
StatusCode	initialize ()
StatusCode	finalize ()
	AdaptiveMultiVertexFitter (const std::string &t, const std::string &n, const IInterface *p)
	default constructor due to Athena interface
virtual	~AdaptiveMultiVertexFitter ()
	destructor
void	fit (std::vector< xAOD::Vertex * > &allVertices) const
	fit all the provided MVFVxCandidate, which have to be already properly initialized.
void	addVtxToFit (xAOD::Vertex *pVtx) const
	Adds a new MVFVxCandidate to a previous multi-vertex fit and fits everything together.
void	addVtxTofit (xAOD::Vertex *pVtx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::vector< double >	collectWeights (TrackToVtxLink &tracklink) const
	Internal function to collect the weights of the tracks partecipating to all the possible vertices (needed to renormalize the probability of the track to belong to the vertex under consideration, to be provided to the AnnealingMaker class).
void	prepareCompatibility (xAOD::Vertex *newvertex) const
	Internal function to prepare the compatibility information of all the tracks of the new vertex (an IP3dAtaPlane is added, which makes later the estimation of the compatibilities of the tracks to the vertex for the downweighting faster).
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static bool	findAmongVertices (const xAOD::Vertex *vertex, const std::vector< xAOD::Vertex * > &previousVertices)
	Internal method to find a VxCandidate among a vector of VxCandidates.

Private Attributes
long int	m_maxIterations
	Max number of 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_doSmoothing
	True if smoothing after fit iterations has to be performed: otherwise the Smoother AlgoTool provided to the fitter will be ignored.
double	m_minweight
	Minimum weight a track as to have in order to be considered in the fit of one of the vertices.
double	m_maxRelativeShift
	Maximum shift allowed for last iteration... (in terms of Delta|VecR|/sigma|VecR|)
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
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Author

N. Giacinto Piacquadio (Freiburg ATLAS Group)

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

The multi-vertex version of the fit is more complicate than the single-vertex version and needs the input to be provided in the form of a vector of already initialized MVFVxCandidate objects. Details of the the objects to provide in the fit() and addVtxToFit() functions.

During the multi-vertex fit all the vertices are fit, using the tracks which are contained in their respective vertex candidates. Tracks which are shared among more than one vertex get their weights adjusted dynamically iteration after iteration thanks to a Deterministic Annealing procedure, so that in the end they are dinamically assigned to the vertex they most probably belong to.

As for the single-vertex fitter, for greater modularity the algorithm is divided into 6 modules (AlgTools in Athena):

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

---

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

Also, VxMultiVertex EDM has been migrated to the following:

Trk::MvfFitInfo
constraintVertex now uses xAOD::Vertex seedVertex now uses Amg::Vector3D linearizationVertex now uses Amg::Vector3D

Vertex objects stored using this class are now xAOD::Vertex

Instead of using the MVFVxCandidate class, xAOD::Vertex is employed by decorating it with the multi-vertex information:

bool isInitialized MvfFitInfo* MvfFitInfo std::Vector<VxTrackAtVertex*> VTAV

This last decoration is needed in order to be able to use MVFVxTrackAtVertex objects which have the additional information of xAOD::Vertices associated to the track and (through polymorphism) to still be able to pass them to the KalmanVertexUpdator as VxTracksAtVertex objects.

This is obviously not an ideal implementation and could be avoided if xAOD::Vertex stored a std::vector<VxTrackAtVertex*> instead of a std::vector<VxTrackAtVertex>, but I think it must remain this way until such a time as the xAOD::Vertex EDM is changed.

Definition at line 109 of file AdaptiveMultiVertexFitter.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

AdaptiveMultiVertexFitter()

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

default constructor due to Athena interface

Definition at line 25 of file AdaptiveMultiVertexFitter.cxx.

  : AthAlgTool(t, n, p)
  , m_maxIterations(30)
  , m_maxDistToLinPoint(0.5)
  , m_initialError(0.0001)
  , m_doSmoothing(false)
  , m_minweight(0.001)
  , m_maxRelativeShift(0.01)
{
  declareProperty("MaxIterations", m_maxIterations);
  declareProperty("MaxDistToLinPoint", m_maxDistToLinPoint);
  declareProperty("InitialError", m_initialError);
  declareProperty("DoSmoothing", m_doSmoothing);
  declareProperty("MinWeight", m_minweight);
  declareProperty("MaxRelativeShift", m_maxRelativeShift);
  declareInterface<AdaptiveMultiVertexFitter>(this);
}

~AdaptiveMultiVertexFitter()

Trk::AdaptiveMultiVertexFitter::~AdaptiveMultiVertexFitter ( )

virtualdefault

destructor

Member Function Documentation

addVtxToFit()

void Trk::AdaptiveMultiVertexFitter::addVtxToFit

(

xAOD::Vertex *

pVtx

)

const

Adds a new MVFVxCandidate to a previous multi-vertex fit and fits everything together.

Please note that the new MVFVxCandidate provided has to be properly initialized, which means it has to have already a proper seed vertex, a constraint rec vertex, a list of initialized MVFVxTrackAtVertex, each with a link to the TrackToVtxLink object, which has to be already be updated to contain also a pointer to the MVFVxCandidate among the vertex candidates the track belongs to.

There are three steps:

1) the new vertex is added to the fit (all the tracks get initialized, so that the Plane through their IP point and the seed vertex (IP3dAtAPlane) is created, to be later able to estimate in a fast way the compatibility of the tracks to their respective vertices.

2) all tracks belonging to the new vertex are scanned and all the vertices which shares tracks with the new vertex to be fit are also added to the fit.

3) the multivertex fit is performed with all the involved vertices.

This has the clear advantage that only vertices which are really affected by adding the new vertex are being refitted, improving the overall finding performance.

Definition at line 314 of file AdaptiveMultiVertexFitter.cxx.

{
  ATH_MSG_VERBOSE(" Now entered addVtxToFit ");
  // TODO: put this in a better place
  // Prepare objects holding the decoration of xAOD::Vertex with MVF auxdata
  // For optimization of access speed
  static const xAOD::Vertex::Accessor<std::vector<Trk::VxTrackAtVertex*>> VTAV(
    "VTAV");
 
  if (VTAV(*newvertex).empty()) {
    ATH_MSG_ERROR(
      "The candidate you're adding has no tracks: please fix the problem");
  }
  std::vector<xAOD::Vertex*>
    allVerticesToFit;           // how many vertices do you expect?
  allVerticesToFit.reserve(10); // try 10
  prepareCompatibility(newvertex);
  //
  ATH_MSG_VERBOSE("Iterating on tracks");
  std::vector<xAOD::Vertex*> addedVerticesLastIteration;
  std::vector<xAOD::Vertex*> addedVerticesNewIteration;
  addedVerticesLastIteration.push_back(newvertex);
  do {
    for (const auto& vertexIterator : addedVerticesLastIteration) {
      // now you have to check what are the other vertices which still have to
      // do with your new one
      const auto& vertexTracksAtVertex = VTAV(*vertexIterator);
      for (const auto& thisTrack : vertexTracksAtVertex) {
        const auto& pTheseVertices =
          (static_cast<Trk::MVFVxTrackAtVertex*>(thisTrack))
            ->linkToVertices()
            ->vertices();
        for (const auto& thisVertex : *pTheseVertices) {
          // add the vertex if it's still not there
          if (not findAmongVertices(thisVertex, allVerticesToFit)) {
            allVerticesToFit.push_back(thisVertex);
            if (thisVertex != vertexIterator) {
              addedVerticesNewIteration.push_back(thisVertex);
            }
          }
        }
      } // iterate on tracks at considered vertex
    }   // end iteration on addedVerticesLastIteration
 
    addedVerticesLastIteration = addedVerticesNewIteration;
    addedVerticesNewIteration.clear();
  } while (not addedVerticesLastIteration.empty());
  //
  // now fitting everything together
  fit(allVerticesToFit);
}

addVtxTofit()

void Trk::AdaptiveMultiVertexFitter::addVtxTofit ( xAOD::Vertex * pVtx ) const

inline

Definition at line 174 of file AdaptiveMultiVertexFitter.h.

{ return addVtxToFit(pVtx);}

collectWeights()

std::vector< double > Trk::AdaptiveMultiVertexFitter::collectWeights ( Trk::TrackToVtxLink & tracklink ) const

private

Internal function to collect the weights of the tracks partecipating to all the possible vertices (needed to renormalize the probability of the track to belong to the vertex under consideration, to be provided to the AnnealingMaker class).

The input is the TrackToVtxLink, where the weights are stored.

Definition at line 281 of file AdaptiveMultiVertexFitter.cxx.

{
  ATH_MSG_DEBUG("Collecting weights for tracklink " << &tracklink);
  // TODO: put this in a better place
  // Prepare objects holding the decoration of xAOD::Vertex with MVF auxdata
  // For optimization of access speed
  static const xAOD::Vertex::Accessor<std::vector<Trk::VxTrackAtVertex*>> VTAV(
    "VTAV");
  const auto& theseVertices = *(tracklink.vertices());
  std::vector<double> myvector;
  myvector.reserve(theseVertices.size());
  for (const auto& pThisVertex : theseVertices) {
    // really stupid, now you have still to find the weight value (right track
    // in this vertex) but if you later remove tracks from candidate, you cannot
    // do much better (maybe update on demand...)
    const auto& trackPointersForThisVertex = VTAV(*pThisVertex);
    for (const auto& pThisTrack : trackPointersForThisVertex) {
      if ((static_cast<Trk::MVFVxTrackAtVertex*>(pThisTrack))
            ->linkToVertices() == &tracklink) {
        ATH_MSG_DEBUG("found one weight: it's : "
                      << pThisTrack->vtxCompatibility() << " for track "
                      << pThisTrack);
        myvector.push_back(pThisTrack->vtxCompatibility());
        break; // gain time in avoiding to look for other tracks if you already
               // found the right one
      }
    }
  }
  return myvector;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode Trk::AdaptiveMultiVertexFitter::finalize

(

)

Definition at line 63 of file AdaptiveMultiVertexFitter.cxx.

{
  ATH_MSG_VERBOSE("Finalize successful");
  return StatusCode::SUCCESS;
}

findAmongVertices()

bool Trk::AdaptiveMultiVertexFitter::findAmongVertices ( const xAOD::Vertex * vertex, const std::vector< xAOD::Vertex * > & previousVertices )

staticprivate

Internal method to find a VxCandidate among a vector of VxCandidates.

Returns true if the vertex is found.

Definition at line 394 of file AdaptiveMultiVertexFitter.cxx.

{
  return (std::find(previousVertices.begin(), previousVertices.end(), vertex) !=
          previousVertices.end());
}

fit()

void Trk::AdaptiveMultiVertexFitter::fit

(

std::vector< xAOD::Vertex * > &

allVertices

)

const

fit all the provided MVFVxCandidate, which have to be already properly initialized.

The information about the Vertices to Tracks association is provided in the following way: the MVFVxCandidate contains a list of MVFVxTrackAtVertex, which contain each a TrackToVtxLink class: this class contains the information about all the vertices (MVFVxCandidate objects) the tracks belongs to and is shared among all MVFVxTrackAtVertex which represents the same track at the different vertices.

This has the clear advantage that the equivalent matrix of the assignments between vertices and tracks can be made block diagonal, so that no time is wasted in case of tracks which are clearly incompatible with some of the other vertices.

Definition at line 70 of file AdaptiveMultiVertexFitter.cxx.

{
  // TODO: put this in a better place
  // Prepare objects needed to add MVF auxdata  to the xAOD::Vertex 
  // For optimization of access speed
  static const xAOD::Vertex::Accessor<MvfFitInfo*> MvfFitInfo("MvfFitInfo");
  static const xAOD::Vertex::Accessor<bool> isInitialized("isInitialized");
  static const xAOD::Vertex::Accessor<std::vector<Trk::VxTrackAtVertex*>> VTAV(
    "VTAV");
  ATH_MSG_DEBUG(" Now fitting all vertices ");
  // create a vector of vertices, to store the old position...
  std::map<xAOD::Vertex*, Amg::Vector3D> oldpositions;
  std::map<xAOD::Vertex*, bool> relinearizations;
  // count number of steps
  int num_steps(0);
  // reset the annealing
  Trk::IVertexAnnealingMaker::AnnealingState astate;
  m_AnnealingMaker->reset(astate);
  ATH_MSG_DEBUG("Entering cycle of AdaptiveMultiVertexFitter");
  bool shiftIsSmall(true);
  // now start to iterate
  do {
    for (auto* pThisVertex : allVertices) {
      // now store all the "old positions"; if vertex is added for the first
      // time this corresponds to the seed (at the same time fitted vertex will
      // be updated with the constraint information) check if you need to
      // reestimate compatibility + linearization
      ATH_MSG_DEBUG("Now considering candidate with ptr " << pThisVertex);
      relinearizations[pThisVertex] = false;
      if (isInitialized(*pThisVertex)) {
        ATH_MSG_DEBUG("vertex position z: " << (*pThisVertex).position()[2]);
        oldpositions[pThisVertex] = pThisVertex->position();
      } else {
        isInitialized(*pThisVertex) = true;
        ATH_MSG_DEBUG("Candidate has no position so far: using as old position "
                      "the seedVertex");
        if (MvfFitInfo(*pThisVertex)->seedVertex() ==
            nullptr) { // TODO: Is there a way of checking whether a decoration
                       // exists on an object?
          ATH_MSG_ERROR("Candidate has no seed...CRASHING now!!!");
        }
        oldpositions[pThisVertex] = *(MvfFitInfo(*pThisVertex)->seedVertex());
      }
      if (MvfFitInfo(*pThisVertex)->linearizationVertex() ==
          nullptr) { // TODO: Is there a way of checking whether a decoration
                     // exists on an object?
        ATH_MSG_ERROR(
          " Candidate has no linearization point...CRASHING now!!! ");
      }
      if ((oldpositions[pThisVertex] -
           *MvfFitInfo(*pThisVertex)->linearizationVertex())
            .perp() > m_maxDistToLinPoint) {
        ATH_MSG_DEBUG("Candidate has to be relinearized ");
        relinearizations[pThisVertex] = true;
        prepareCompatibility(pThisVertex);
      }
      ATH_MSG_DEBUG("Setting the Vertex to the initial constraint");
      // reput everything to the constraint level
      pThisVertex->setPosition(
        MvfFitInfo(*pThisVertex)->constraintVertex()->position());
      pThisVertex->setCovariancePosition(
        MvfFitInfo(*pThisVertex)->constraintVertex()->covariancePosition());
      pThisVertex->setFitQuality(
        MvfFitInfo(*pThisVertex)->constraintVertex()->chiSquared(),
        MvfFitInfo(*pThisVertex)->constraintVertex()->numberDoF());
      pThisVertex->setCovariancePosition(
        pThisVertex->covariancePosition() * 1. /
        float(m_AnnealingMaker->getWeight(astate, 1.)));
      ATH_MSG_DEBUG("Running TrackCompatibilityEstimator on each track");
      // prepare the iterators for the tracks
      const auto& theseTrackPointersAtVtx = VTAV(*pThisVertex);
      // iterate and update the vertex with the track information
      for (const auto& pThisTrack : theseTrackPointersAtVtx) {
        ATH_MSG_DEBUG("Adding compatibility info to a track of "
                      << theseTrackPointersAtVtx.size());
        // now recover from cases where the linearization position is !=0, but
        // you added more tracks later on...
        if (not pThisTrack->ImpactPoint3dAtaPlane()) {
          const bool success = m_ImpactPoint3dEstimator->addIP3dAtaPlane(
            *pThisTrack, *MvfFitInfo(*pThisVertex)->linearizationVertex());
          if (!success) {
            ATH_MSG_DEBUG(
              "Adding compatibility to vertex information failed. Newton "
              "distance finder didn't converge...");
          }
        }
        // first -> estimate the compatibility of the track to the vertex
        m_TrackCompatibilityEstimator->estimate(*pThisTrack,
                                                oldpositions[pThisVertex]);
        ATH_MSG_DEBUG("End of compatibility for a track");
      }
    }
    ATH_MSG_DEBUG("Finished first candidates cycle");
    // after having estimated the compatibility of all the vertices, you have to
    // run again on all vertices, to compute the weights
    for (auto* pThisVertex : allVertices) {
      // TODO: crude and quite possibly time consuming, but best solution I
      // could think of...
      //      updated VxTrackAtVertices are stored in VTAV decoration:
      //      so each time a vertex is to be updated with its tracks in this
      //      loop, delete VxTrackAtVertex vector and add correctly updated
      //      VxTrackAtVertex (from VTAV) to the vector just before calling
      //      the vertex updator
      std::vector<Trk::VxTrackAtVertex>* tracksOfVertex =
        &(pThisVertex->vxTrackAtVertex());
      tracksOfVertex->clear();
      // prepare the iterators for the tracks
      const auto& theseTrackPointersAtVtx = VTAV(*pThisVertex);
      ATH_MSG_VERBOSE(
        "Beginning lin&update of vertex with pointer: " << pThisVertex);
      for (const auto& pThisTrack : theseTrackPointersAtVtx) {
        // set the weight according to all other track's weight
        ATH_MSG_DEBUG("Calling collect weight for track " << pThisTrack);
        const std::vector<double>& allweights(
          collectWeights(*(static_cast<Trk::MVFVxTrackAtVertex*>(pThisTrack))
                            ->linkToVertices()));
        ATH_MSG_DEBUG("The vtxcompatibility for the track is: "
                      << pThisTrack->vtxCompatibility());
        pThisTrack->setWeight(m_AnnealingMaker->getWeight(
          astate, pThisTrack->vtxCompatibility(), allweights));
        ATH_MSG_DEBUG("The resulting weight for the track is "
                      << m_AnnealingMaker->getWeight(
                           astate, pThisTrack->vtxCompatibility(), allweights));
        if (pThisTrack->weight() > m_minweight) {
          ATH_MSG_DEBUG("check passed");
          // now take care if linearization has been done at least once
          if (not pThisTrack->linState()) {
            // linearization never done so far: do it now!
            ATH_MSG_VERBOSE("Linearizing track for the first time");
            m_LinearizedTrackFactory->linearize(*pThisTrack,
                                                oldpositions[pThisVertex]);
          } else if (relinearizations[pThisVertex]) {
            ATH_MSG_VERBOSE("Relinearizing track ");
            m_LinearizedTrackFactory->linearize(*pThisTrack,
                                                oldpositions[pThisVertex]);
            MvfFitInfo(*pThisVertex)
              ->setLinearizationVertex(
                new Amg::Vector3D(oldpositions[pThisVertex]));
          }
          // now you can proceed with the update
          ATH_MSG_DEBUG("Update of the track "
                        << pThisTrack << " to the vertex " << pThisVertex);
          // TODO: obviously not ideal that I have to do this
          tracksOfVertex->push_back(*pThisTrack);
          // TODO: add() returns an xAOD::Vertex* - is it really ok to just
          // have this line without *iter = m_VertexUpdator->add() ? Must
          // be...
          m_VertexUpdator->add(*pThisVertex, *pThisTrack);
        }
      } // iterator on tracks
      // show some info about the position
      ATH_MSG_DEBUG("Vertex pointer " << pThisVertex << " New position x: "
                                      << pThisVertex->position().x()
                                      << " y: " << pThisVertex->position().y()
                                      << " z: " << pThisVertex->position().z());
    } // iterator on Vertices
    // call now one more step of annealing
    if (!(m_AnnealingMaker->isEquilibrium(astate))) {
      m_AnnealingMaker->anneal(astate);
    }
    // August 2009: sometimes the fitter has not converged when the annealing
    // has finished iterate on all vertex candidates and check whether they moved
    // significantly from last iteration
    shiftIsSmall = true;
    Amg::Vector3D vrtpos;
    for (const auto& pThisVertex : allVertices) {
      vrtpos[0] = oldpositions[pThisVertex][0] - pThisVertex->position()[0];
      vrtpos[1] = oldpositions[pThisVertex][1] - pThisVertex->position()[1];
      vrtpos[2] = oldpositions[pThisVertex][2] - pThisVertex->position()[2];
      AmgSymMatrix(3) weightMatrixVertex;
      weightMatrixVertex = pThisVertex->covariancePosition().inverse();
      double relativeShift = vrtpos.dot(weightMatrixVertex * vrtpos);
      if (relativeShift > m_maxRelativeShift) {
        shiftIsSmall = false;
        break;
      }
    }
    num_steps += 1;
  } while (num_steps < m_maxIterations &&
           (!(m_AnnealingMaker->isEquilibrium(astate)) || !shiftIsSmall));
 
  if (num_steps >= m_maxIterations) {
    ATH_MSG_DEBUG("Didn't converge fully after " << num_steps);
  }
  ATH_MSG_VERBOSE(
    "In principle the big multivertex fit step is finished now...");
  // TODO: I don't think that I need to fiddle with updating
  // MVFVxTracksAtVertex - vector of VxTrackAtVertex should be available in
  // the usual way now and be enough
  if (m_doSmoothing) {
    auto trackAvailable = [](const xAOD::Vertex* pV) {
      return pV->vxTrackAtVertexAvailable() and
             not(pV->vxTrackAtVertex()).empty();
    };
    for (const auto& pThisVertex : allVertices) {
      if (trackAvailable(pThisVertex)) {
        m_VertexSmoother->smooth(*pThisVertex);
      }
    }
  } else { // TODO: I added this during xAOD migration
    for (auto* pThisVertex : allVertices) {
      const auto& theseTrackPointersAtVtx = VTAV(*pThisVertex);
      for (const auto& pTrack : theseTrackPointersAtVtx) {
        if (pTrack->initialPerigee())
          pTrack->setPerigeeAtVertex((pTrack->initialPerigee())->clone());
      }
    }
  }
}

initialize()

StatusCode Trk::AdaptiveMultiVertexFitter::initialize

(

)

Definition at line 48 of file AdaptiveMultiVertexFitter.cxx.

{
  ATH_CHECK(m_LinearizedTrackFactory.retrieve());
  ATH_CHECK(m_TrackCompatibilityEstimator.retrieve());
  ATH_CHECK(m_ImpactPoint3dEstimator.retrieve());
  ATH_CHECK(m_VertexUpdator.retrieve());
  // loading smoother in case required
  if (m_doSmoothing)
    ATH_CHECK(m_VertexSmoother.retrieve());
  ATH_CHECK(m_AnnealingMaker.retrieve());
  ATH_MSG_VERBOSE("Initialize successful");
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & Trk::AdaptiveMultiVertexFitter::interfaceID ( )

inlinestatic

Definition at line 177 of file AdaptiveMultiVertexFitter.h.

                  {
      return IID_AdaptiveMultiVertexFitter;
    }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

prepareCompatibility()

void Trk::AdaptiveMultiVertexFitter::prepareCompatibility ( xAOD::Vertex * newvertex ) const

private

Internal function to prepare the compatibility information of all the tracks of the new vertex (an IP3dAtaPlane is added, which makes later the estimation of the compatibilities of the tracks to the vertex for the downweighting faster).

Further information in the TrkVertexFitterUtils package (IP3dAtAPlaneFactory class).

Definition at line 367 of file AdaptiveMultiVertexFitter.cxx.

{
  ATH_MSG_VERBOSE("Entered prepareCompatibility() ");
  // TODO: put this in a better place
  // Prepare objects holding the decoration of xAOD::Vertex with MVF auxdata
  // For optimization of access speed
  static const xAOD::Vertex::Accessor<MvfFitInfo*> MvfFitInfo("MvfFitInfo");
  static const xAOD::Vertex::Accessor<std::vector<Trk::VxTrackAtVertex*>> VTAV(
    "VTAV");
  const Amg::Vector3D* seedPoint = MvfFitInfo(*newvertex)->seedVertex();
  ATH_MSG_VERBOSE("Now adding compatibility info to the track");
  // lambda adds impact point and 'ANDs' with previous success result
  auto addImpactPoint = [this, seedPoint](const auto& thisVxTrack) {
    return this->m_ImpactPoint3dEstimator->addIP3dAtaPlane(*thisVxTrack,
                                                           *seedPoint);
  };
  const auto& vertexTracksAtVertex = VTAV(*newvertex);
  // std::reduce might be quicker, if compiler implemented it
  const bool success = std::all_of(
    vertexTracksAtVertex.begin(), vertexTracksAtVertex.end(), addImpactPoint);
  if (not success) {
    ATH_MSG_DEBUG("Adding compatibility to vertex information failed. Newton "
                    "distance finder didn't converge...");
  }
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_AnnealingMaker

ToolHandle<Trk::IVertexAnnealingMaker> Trk::AdaptiveMultiVertexFitter::m_AnnealingMaker

private

Initial value:

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

Definition at line 285 of file AdaptiveMultiVertexFitter.h.

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

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doSmoothing

bool Trk::AdaptiveMultiVertexFitter::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 242 of file AdaptiveMultiVertexFitter.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_ImpactPoint3dEstimator

ToolHandle<Trk::IImpactPoint3dEstimator> Trk::AdaptiveMultiVertexFitter::m_ImpactPoint3dEstimator

private

Initial value:

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

Definition at line 269 of file AdaptiveMultiVertexFitter.h.

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

m_initialError

double Trk::AdaptiveMultiVertexFitter::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 234 of file AdaptiveMultiVertexFitter.h.

m_LinearizedTrackFactory

ToolHandle<Trk::IVertexLinearizedTrackFactory> Trk::AdaptiveMultiVertexFitter::m_LinearizedTrackFactory

private

Initial value:

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

Definition at line 260 of file AdaptiveMultiVertexFitter.h.

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

m_maxDistToLinPoint

double Trk::AdaptiveMultiVertexFitter::m_maxDistToLinPoint

private

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

Definition at line 226 of file AdaptiveMultiVertexFitter.h.

m_maxIterations

long int Trk::AdaptiveMultiVertexFitter::m_maxIterations

private

Max number of iterations.

Definition at line 217 of file AdaptiveMultiVertexFitter.h.

m_maxRelativeShift

double Trk::AdaptiveMultiVertexFitter::m_maxRelativeShift

private

Maximum shift allowed for last iteration... (in terms of Delta|VecR|/sigma|VecR|)

Definition at line 258 of file AdaptiveMultiVertexFitter.h.

m_minweight

double Trk::AdaptiveMultiVertexFitter::m_minweight

private

Minimum weight a track as to have in order to be considered in the fit of one of the vertices.

This should make the fit slightly faster.

Definition at line 250 of file AdaptiveMultiVertexFitter.h.

m_TrackCompatibilityEstimator

ToolHandle<Trk::IVertexTrackCompatibilityEstimator> Trk::AdaptiveMultiVertexFitter::m_TrackCompatibilityEstimator

private

Initial value:

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

Definition at line 266 of file AdaptiveMultiVertexFitter.h.

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

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_VertexSmoother

ToolHandle<Trk::IVertexSmoother> Trk::AdaptiveMultiVertexFitter::m_VertexSmoother

private

Initial value:

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

Definition at line 280 of file AdaptiveMultiVertexFitter.h.

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

m_VertexUpdator

ToolHandle<Trk::IVertexUpdator> Trk::AdaptiveMultiVertexFitter::m_VertexUpdator

private

Initial value:

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

Definition at line 275 of file AdaptiveMultiVertexFitter.h.

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

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• AdaptiveMultiVertexFitter.h
• AdaptiveMultiVertexFitter.cxx