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

virtual	~AdaptiveMultiVertexFitter ()
	destructor More...

void	fit (std::vector< xAOD::Vertex * > &allVertices) const
	fit all the provided MVFVxCandidate, which have to be already properly initialized. More...

void	addVtxToFit (xAOD::Vertex *pVtx) const
	Adds a new MVFVxCandidate to a previous multi-vertex fit and fits everything together. More...

void	addVtxTofit (xAOD::Vertex *pVtx) const

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) 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 More...

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

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). More...

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). More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

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

Private Attributes
long int	m_maxIterations
	Max number of iterations. More...

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

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) More...

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

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

double	m_maxRelativeShift
	Maximum shift allowed for last iteration... More...

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) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

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):

LinearizedTrackFactory
TrackCompatibilityEstimator 2b. ImpactPoint3dEstimator
VertexUpdator
VertexSmoother plus another one, which is responsible for letting the temperature go down (which implements the so called "annealing technique")
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 27 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::~AdaptiveMultiVertexFitter() = default;

◆ ~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 316 of file AdaptiveMultiVertexFitter.cxx.

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

◆ addVtxTofit()

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

inline

Definition at line 174 of file AdaptiveMultiVertexFitter.h.

174 { 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 283 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;
 }
  
 void

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & 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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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 65 of file AdaptiveMultiVertexFitter.cxx.

◆ 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 396 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 72 of file AdaptiveMultiVertexFitter.cxx.

      {
     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());
       }
     }
   }
 }
  
 std::vector<double>

◆ initialize()

StatusCode Trk::AdaptiveMultiVertexFitter::initialize ( )

Definition at line 50 of file AdaptiveMultiVertexFitter.cxx.

◆ 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()

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

inlinestatic

Definition at line 177 of file AdaptiveMultiVertexFitter.h.

                   {
       return IID_AdaptiveMultiVertexFitter;
     }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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 369 of file AdaptiveMultiVertexFitter.cxx.

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

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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

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

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

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

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

◆ m_VertexUpdator

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

private

Initial value:

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

Definition at line 275 of file AdaptiveMultiVertexFitter.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ AdaptiveMultiVertexFitter()

◆ ~AdaptiveMultiVertexFitter()

Member Function Documentation

◆ addVtxToFit()

◆ addVtxTofit()

◆ collectWeights()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ finalize()

◆ findAmongVertices()

◆ fit()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ prepareCompatibility()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_AnnealingMaker

◆ m_detStore

◆ m_doSmoothing

◆ m_evtStore

◆ m_ImpactPoint3dEstimator

◆ m_initialError

◆ m_LinearizedTrackFactory

◆ m_maxDistToLinPoint

◆ m_maxIterations

◆ m_maxRelativeShift

◆ m_minweight

◆ m_TrackCompatibilityEstimator

◆ m_varHandleArraysDeclared

◆ m_VertexSmoother

◆ m_VertexUpdator

◆ m_vhka