#include <InDetIterativePriVxFinderTool.h>

Inheritance diagram for InDet::InDetIterativePriVxFinderTool:

Collaboration diagram for InDet::InDetIterativePriVxFinderTool:

Public Member Functions
	InDetIterativePriVxFinderTool (const std::string &t, const std::string &n, const IInterface *p)
	Constructor. More...

virtual	~InDetIterativePriVxFinderTool ()
	Destructor. More...

virtual StatusCode	initialize () override

virtual std::pair< xAOD::VertexContainer , xAOD::VertexAuxContainer >	findVertex (const EventContext &ctx, const TrackCollection *trackTES) const override
	Finding method for Trk::Track collection. More...

virtual std::pair< xAOD::VertexContainer , xAOD::VertexAuxContainer >	findVertex (const EventContext &ctx, const xAOD::TrackParticleContainer *trackParticles) const override
	Finding method for TrackParticle collection. More...

virtual StatusCode	finalize () override

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, V, H > &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::pair< xAOD::VertexContainer , xAOD::VertexAuxContainer >	findVertex (const EventContext &ctx, const std::vector< Trk::ITrackLink * > &trackVector) const

void	removeCompatibleTracks (xAOD::Vertex myxAODVertex, std::vector< const Trk::TrackParameters > &perigeesToFit, std::vector< Trk::ITrackLink * > &seedTracks) const

void	removeAllFrom (std::vector< const Trk::TrackParameters * > &perigeesToFit, std::vector< Trk::ITrackLink * > &seedTracks) const

double	compatibility (const Trk::TrackParameters &measPerigee, const xAOD::Vertex &vertex) const

void	printParameterSettings ()
	Internal method to print the parameters setting. More...

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

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

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

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &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 void	countTracksAndNdf (xAOD::Vertex *myxAODVertex, double &ndf, int &ntracks)

Private Attributes
ToolHandle< Trk::IVertexFitter >	m_iVertexFitter

ToolHandle< InDet::IInDetTrackSelectionTool >	m_trkFilter

ToolHandle< Trk::IVertexSeedFinder >	m_SeedFinder

ToolHandle< Trk::IImpactPoint3dEstimator >	m_ImpactPoint3dEstimator

ToolHandle< Trk::IVertexLinearizedTrackFactory >	m_LinearizedTrackFactory

SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey

BooleanProperty	m_useBeamConstraint {this, "useBeamConstraint", false}

DoubleProperty	m_significanceCutSeeding {this, "significanceCutSeeding", 10.}

DoubleProperty	m_maximumChi2cutForSeeding {this, "maximumChi2cutForSeeding", 36.}

IntegerProperty	m_maxVertices {this, "maxVertices", 25}

BooleanProperty	m_createSplitVertices {this, "createSplitVertices", false}

IntegerProperty	m_splitVerticesTrkInvFraction {this, "splitVerticesTrkInvFraction", 2, "inverse fraction to split tracks (1:N)"}

BooleanProperty	m_reassignTracksAfterFirstFit {this, "reassignTracksAfterFirstFit", false}

BooleanProperty	m_doMaxTracksCut {this, "doMaxTracksCut", false}

UnsignedIntegerProperty	m_maxTracks {this, "MaxTracks", 5000}

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: Giacinto Piacquadio (Freiburg University)

This class provides an implementation for a primary vertex finding tool, which uses the Adaptive Vertex Fitter to reject outliers not belonging to the primary vertex interaction.

Changes:

David Shope david.nosp@m..ric.nosp@m.hard..nosp@m.shop.nosp@m.e@cer.nosp@m.n.ch (2016-04-26)

EDM Migration to xAOD - from Trk::VxCandidate to xAOD::Vertex

findVertex will now always return an xAOD::VertexContainer, even when using a TrackCollection or a TrackParticleBaseCollection as input.

Dave Casper dcasp.nosp@m.er@u.nosp@m.ci.ed.nosp@m.u (2018-03-28) Migrate beam spot service to conditions handle

Definition at line 68 of file InDetIterativePriVxFinderTool.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

◆ InDetIterativePriVxFinderTool()

InDet::InDetIterativePriVxFinderTool::InDetIterativePriVxFinderTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Constructor.

Definition at line 58 of file InDetIterativePriVxFinderTool.cxx.

 {
   if (m_createSplitVertices && m_useBeamConstraint) {
     ATH_MSG_FATAL(" Split vertices cannot be obtained if beam spot constraint "
                   "is true! Change settings...");
     return StatusCode::FAILURE;
   }

◆ ~InDetIterativePriVxFinderTool()

InDet::InDetIterativePriVxFinderTool::~InDetIterativePriVxFinderTool ( )

virtualdefault

Destructor.

Member Function Documentation

◆ compatibility()

double InDet::InDetIterativePriVxFinderTool::compatibility	(	const Trk::TrackParameters &	measPerigee,
		const xAOD::Vertex &	vertex
	)		const

private

Definition at line 824 of file InDetIterativePriVxFinderTool.cxx.

 {
   // remove all perigeesToFit and go on...
  
   std::vector<Trk::ITrackLink*>::iterator seedBegin = seedTracks.begin();
   std::vector<Trk::ITrackLink*>::iterator seedEnd = seedTracks.end();
  

◆ countTracksAndNdf()

void InDet::InDetIterativePriVxFinderTool::countTracksAndNdf	(	xAOD::Vertex *	myxAODVertex,
		double &	ndf,
		int &	ntracks
	)

staticprivate

Definition at line 894 of file InDetIterativePriVxFinderTool.cxx.

                        {
       if ((*tracksIter).weight() > 0.01) {
         ntracks += 1;
       }
     }
   }
 }
  
 void
 InDetIterativePriVxFinderTool::removeCompatibleTracks(
   xAOD::Vertex* myxAODVertex,
   std::vector<const Trk::TrackParameters*>& perigeesToFit,
   std::vector<Trk::ITrackLink*>& seedTracks) const
 {
   // now you have your new vertex with its new tracks
   // now you have to get the compatibility also of all tracks which DIDN'T
   // BELONG to the vertex!
   std::vector<Trk::VxTrackAtVertex>* tracksAtVertex =

◆ declareGaudiProperty() [1/4]

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

◆ declareGaudiProperty() [3/4]

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

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 InDet::InDetIterativePriVxFinderTool::finalize ( )

overridevirtual

Definition at line 809 of file InDetIterativePriVxFinderTool.cxx.

◆ findVertex() [1/3]

std::pair< xAOD::VertexContainer , xAOD::VertexAuxContainer > InDet::InDetIterativePriVxFinderTool::findVertex	(	const EventContext &	ctx,
		const std::vector< Trk::ITrackLink * > &	trackVector
	)		const

private

Definition at line 235 of file InDetIterativePriVxFinderTool.cxx.

                                                               {
     ATH_MSG_WARNING(trackVector.size()
                     << " tracks - exceeds maximum (" << m_maxTracks
                     << "), skipping vertexing and returning only dummy...");
     xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
     theVertexContainer->push_back(
       dummyxAODVertex); // have to add vertex to container here first so it can
                         // use its aux store
     dummyxAODVertex->setPosition(beamSpot->beamVtx().position());
     dummyxAODVertex->setCovariancePosition(
       beamSpot->beamVtx().covariancePosition());
     dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
     dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
     return std::make_pair(theVertexContainer, theVertexAuxContainer);
   }
  
   int iterations = 0;
   unsigned int seedtracknumber = seedTracks.size();
  
   // used to store seed info
   Amg::Vector3D actualVertex;
  
   // prepare iterators for tracks only necessary for seeding
   std::vector<Trk::ITrackLink*>::iterator seedBegin;
   std::vector<Trk::ITrackLink*>::iterator seedEnd;
  
   do {
  
     seedBegin = seedTracks.begin();
     seedEnd = seedTracks.end();
  
     if (seedtracknumber == 0) {
       ATH_MSG_DEBUG(" New iteration. No tracks available after track selection "
                     "for seeding. No finding done.");
       break;
     }
  
     ATH_MSG_DEBUG("ITERATION NUMBER " << iterations);
  
     // now find a new SEED
  
     std::vector<const Trk::TrackParameters*> perigeeList;
     for (std::vector<Trk::ITrackLink*>::iterator seedtrkAtVtxIter = seedBegin;
          seedtrkAtVtxIter != seedEnd;
          ++seedtrkAtVtxIter) {
       perigeeList.push_back((*seedtrkAtVtxIter)->parameters());
     }
  
     xAOD::Vertex theconstraint;
     if (m_useBeamConstraint && beamSpot != nullptr) {
       theconstraint =
         xAOD::Vertex(); // Default constructor creates a private store
       theconstraint.setPosition(beamSpot->beamVtx().position());
       theconstraint.setCovariancePosition(
         beamSpot->beamVtx().covariancePosition());
       theconstraint.setFitQuality(
         beamSpot->beamVtx().fitQuality().chiSquared(),
         beamSpot->beamVtx().fitQuality().doubleNumberDoF());
       actualVertex = m_SeedFinder->findSeed(perigeeList, &theconstraint);
     } else {
       actualVertex = m_SeedFinder->findSeed(perigeeList);
       Amg::MatrixX looseConstraintCovariance(3, 3);
       looseConstraintCovariance.setIdentity();
       looseConstraintCovariance = looseConstraintCovariance * 1e+8;
       theconstraint = xAOD::Vertex();
       theconstraint.setPosition(actualVertex);
       theconstraint.setCovariancePosition(looseConstraintCovariance);
       theconstraint.setFitQuality(0., -3.);
     }
  
     if (msgLvl(MSG::DEBUG)) {
       msg(MSG::DEBUG) << " seed at x: " << actualVertex.x()
                       << " at y: " << actualVertex.y()
                       << " at z: " << actualVertex.z() << endmsg;
     }
  
     if (actualVertex.z() == 0.) {
       break;
     }
  
     // now question (remove tracks which are too far away??? I think so...)
     std::vector<const Trk::TrackParameters*> perigeesToFit;
     std::vector<const Trk::TrackParameters*> perigeesToFitSplitVertex;
  
     int numberOfTracks(perigeeList.size());
  
     std::vector<const Trk::TrackParameters*>::const_iterator perigeeListBegin =
       perigeeList.begin();
     std::vector<const Trk::TrackParameters*>::const_iterator perigeeListEnd =
       perigeeList.end();
  
     int counter = 0;
  
     for (std::vector<const Trk::TrackParameters*>::const_iterator
            perigeeListIter = perigeeListBegin;
          perigeeListIter != perigeeListEnd;
          ++perigeeListIter) {
       if (numberOfTracks <= 2) {
         perigeesToFit.push_back(*perigeeListIter);
         counter += 1;
       } else if (numberOfTracks <= 4 && !m_createSplitVertices) {
         perigeesToFit.push_back(*perigeeListIter);
         counter += 1;
       } else if (numberOfTracks <= 4 * m_splitVerticesTrkInvFraction &&
                  m_createSplitVertices) {
         // few tracks are left, put them into the fit regardless their position!
         if (counter % m_splitVerticesTrkInvFraction == 0) {
           perigeesToFit.push_back(*perigeeListIter);
           counter += 1;
         } else {
           perigeesToFitSplitVertex.push_back(*perigeeListIter);
           counter += 1;
         }
       } else { // check first whether it is not too far away!
         double distance = 0.;
         try {
           std::unique_ptr<Trk::PlaneSurface> mySurface =
             m_ImpactPoint3dEstimator->Estimate3dIP(
               *perigeeListIter, &actualVertex, distance);
         } catch (error::ImpactPoint3dEstimatorProblem err) {
           msg(MSG::WARNING) << " ImpactPoint3dEstimator failed to find minimum "
                                "distance between track and vertex seed: "
                             << err.p << endmsg;
         }
  
         if (distance < 0) {
           msg(MSG::WARNING)
             << " Distance between track and seed vtx is negative: " << distance
             << endmsg;
         }
  
         const Trk::TrackParameters* myPerigee = (*perigeeListIter);
  
         // very approximate error
         double error = 0.;
  
         if (myPerigee && myPerigee->covariance()) {
           error = std::sqrt((*myPerigee->covariance())(Trk::d0, Trk::d0) +
                             (*myPerigee->covariance())(Trk::z0, Trk::z0));
         } // end of the security check
  
         if (error == 0.) {
           msg(MSG::ERROR) << " Error is zero! " << distance << endmsg;
           error = 1.;
         }
  
         if (distance / error < m_significanceCutSeeding) {
           if (counter % m_splitVerticesTrkInvFraction == 0 ||
               !m_createSplitVertices) {
             perigeesToFit.push_back(*perigeeListIter);
             counter += 1;
           } else {
             perigeesToFitSplitVertex.push_back(*perigeeListIter);
             counter += 1;
           }
         }
       }
     }
  
     if (perigeesToFit.empty()) {
       ATH_MSG_DEBUG(" No good seed found. Exiting search for vertices...");
       break;
     }
  
     // now you have perigeeToFit and perigeeToFitSplitVertices
     // AND HERE YOU DO THE FIT
     // to reassign vertices you look ino what is already in myVxCandidate
     // you do it only ONCE!
  
     xAOD::Vertex* myxAODVertex = nullptr;
     xAOD::Vertex* myxAODSplitVertex = nullptr;
  
     if (m_useBeamConstraint && !perigeesToFit.empty()) {
       myxAODVertex = m_iVertexFitter->fit(perigeesToFit, theconstraint);
     } else if (!m_useBeamConstraint && perigeesToFit.size() > 1) {
       myxAODVertex = m_iVertexFitter->fit(perigeesToFit);
     }
     if (m_createSplitVertices && perigeesToFitSplitVertex.size() > 1) {
       myxAODSplitVertex = m_iVertexFitter->fit(perigeesToFitSplitVertex);
     }
  
     double ndf = 0.;
     int ntracks = 0;
     countTracksAndNdf(myxAODVertex, ndf, ntracks);
  
     double ndfSplitVertex = 0.;
     int ntracksSplitVertex = 0;
     countTracksAndNdf(myxAODSplitVertex, ndfSplitVertex, ntracksSplitVertex);
  
     bool goodVertex = myxAODVertex != nullptr &&
                       ((!m_useBeamConstraint && ndf > 0 && ntracks >= 2) ||
                        (m_useBeamConstraint && ndf > 3 && ntracks >= 2));
  
     if (msgLvl(MSG::DEBUG)) {
       msg(MSG::DEBUG) << " xAOD::Vertex is pointer: " << myxAODVertex
                       << " ndf = " << ndf << " ntracks (with weight>0.01) "
                       << ntracks << " beam constraint "
                       << (m_useBeamConstraint ? "yes" : "no") << endmsg;
     }
  
     if (!goodVertex) {
       removeAllFrom(perigeesToFit, seedTracks);
     } else {
       if (m_reassignTracksAfterFirstFit && (!m_createSplitVertices)) {
         // now you HAVE a good vertex
         // but you want to add the tracks which you missed...
  
         int numberOfAddedTracks = 0;
  
         // iterate on remaining vertices and cross-check if tracks need to be
         // attached to new vertex
         xAOD::VertexContainer::iterator vxBegin = theVertexContainer->begin();
         xAOD::VertexContainer::iterator vxEnd = theVertexContainer->end();
  
         for (xAOD::VertexContainer::iterator vxIter = vxBegin; vxIter != vxEnd;
              ++vxIter) {
           // now iterate on tracks at vertex
  
           std::vector<Trk::VxTrackAtVertex>* myVxTracksAtVtx =
             (&(*vxIter)->vxTrackAtVertex());
  
           if (!myVxTracksAtVtx)
             continue;
  
           std::vector<Trk::VxTrackAtVertex>::iterator tracksBegin =
             myVxTracksAtVtx->begin();
           std::vector<Trk::VxTrackAtVertex>::iterator tracksEnd =
             myVxTracksAtVtx->end();
  
           for (std::vector<Trk::VxTrackAtVertex>::iterator tracksIter =
                  tracksBegin;
                tracksIter != tracksEnd;) {
             // only try with tracks which are not too tightly assigned to
             // another vertex
             if ((*tracksIter).weight() > 0.01) {
               ++tracksIter;
               continue;
             }
  
             const Trk::TrackParameters* trackPerigee =
               (*tracksIter).initialPerigee();
  
             if (trackPerigee == nullptr) {
               ATH_MSG_ERROR("Cast to perigee gives null pointer");
               return std::make_pair(theVertexContainer, theVertexAuxContainer);
             }
  
             double chi2_newvtx = compatibility(*trackPerigee, *myxAODVertex);
             double chi2_oldvtx = compatibility(*trackPerigee, *(*vxIter));
  
             bool remove = false;
  
             if (chi2_newvtx < chi2_oldvtx) {
               ATH_MSG_DEBUG(" Found track of old vertex (chi2= "
                             << chi2_oldvtx
                             << ") more compatible to new one (chi2= "
                             << chi2_newvtx << ")");
  
               perigeesToFit.push_back(trackPerigee);
               // but you need to re-add it to the seedTracks too...
  
               bool isFound = false;
  
               std::vector<Trk::ITrackLink*>::iterator origBegin =
                 origTracks.begin();
               std::vector<Trk::ITrackLink*>::iterator origEnd =
                 origTracks.end();
  
               for (std::vector<Trk::ITrackLink*>::iterator origIter = origBegin;
                    origIter != origEnd;
                    ++origIter) {
                 if ((*origIter)->parameters() == trackPerigee) {
                   isFound = true;
                   seedTracks.push_back(*origIter);
                   break;
                 }
               }
               if (!isFound) {
                 ATH_MSG_WARNING(" Cannot find old perigee to re-add back to "
                                 "seed tracks... ");
               }
  
               numberOfAddedTracks += 1;
  
               remove = true;
             }
  
             if (remove) {
               // now you have to delete the track from the old vertex...
               // easy???
               tracksIter = myVxTracksAtVtx->erase(tracksIter);
               tracksBegin = myVxTracksAtVtx->begin();
               tracksEnd = myVxTracksAtVtx->end();
             } else {
               ++tracksIter;
             }
           } // end of iterating on tracks
         }   // end of iterating on already found vertices in event
  
         // now you have to delete the previous xAOD::Vertex, do a new fit, then
         // check if you still have a good vertex
  
         if (numberOfAddedTracks > 0) {
           delete myxAODVertex;
           myxAODVertex = nullptr;
  
           if (m_useBeamConstraint && !perigeesToFit.empty()) {
             myxAODVertex = m_iVertexFitter->fit(perigeesToFit, theconstraint);
           } else if (!m_useBeamConstraint && perigeesToFit.size() > 1) {
             myxAODVertex = m_iVertexFitter->fit(perigeesToFit);
           }
  
           ndf = 0.;
           ntracks = 0;
           countTracksAndNdf(myxAODVertex, ndf, ntracks);
  
           goodVertex = myxAODVertex != nullptr &&
                        ((!m_useBeamConstraint && ndf > 0 && ntracks >= 2) ||
                         (m_useBeamConstraint && ndf > 3 && ntracks >= 2));
  
           ATH_MSG_DEBUG(" Refitted xAODVertex is pointer: "
                         << myxAODVertex << " ndf = " << ndf
                         << " ntracks (with weight>0.01) " << ntracks
                         << " beam constraint "
                         << (m_useBeamConstraint ? "yes" : "no"));
  
           if (!goodVertex) {
             removeAllFrom(perigeesToFit, seedTracks);
             ATH_MSG_DEBUG(" Adding tracks resulted in an invalid vertex. "
                           "Should be rare. ");
           }
         } // end if tracks were added...
       }   // end reassign tracks from previous vertices and refitting if needed
  
       // need to re-ask goodVertex since it can be changed in the mean time
       if (goodVertex) {
         removeCompatibleTracks(myxAODVertex, perigeesToFit, seedTracks);
       }
     } // end else case on if not good Vertex
  
     bool goodSplitVertex = false;
  
     if (m_createSplitVertices) {
       goodSplitVertex = myxAODSplitVertex != nullptr && ndfSplitVertex > 0 &&
                         ntracksSplitVertex >= 2;
  
       ATH_MSG_DEBUG(" xAODSplitVertex is pointer: "
                     << myxAODSplitVertex << " ndf = " << ndfSplitVertex
                     << " ntracks (with weight>0.01) " << ntracksSplitVertex);
  
       if (!goodSplitVertex) {
         removeAllFrom(perigeesToFitSplitVertex, seedTracks);
       } else {
         removeCompatibleTracks(
           myxAODSplitVertex, perigeesToFitSplitVertex, seedTracks);
  
       } // end else if not good Vertex
     }   // end if create split vertices
  
     if (!m_createSplitVertices) {
       if (goodVertex) {
         theVertexContainer->push_back(myxAODVertex);
       } else {
         if (myxAODVertex) {
           delete myxAODVertex;
           myxAODVertex = nullptr;
         }
       }
     } else {
       if (goodVertex) {
         // type does not seem to be set earlier
         myxAODVertex->setVertexType(xAOD::VxType::PriVtx);
         theVertexContainer->push_back(myxAODVertex);
       } else {
         if (myxAODVertex) {
           delete myxAODVertex;
           myxAODVertex = nullptr;
         }
  
         xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
         theVertexContainer->push_back(
           dummyxAODVertex); // have to add vertex to container here first so it
                             // can use its aux store
         dummyxAODVertex->setPosition(beamSpot->beamVtx().position());
         dummyxAODVertex->setCovariancePosition(
           beamSpot->beamVtx().covariancePosition());
         dummyxAODVertex->vxTrackAtVertex() =
           std::vector<Trk::VxTrackAtVertex>();
         dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
       }
       if (goodSplitVertex) {
         // type does not seem to be set earlier
         myxAODSplitVertex->setVertexType(xAOD::VxType::PriVtx);
         theVertexContainer->push_back(myxAODSplitVertex);
       } else {
         if (myxAODSplitVertex) {
           delete myxAODSplitVertex;
           myxAODSplitVertex = nullptr;
         }
  
         xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
         theVertexContainer->push_back(
           dummyxAODVertex); // have to add vertex to container here first so it
                             // can use its aux store
         dummyxAODVertex->setPosition(beamSpot->beamVtx().position());
         dummyxAODVertex->setCovariancePosition(
           beamSpot->beamVtx().covariancePosition());
         dummyxAODVertex->vxTrackAtVertex() =
           std::vector<Trk::VxTrackAtVertex>();
         dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
       }
     }
  
     ++iterations;
   } while (seedTracks.size() > 1 && iterations < m_maxVertices);
  
   if (iterations == m_maxVertices) {
     ATH_MSG_DEBUG("Reached maximum iterations, have "<<iterations<<" vertices");
   }
   else if (iterations > m_maxVertices) {
     ATH_MSG_WARNING("Exceeded maximum iterations, have "<<iterations<<" vertices, m_maxVertices = "<<m_maxVertices);
   }
  
   //---- add dummy vertex at the end
   //------------------------------------------------------//
   //---- if one or more vertices are already there: let dummy have same position
   // as primary vertex
   if (!m_createSplitVertices) {
     if (!theVertexContainer->empty()) {
       xAOD::Vertex* primaryVtx = theVertexContainer->front();
       if (!primaryVtx->vxTrackAtVertex().empty()) {
         primaryVtx->setVertexType((xAOD::VxType::VertexType)Trk::PriVtx);
         xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
         theVertexContainer->push_back(
           dummyxAODVertex); // have to add vertex to container here first so it
                             // can use its aux store
         dummyxAODVertex->setPosition(primaryVtx->position());
         dummyxAODVertex->setCovariancePosition(
           primaryVtx->covariancePosition());
         dummyxAODVertex->vxTrackAtVertex() =
           std::vector<Trk::VxTrackAtVertex>();
         dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
       } else {
         primaryVtx->setVertexType(xAOD::VxType::NoVtx);
       }
     }
     //---- if no vertex is there let dummy be at beam spot
  
     else if (theVertexContainer->empty()) {
       xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
       theVertexContainer->push_back(
         dummyxAODVertex); // have to add vertex to container here first so it
                           // can use its aux store
       dummyxAODVertex->setPosition(beamSpot->beamVtx().position());
       dummyxAODVertex->setCovariancePosition(
         beamSpot->beamVtx().covariancePosition());
       dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
       dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
     }
     // loop over the pile up to set it as pile up (EXCLUDE first and last
     // vertex, do not do that in split mode)
     for (unsigned int i = 0; i < theVertexContainer->size() - 1; i++) {
  
       ATH_MSG_DEBUG(
         " Vtx: " << i << " x= " << (*theVertexContainer)[i]->position().x()
                  << " y= " << (*theVertexContainer)[i]->position().y() << " z= "
                  << (*theVertexContainer)[i]->position().z() << " ntracks= "
                  << (*theVertexContainer)[i]->vxTrackAtVertex().size()
                  << " chi2= " << (*theVertexContainer)[i]->chiSquared()
                  << " ndf = " << (*theVertexContainer)[i]->numberDoF());
       if (i > 0) {
         (*theVertexContainer)[i]->setVertexType(xAOD::VxType::PileUp);
       }
     }
   }
  
   xAOD::VertexContainer::iterator vxBegin = theVertexContainer->begin();
   xAOD::VertexContainer::iterator vxEnd = theVertexContainer->end();
  
   // prepare iterators for tracks only necessary for seeding
   std::vector<Trk::ITrackLink*>::iterator origtrkbegin = origTracks.begin();
   std::vector<Trk::ITrackLink*>::iterator origtrkend = origTracks.end();
  
   for (xAOD::VertexContainer::iterator vxIter = vxBegin; vxIter != vxEnd;
        ++vxIter) {
     std::vector<Trk::VxTrackAtVertex>* myVxTracksAtVtx =
       &((*vxIter)->vxTrackAtVertex());
  
     if (!myVxTracksAtVtx)
       continue;
  
     std::vector<Trk::VxTrackAtVertex>::iterator tracksBegin =
       myVxTracksAtVtx->begin();
     std::vector<Trk::VxTrackAtVertex>::iterator tracksEnd =
       myVxTracksAtVtx->end();
  
     bool found = false;
  
     for (std::vector<Trk::VxTrackAtVertex>::iterator tracksIter = tracksBegin;
          tracksIter != tracksEnd;
          ++tracksIter) {
  
       // now look for corresponding ITrackLink
       for (std::vector<Trk::ITrackLink*>::iterator origtrkiter = origtrkbegin;
            origtrkiter != origtrkend;
            ++origtrkiter) {
         if ((*origtrkiter)->parameters() == (*tracksIter).initialPerigee()) {
           found = true;
  
           // assigning the input track to the fitted vertex through
           // VxTrackAtVertices vector
           (*tracksIter).setOrigTrack(*origtrkiter);
  
           // See if the trklink is to an xAOD::TrackParticle
           Trk::LinkToXAODTrackParticle* linkToXAODTP = nullptr;
           Trk::ITrackLink* tmpLink = (*tracksIter).trackOrParticleLink();
           if (tmpLink->type() == Trk::ITrackLink::ToxAODTrackParticle) {
             linkToXAODTP = static_cast<Trk::LinkToXAODTrackParticle*>(tmpLink);
           }
  
           // If track is an xAOD::TrackParticle, set directly in xAOD::Vertex
           if (linkToXAODTP) {
             (*vxIter)->addTrackAtVertex(*linkToXAODTP, (*tracksIter).weight());
           }
  
           origTracks.erase(origtrkiter);
           origtrkbegin = origTracks.begin();
           origtrkend = origTracks.end();
           break;
         }
       }
       if (!found) {
         ATH_MSG_ERROR(" Cannot find vector element to fix links (step 4)! ");
       }
     } // end iterate on tracks at vtx
   }   // end iterate on vertices
  
   for (std::vector<Trk::ITrackLink*>::iterator origtrkiter = origtrkbegin;
        origtrkiter != origtrkend;
        ++origtrkiter) {
     if ((*origtrkiter) != 0) {
       delete *origtrkiter;
       *origtrkiter = 0;
     }
   }
  
   return std::make_pair(theVertexContainer, theVertexAuxContainer);
 }
  
 StatusCode
 InDetIterativePriVxFinderTool::finalize()
 {
   return StatusCode::SUCCESS;
 }
  
 void
 InDetIterativePriVxFinderTool::printParameterSettings()
 {
   ATH_MSG_DEBUG("VxPrimary initialize(): Parametersettings "

◆ findVertex() [2/3]

std::pair< xAOD::VertexContainer , xAOD::VertexAuxContainer > InDet::InDetIterativePriVxFinderTool::findVertex	(	const EventContext &	ctx,
		const TrackCollection *	trackTES
	)		const

overridevirtual

Finding method for Trk::Track collection.

Implements InDet::IVertexFinder.

Definition at line 130 of file InDetIterativePriVxFinderTool.cxx.

               {
  
     if (m_useBeamConstraint && beamSpot != nullptr) {
       Trk::RecVertex beamPosition{ beamSpot->beamVtx() };
       selectionPassed =
         static_cast<bool>(m_trkFilter->accept(**itr, &beamPosition));
     } else {
       Trk::Vertex null(Amg::Vector3D(0, 0, 0));
       selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &null));
     }
     if (selectionPassed) {
       ElementLink<TrackCollection> link;
       link.setElement(*itr);
       Trk::LinkToTrack* linkTT = new Trk::LinkToTrack(link);
       linkTT->setStorableObject(*trackTES);
       selectedTracks.push_back(linkTT);
     }
   }
  
   ATH_MSG_DEBUG("Of " << trackTES->size() << " tracks " << selectedTracks.size()
                       << " survived the preselection.");
  
   std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
     returnContainers = findVertex(ctx, selectedTracks);
  
   return returnContainers;
 }
  
 std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
 InDetIterativePriVxFinderTool::findVertex(
   const EventContext& ctx,
   const xAOD::TrackParticleContainer* trackParticles) const
 {
   ATH_MSG_DEBUG(" Number of input tracks before track selection: "
                 << trackParticles->size());
  
   SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{ m_beamSpotKey, ctx };
   const InDet::BeamSpotData* beamSpot = *beamSpotHandle;

◆ findVertex() [3/3]

std::pair< xAOD::VertexContainer , xAOD::VertexAuxContainer > InDet::InDetIterativePriVxFinderTool::findVertex	(	const EventContext &	ctx,
		const xAOD::TrackParticleContainer *	trackParticles
	)		const

overridevirtual

Finding method for TrackParticle collection.

Implements InDet::IVertexFinder.

Definition at line 175 of file InDetIterativePriVxFinderTool.cxx.

               {
  
     if (m_useBeamConstraint && beamSpot != nullptr) {
       xAOD::Vertex beamPosition;
       beamPosition.makePrivateStore();
       beamPosition.setPosition(beamSpot->beamVtx().position());
       beamPosition.setCovariancePosition(
         beamSpot->beamVtx().covariancePosition());
       selectionPassed =
         static_cast<bool>(m_trkFilter->accept(**itr, &beamPosition));
     } else {
  
       xAOD::Vertex null;
       null.makePrivateStore();
       null.setPosition(Amg::Vector3D(0, 0, 0));
       AmgSymMatrix(3) vertexError;
       vertexError.setZero();
       null.setCovariancePosition(vertexError);
       selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &null));
     }
  
     if (selectionPassed) {
       ElementLink<xAOD::TrackParticleContainer> link;
       link.setElement(*itr);
       Trk::LinkToXAODTrackParticle* linkTT =
         new Trk::LinkToXAODTrackParticle(link);
       linkTT->setStorableObject(*trackParticles);
       selectedTracks.push_back(linkTT);
     }
   }
  
   ATH_MSG_DEBUG("Of " << trackParticles->size() << " tracks "
                       << selectedTracks.size()
                       << " survived the preselection.");
  
   std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
     returnContainers = findVertex(ctx, selectedTracks);
  
   return returnContainers;
 }
  
 std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
 InDetIterativePriVxFinderTool::findVertex(
   const EventContext& ctx,
   const std::vector<Trk::ITrackLink*>& trackVector) const
 {
   SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{ m_beamSpotKey, ctx };
   const InDet::BeamSpotData* beamSpot = *beamSpotHandle;
   // two things need to be added
   // 1) the seeding mechanism
   // 2) the iterative removal of tracks

◆ initialize()

StatusCode InDet::InDetIterativePriVxFinderTool::initialize ( )

overridevirtual

Definition at line 70 of file InDetIterativePriVxFinderTool.cxx.

                                            {
     ATH_MSG_FATAL("Failed to retrieve tool " << m_SeedFinder);
     return StatusCode::FAILURE;
   }
  
   if (m_LinearizedTrackFactory.retrieve().isFailure()) {
     ATH_MSG_FATAL("Failed to retrieve tool " << m_LinearizedTrackFactory);
     return StatusCode::FAILURE;
   }
  
   if (m_ImpactPoint3dEstimator.retrieve().isFailure()) {
     ATH_MSG_FATAL("Failed to retrieve tool " << m_ImpactPoint3dEstimator);
     return StatusCode::FAILURE;
   }
  
   ATH_CHECK(m_beamSpotKey.initialize());
  
   if (m_trkFilter.retrieve().isFailure()) {
     ATH_MSG_ERROR(" Unable to retrieve " << m_trkFilter);
     return StatusCode::FAILURE;
   }
  
   // since some parameters special to an inherited class this method
   // will be overloaded by the inherited class
   printParameterSettings();
  
   return StatusCode::SUCCESS;
 }
  
 namespace {
 struct xAODVertex_pair
 {
   double first;
   xAOD::Vertex* second;
   xAODVertex_pair(double p1, xAOD::Vertex* p2)
     : first(p1)
     , second(p2)
   {}
   bool operator<(const xAODVertex_pair& other) const

◆ 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& InDet::IVertexFinder::interfaceID ( )

inlinestaticinherited

Definition at line 73 of file IVertexFinder.h.

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

◆ printParameterSettings()

void InDet::InDetIterativePriVxFinderTool::printParameterSettings ( )

private

Internal method to print the parameters setting.

Definition at line 815 of file InDetIterativePriVxFinderTool.cxx.

 {
   Trk::LinearizedTrack* myLinearizedTrack =
     m_LinearizedTrackFactory->linearizedTrack(&measPerigee, vertex.position());
  
   AmgMatrix(2, 2) weightReduced =

◆ removeAllFrom()

void InDet::InDetIterativePriVxFinderTool::removeAllFrom	(	std::vector< const Trk::TrackParameters * > &	perigeesToFit,
		std::vector< Trk::ITrackLink * > &	seedTracks
	)		const

private

Definition at line 854 of file InDetIterativePriVxFinderTool.cxx.

                             {
  
     bool found = false;
  
     for (std::vector<Trk::ITrackLink*>::iterator seedIter = seedTracks.begin();
          seedIter != seedEnd;
          ++seedIter) {
       if ((*seedIter)->parameters() == *perigeesToFitIter) {
         found = true;
         seedTracks.erase(seedIter);
         seedBegin = seedTracks.begin();
         seedEnd = seedTracks.end();
         break;
       }
     }
     if (!found) {
       ATH_MSG_ERROR(
         " Cannot find vector element to delete when removing BAD vertex! ");
     }
   } // for cycle
 }
  
 void
 InDetIterativePriVxFinderTool::countTracksAndNdf(xAOD::Vertex* myxAODVertex,
                                                  double& ndf,
                                                  int& ntracks)
 {
   if (myxAODVertex) {
     ndf = myxAODVertex->numberDoF();
  
     std::vector<Trk::VxTrackAtVertex> myVxTracksAtVtx =
       myxAODVertex->vxTrackAtVertex();

◆ removeCompatibleTracks()

void InDet::InDetIterativePriVxFinderTool::removeCompatibleTracks	(	xAOD::Vertex *	myxAODVertex,
		std::vector< const Trk::TrackParameters * > &	perigeesToFit,
		std::vector< Trk::ITrackLink * > &	seedTracks
	)		const

private

Definition at line 920 of file InDetIterativePriVxFinderTool.cxx.

                              {
  
     bool found = false;
  
     for (std::vector<Trk::ITrackLink*>::iterator seedIter = seedBegin;
          seedIter != seedEnd;
          ++seedIter) {
       if ((*seedIter)->parameters() == (*tracksAtVertexIter).initialPerigee()) {
         found = true;
         if ((*tracksAtVertexIter).weight() > 0.01) {
           seedTracks.erase(seedIter);
           seedBegin = seedTracks.begin();
           seedEnd = seedTracks.end();
         }
         break;
       }
     }
  
     if (!found) {
       ATH_MSG_ERROR(" Cannot find vector element to delete (step 1)! ");
     }
  
     found = false;
     for (std::vector<const Trk::TrackParameters*>::iterator perigeesToFitIter =
            perigeesToFitBegin;
          perigeesToFitIter != perigeesToFitEnd;
          ++perigeesToFitIter) {
       if (*perigeesToFitIter == (*tracksAtVertexIter).initialPerigee()) {
         found = true;
         if ((*tracksAtVertexIter).weight() > 0.01) {
           perigeesToFit.erase(perigeesToFitIter);
           perigeesToFitBegin = perigeesToFit.begin();
           perigeesToFitEnd = perigeesToFit.end();
         }
         break;
       }
     }
  
     if (!found) {
       ATH_MSG_ERROR(" Cannot find vector element to delete (step 2)! ");
     }
   } // finishing iterating on tracks at vertex
  
   std::vector<Trk::VxTrackAtVertex>* myVxTracksAtVertex =
     &(myxAODVertex->vxTrackAtVertex());
  
   std::vector<Trk::VxTrackAtVertex>::iterator tracksBegin =
     myVxTracksAtVertex->begin();
   std::vector<Trk::VxTrackAtVertex>::iterator tracksEnd =
     myVxTracksAtVertex->end();
  
   for (std::vector<const Trk::TrackParameters*>::iterator perigeesToFitIter =
          perigeesToFitBegin;
        perigeesToFitIter != perigeesToFitEnd;
        ++perigeesToFitIter) {
     bool found = false;
  
     // compute the chi2 with respect to the last fitted vertex!
     //(easy since track was NOT used in the last vertex fit...)
  
     const Trk::TrackParameters* myPerigee = (*perigeesToFitIter);
  
     if (myPerigee == nullptr) {
       ATH_MSG_ERROR(" nullptr to perigee ");
       return;
     }
  
     double chi2 = compatibility(*myPerigee, *myxAODVertex);
  
     // check if still sufficiently compatible to previous vertex
     //(CAN BE VERY LOOSE TO BE CONSERVATIVE AGAINST FAR OUTLIERS)
     if (chi2 < m_maximumChi2cutForSeeding) {
       for (std::vector<Trk::ITrackLink*>::iterator seedIter =
              seedTracks.begin();
            seedIter != seedEnd;
            ++seedIter) {
         if ((*seedIter)->parameters() == *perigeesToFitIter) {
           found = true;
           seedTracks.erase(seedIter);
           seedBegin = seedTracks.begin();
           seedEnd = seedTracks.end();
           break;
         }
       }
  
       if (!found) {
         ATH_MSG_ERROR(" Cannot find vector element to delete (step 3)! ");
       }
     } else {
       // look if the track is attached to the vertex. If this is the case you
       // should delete the track from the vertex!
       for (std::vector<Trk::VxTrackAtVertex>::iterator tracksIter = tracksBegin;
            tracksIter != tracksEnd;
            ++tracksIter) {
         if ((*tracksIter).initialPerigee() == *perigeesToFitIter) {
           // delete *tracksIter;
           // delete has to happen BEFORE the erase (because the iterator will
           // point to the next object in the vector AFTER the erase!)
           myVxTracksAtVertex->erase(tracksIter);
           tracksBegin = myVxTracksAtVertex->begin();
           tracksEnd = myVxTracksAtVertex->end();
           found = true;
           break;
         }
       }
     }
   } // iterate on all perigeesToFit
 }
  
 } // end namespace InDet

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

SG::ReadCondHandleKey<InDet::BeamSpotData> InDet::InDetIterativePriVxFinderTool::m_beamSpotKey

private

Initial value:

{
    this,
    "BeamSpotKey",
    "BeamSpotData",
    "SG key for beam spot"
  }

Definition at line 149 of file InDetIterativePriVxFinderTool.h.

◆ m_createSplitVertices

BooleanProperty InDet::InDetIterativePriVxFinderTool::m_createSplitVertices {this, "createSplitVertices", false}

private

Definition at line 163 of file InDetIterativePriVxFinderTool.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_doMaxTracksCut

BooleanProperty InDet::InDetIterativePriVxFinderTool::m_doMaxTracksCut {this, "doMaxTracksCut", false}

private

Definition at line 170 of file InDetIterativePriVxFinderTool.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> InDet::InDetIterativePriVxFinderTool::m_ImpactPoint3dEstimator

private

Initial value:

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

Definition at line 137 of file InDetIterativePriVxFinderTool.h.

◆ m_iVertexFitter

ToolHandle<Trk::IVertexFitter> InDet::InDetIterativePriVxFinderTool::m_iVertexFitter

private

Initial value:

{ this,
                                                  "VertexFitterTool",
                                                  "Trk::AdaptiveVertexFitter" }

Definition at line 125 of file InDetIterativePriVxFinderTool.h.

◆ m_LinearizedTrackFactory

ToolHandle<Trk::IVertexLinearizedTrackFactory> InDet::InDetIterativePriVxFinderTool::m_LinearizedTrackFactory

private

Initial value:

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

Definition at line 143 of file InDetIterativePriVxFinderTool.h.

◆ m_maximumChi2cutForSeeding

DoubleProperty InDet::InDetIterativePriVxFinderTool::m_maximumChi2cutForSeeding {this, "maximumChi2cutForSeeding", 36.}

private

Definition at line 159 of file InDetIterativePriVxFinderTool.h.

◆ m_maxTracks

UnsignedIntegerProperty InDet::InDetIterativePriVxFinderTool::m_maxTracks {this, "MaxTracks", 5000}

private

Definition at line 171 of file InDetIterativePriVxFinderTool.h.

◆ m_maxVertices

IntegerProperty InDet::InDetIterativePriVxFinderTool::m_maxVertices {this, "maxVertices", 25}

private

Definition at line 161 of file InDetIterativePriVxFinderTool.h.

◆ m_reassignTracksAfterFirstFit

BooleanProperty InDet::InDetIterativePriVxFinderTool::m_reassignTracksAfterFirstFit {this, "reassignTracksAfterFirstFit", false}

private

Definition at line 167 of file InDetIterativePriVxFinderTool.h.

◆ m_SeedFinder

ToolHandle<Trk::IVertexSeedFinder> InDet::InDetIterativePriVxFinderTool::m_SeedFinder

private

Initial value:

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

Definition at line 134 of file InDetIterativePriVxFinderTool.h.

◆ m_significanceCutSeeding

DoubleProperty InDet::InDetIterativePriVxFinderTool::m_significanceCutSeeding {this, "significanceCutSeeding", 10.}

private

Definition at line 157 of file InDetIterativePriVxFinderTool.h.

◆ m_splitVerticesTrkInvFraction

IntegerProperty InDet::InDetIterativePriVxFinderTool::m_splitVerticesTrkInvFraction {this, "splitVerticesTrkInvFraction", 2, "inverse fraction to split tracks (1:N)"}

private

Definition at line 164 of file InDetIterativePriVxFinderTool.h.

◆ m_trkFilter

ToolHandle<InDet::IInDetTrackSelectionTool> InDet::InDetIterativePriVxFinderTool::m_trkFilter

private

Initial value:

{
    this,
    "TrackSelector",
    "InDet::InDetTrackSelection"
  }

Definition at line 128 of file InDetIterativePriVxFinderTool.h.

◆ m_useBeamConstraint

BooleanProperty InDet::InDetIterativePriVxFinderTool::m_useBeamConstraint {this, "useBeamConstraint", false}

private

Definition at line 156 of file InDetIterativePriVxFinderTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.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

◆ InDetIterativePriVxFinderTool()

◆ ~InDetIterativePriVxFinderTool()

Member Function Documentation

◆ compatibility()

◆ countTracksAndNdf()

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

◆ findVertex() [1/3]

◆ findVertex() [2/3]

◆ findVertex() [3/3]

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ printParameterSettings()

◆ removeAllFrom()

◆ removeCompatibleTracks()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_beamSpotKey

◆ m_createSplitVertices

◆ m_detStore

◆ m_doMaxTracksCut

◆ m_evtStore

◆ m_ImpactPoint3dEstimator

◆ m_iVertexFitter

◆ m_LinearizedTrackFactory

◆ m_maximumChi2cutForSeeding

◆ m_maxTracks

◆ m_maxVertices

◆ m_reassignTracksAfterFirstFit

◆ m_SeedFinder

◆ m_significanceCutSeeding

◆ m_splitVerticesTrkInvFraction

◆ m_trkFilter

◆ m_useBeamConstraint

◆ m_varHandleArraysDeclared

◆ m_vhka