#include <InDetAdaptiveMultiSecVtxFinderTool.h>

Inheritance diagram for InDet::InDetAdaptiveMultiSecVtxFinderTool:

Collaboration diagram for InDet::InDetAdaptiveMultiSecVtxFinderTool:

Public Member Functions
	InDetAdaptiveMultiSecVtxFinderTool (const std::string &t, const std::string &n, const IInterface *p)

virtual	~InDetAdaptiveMultiSecVtxFinderTool ()=default
	Destructor. More...

StatusCode	initialize () override

StatusCode	finalize () override

std::pair< xAOD::VertexContainer , xAOD::VertexAuxContainer >	findVertex (const xAOD::TrackParticleContainer *trackParticles) override

void	setPrimaryVertexPosition (double, double, double) override

Private Member Functions
std::pair< xAOD::VertexContainer , xAOD::VertexAuxContainer >	doVertexing (const std::vector< Trk::ITrackLink * > &trackVector)

float	findCompatibleTracks (Amg::Vector3D &seedVertex, Trk::ITrackLink *trkIter) const

void	countTracksAndNdf (xAOD::Vertex *myxAODVertex, float &ndf, int &ntracks) const

bool	checkFit (xAOD::Vertex *actualCandidate) const

int	removeTracksFromSeeds (xAOD::Vertex actualCandidate, std::vector< Trk::ITrackLink > &seedTracks) const

void	removeClosestTrack (Amg::Vector3D &seedVertex, std::vector< Trk::ITrackLink * > &seedTracks, int &nFound) const

bool	V0check (const std::vector< Amg::Vector3D > &momenta, const Amg::Vector3D &posi) const

const std::vector< Amg::Vector3D >	getVertexMomenta (xAOD::Vertex *myxAODVertex) const

Private Attributes
ToolHandle< Trk::AdaptiveMultiVertexFitter >	m_VertexFitter {this, "VertexFitterTool", "Trk::AdaptiveMultiVertexFitter", "Multi Vertex Fitter"}

ToolHandle< InDet::IInDetTrackSelectionTool >	m_trkFilter {this, "BaseTrackSelector", "InDet::DetailedTrackSelectToolRelax", "Base track selection tool"}

ToolHandle< InDet::IInDetTrackSelectionTool >	m_SVtrkFilter {this, "SecVtxTrackSelector", "InDet::SecVtxTrackSelector", "SV track selection tool"}

ToolHandle< Trk::IVertexSeedFinder >	m_SeedFinder {this, "SeedFinder", "Trk::IndexedCrossDistancesSeedFinder", "Seed finder"}

ToolHandle< Trk::IImpactPoint3dEstimator >	m_ImpactPoint3dEstimator {this, "ImpactPoint3dEstimator", "Trk::ImpactPoint3dEstimator", "Impact point estimator"}

FloatProperty	m_privtxRef {this, "MomentumProjectionOnDirection", -999999.9, "pri vtx ref"}

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

DoubleProperty	m_minWghtAtVtx {this, "minTrackWeightAtVtx", 0., "minTrackWeightAtVtx"}

DoubleProperty	m_maxIterations {this, "maxVertices", 25, "max iterations"}

Amg::Vector3D	m_privtx

Detailed Description

Definition at line 53 of file InDetAdaptiveMultiSecVtxFinderTool.h.

Constructor & Destructor Documentation

◆ InDetAdaptiveMultiSecVtxFinderTool()

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

Definition at line 63 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

◆ ~InDetAdaptiveMultiSecVtxFinderTool()

virtual InDet::InDetAdaptiveMultiSecVtxFinderTool::~InDetAdaptiveMultiSecVtxFinderTool ( )

virtualdefault

Destructor.

Member Function Documentation

◆ checkFit()

bool InDet::InDetAdaptiveMultiSecVtxFinderTool::checkFit ( xAOD::Vertex * actualCandidate ) const

private

Definition at line 489 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

                                               : VTAV(*actualCandidate)) {
             if ((trkAtVtxIter)->weight() > m_minWghtAtVtx) { ntracks += 1; }
         }
  
         ATH_MSG_DEBUG(" xAOD::Vertex : " << (actualCandidate != nullptr ? 1 : 0) << ",  #dof = " << ndf
                                          << ",  #tracks (weight>0.01) = " << ntracks);
  
         return ( ndf > 0 && ntracks >= 2);
     }
  
     int InDetAdaptiveMultiSecVtxFinderTool::removeTracksFromSeeds(xAOD::Vertex* actualCandidate,
                                                                   std::vector<Trk::ITrackLink*>& seedTracks) const {
         if (not actualCandidate) return 0;
         static const xAOD::Vertex::Decorator<std::vector<Trk::VxTrackAtVertex*>> VTAV("VTAV");
  
         std::vector<Trk::ITrackLink*>::iterator seedBegin = seedTracks.begin();

◆ countTracksAndNdf()

void InDet::InDetAdaptiveMultiSecVtxFinderTool::countTracksAndNdf	(	xAOD::Vertex *	myxAODVertex,
		float &	ndf,
		int &	ntracks
	)		const

private

Definition at line 447 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

                                                   : VTAV(*myxAODVertex)) {
                 if ((trkAtVtxIter)->weight() > m_minWghtAtVtx) { ntrk += 1; }
             }
         }
     }
  
     const std::vector<Amg::Vector3D> InDetAdaptiveMultiSecVtxFinderTool::getVertexMomenta(xAOD::Vertex* myxAODVertex) const {
         std::vector<Amg::Vector3D> TrkAtVtxMomenta;
  
         std::vector<Trk::VxTrackAtVertex>* tracksAtVertex = &(myxAODVertex->vxTrackAtVertex());
  
         ATH_MSG_DEBUG(" getVertexMomenta ... #Tracks associated at vertex : " << tracksAtVertex->size());

◆ doVertexing()

std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > InDet::InDetAdaptiveMultiSecVtxFinderTool::doVertexing ( const std::vector< Trk::ITrackLink * > & trackVector )

private

prepare decorators to hold multi vertex fit information

place all tracks in the origTrack vector and initially all in the seedTrack vector

Definition at line 129 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

                                     : origTracks) {
             Trk::TrackToVtxLink* newTrkToVtxLink(new Trk::TrackToVtxLink(new std::vector<xAOD::Vertex*>));
  
             TrackLinkOf[trkIter] = newTrkToVtxLink;
             myTrackToVtxLinks.push_back(newTrkToVtxLink);
         }
  
         int iteration = 0;
         unsigned int seedtracknumber = seedTracks.size();
  
         do {
             if (seedtracknumber == 0) { ATH_MSG_DEBUG("New iteration. No tracks available after track selection for seeding."); }
  
             iteration += 1;
             ATH_MSG_DEBUG("Iteration number " << iteration << " and tracks left for seeding " << seedtracknumber);
  
             std::vector<const Trk::TrackParameters*> perigeeList;
  
             perigeeList.reserve(seedTracks.size());
 for (const Trk::ITrackLink* seedtrkAtVtxIter : seedTracks) { perigeeList.push_back((seedtrkAtVtxIter)->parameters()); }
  
             ATH_MSG_DEBUG("Going to seed finder");
  
             std::unique_ptr<Trk::IMode3dInfo> info;
             Amg::Vector3D seedVertex;
             seedVertex = m_SeedFinder->findSeed(m_privtx.x(), m_privtx.y(), info, perigeeList);
  
             ATH_MSG_DEBUG("Found seed at x: " << seedVertex.x() << " at y: " << seedVertex.y() << " at z: " << seedVertex.z());
  
             xAOD::Vertex* seededxAODVertex = new xAOD::Vertex;
             theVertexContainer->push_back(seededxAODVertex);
             seededxAODVertex->setPosition(seedVertex);
             Amg::MatrixX looseConstraintCovariance(3, 3);
             looseConstraintCovariance.setIdentity();
             looseConstraintCovariance = looseConstraintCovariance * 1e+8;
             seededxAODVertex->setCovariancePosition(looseConstraintCovariance);
             seededxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
             seededxAODVertex->setVertexType(xAOD::VxType::NotSpecified);
  
             if (seedVertex.z() == 0) {
                 ATH_MSG_DEBUG("No good seed found: no further vertices in event");
                 ATH_MSG_DEBUG("Number of input tracks: " << perigeeList.size() << ", but no good seed returned");
                 break;
             }
  
             xAOD::Vertex* constraintVertex = nullptr;
             looseConstraintCovariance.setIdentity();
             looseConstraintCovariance = looseConstraintCovariance * 1e+8;
             constraintVertex = new xAOD::Vertex();
             constraintVertex->makePrivateStore();
             constraintVertex->setPosition(seedVertex);
             constraintVertex->setCovariancePosition(looseConstraintCovariance);
             constraintVertex->setFitQuality(0., -3.);
             constraintVertex->setVertexType(xAOD::VxType::NotSpecified);
  
             xAOD::Vertex* actualCandidate = new xAOD::Vertex;
             actualCandidate->makePrivateStore();
             actualCandidate->setVertexType(xAOD::VxType::NotSpecified);
  
             MvfFitInfo(*actualCandidate) =
                 new Trk::MvfFitInfo(constraintVertex, new Amg::Vector3D(seedVertex), new Amg::Vector3D(seedVertex));
             isInitialized(*actualCandidate) = false;
             std::vector<Trk::VxTrackAtVertex*> vectorOfTracks(0);
             VTAV(*actualCandidate) = vectorOfTracks;
  
             for (Trk::ITrackLink* trkIter : origTracks) {
                 // now fill perigeesToFit list of track parameters from origTracks
                 float doe = findCompatibleTracks(seedVertex, trkIter);
                 if (doe < m_significanceCutSeeding) {
                     Trk::TrackToVtxLink* actualLink = TrackLinkOf[trkIter];
                     std::vector<xAOD::Vertex*>* actualvtxlink = actualLink->vertices();
                     // adding vertex to candidates of track
                     actualvtxlink->push_back(actualCandidate);
                     VTAV(*actualCandidate).push_back(new Trk::MVFVxTrackAtVertex((trkIter)->clone(), actualLink));
                 }
             }
  
             ATH_MSG_DEBUG(" Considering n. " << VTAV(*actualCandidate).size() << " tracks for the fit. ");
             
             if (VTAV(*actualCandidate).size() < 2) {
                 ATH_MSG_DEBUG("No tracks found near seed, while at least two tracks were expected.");
  
                 if (VTAV.isAvailable(*actualCandidate)) {
                     for (auto *tav : VTAV(*actualCandidate)) {
                         if (tav == nullptr) continue;
  
                         (static_cast<Trk::MVFVxTrackAtVertex*>(tav))->setLinkToVertices(nullptr);
                         delete tav;
                         tav = nullptr;
                     }
                     VTAV(*actualCandidate).clear();
                 }
                 if (MvfFitInfo.isAvailable(*actualCandidate) && MvfFitInfo(*actualCandidate) != nullptr) {
                     delete MvfFitInfo(*actualCandidate);
                     MvfFitInfo(*actualCandidate) = nullptr;
                 }
                 delete actualCandidate;
                 actualCandidate = nullptr;
  
                 break;
             }
             
             ATH_MSG_DEBUG("Going to fitter.");
  
             m_VertexFitter->addVtxTofit(actualCandidate);
  
             ATH_MSG_DEBUG("Deleting tracks with really good fit to vertex from seeding tracks.");
             int nFound = removeTracksFromSeeds(actualCandidate, seedTracks);
  
             ATH_MSG_DEBUG("Found and deleted " << nFound << " tracks from seeding tracks.");
             if (nFound == 0) {
                 ATH_MSG_DEBUG("All tracks used for fitting came from fiting tracks, removing closest from seeding.");
                 // all the tracks used for the fit came from fitting track list
                 //-> so remove the closest track to seed from seeding, otherwise you'll keep finding the same seed position
  
                 removeClosestTrack(seedVertex, seedTracks, nFound);
             }
  
             if (nFound == 0) {
                 ATH_MSG_DEBUG("You still have not removed any tracks from seeds! Aborting.");
                 break;
             }
  
             ATH_MSG_DEBUG("Checking goodness of fit.");
             bool goodVertex = checkFit(actualCandidate);
  
             if (!goodVertex) {
                 ATH_MSG_DEBUG("Bad vertex, deleting the vertex and clearing all pointers");
  
                 seededxAODVertex->setVertexType(xAOD::VxType::KinkVtx);
  
                 if (actualCandidate) {
                     if (VTAV.isAvailable(*actualCandidate)) {
                         for (auto *tav : VTAV(*actualCandidate)) {
                             if (tav == nullptr) continue;
  
                             (static_cast<Trk::MVFVxTrackAtVertex*>(tav))->setLinkToVertices(nullptr);
                             delete tav;
                             tav = nullptr;
                         }
                         VTAV(*actualCandidate).clear();
                     }
                     if (MvfFitInfo.isAvailable(*actualCandidate) && MvfFitInfo(*actualCandidate) != nullptr) {
                         delete MvfFitInfo(*actualCandidate);
                         MvfFitInfo(*actualCandidate) = nullptr;
                     }
  
                     delete actualCandidate;
                     actualCandidate = nullptr;
                 }
  
             } else {
                 ATH_MSG_DEBUG("I have found a good vertex!");
  
                 seededxAODVertex->setVertexType(xAOD::VxType::NoVtx);
                 actualCandidate->setVertexType(xAOD::VxType::SecVtx);
                 myxAODVertices.emplace_back(0, actualCandidate);
             }
             seedtracknumber = seedTracks.size();
         } while (seedTracks.size() > 1 && iteration < m_maxIterations);
  
         if (iteration >= m_maxIterations) {
             ATH_MSG_DEBUG("Maximum number of iterations ("
                           << m_maxIterations << ") reached; to reconstruct more vertices, set maxIterations to a higher value.");
         }
  
         ATH_MSG_DEBUG("Secondary vertex finding complete with " << iteration << " iterations and " << myxAODVertices.size()
                                                                 << " vertices found.");
  
         for (const xAODVertex_pair& vtxIter : myxAODVertices) {
             xAOD::Vertex* fittedVert = vtxIter.second;
  
             xAOD::Vertex* cand = new xAOD::Vertex;
             theVertexContainer->push_back(cand);
             cand->setPosition(fittedVert->position());
             cand->setCovariancePosition(fittedVert->covariancePosition());
             cand->setFitQuality(fittedVert->chiSquared(), fittedVert->numberDoF());
             cand->setVertexType(xAOD::VxType::SecVtx);
  
             std::vector<Trk::VxTrackAtVertex>* tracksOfVertex = &(cand->vxTrackAtVertex());
             tracksOfVertex->clear();
  
             for (Trk::VxTrackAtVertex* MVFtrkIter : VTAV(*fittedVert)) {
                 if ((*MVFtrkIter).initialPerigee()) { (*MVFtrkIter).setPerigeeAtVertex(((*MVFtrkIter).initialPerigee())->clone()); }
                 tracksOfVertex->push_back(*MVFtrkIter);
             }
         }
  
         for (const xAODVertex_pair& vtxIter : myxAODVertices) {
             xAOD::Vertex* cand = vtxIter.second;
  
             for (Trk::VxTrackAtVertex* MVFtrkIter : VTAV(*cand)) {
                 (static_cast<Trk::MVFVxTrackAtVertex*>(MVFtrkIter))->setLinkToVertices(nullptr);
                 delete MVFtrkIter;
                 MVFtrkIter = nullptr;
             }
  
             delete MvfFitInfo(*cand);
         }
  
         ATH_MSG_DEBUG("Looping over vertex container");
  
         for (xAOD::Vertex* vxIter : *theVertexContainer) {
             std::vector<Trk::VxTrackAtVertex>* myVxTracksAtVtx = &((vxIter)->vxTrackAtVertex());
             if (!myVxTracksAtVtx) continue;
  
             for (Trk::VxTrackAtVertex& tracksIter : *myVxTracksAtVtx) {
                 Trk::LinkToXAODTrackParticle* linkToXAODTP = nullptr;
                 Trk::ITrackLink* tmpLink = (tracksIter).trackOrParticleLink();
                 if (tmpLink->type() == Trk::ITrackLink::ToxAODTrackParticle) {
                     linkToXAODTP = static_cast<Trk::LinkToXAODTrackParticle*>(tmpLink);
                 }
  
                 if (linkToXAODTP) { (vxIter)->addTrackAtVertex(*linkToXAODTP, (tracksIter).weight()); }
             }
  
             int ntrk = myVxTracksAtVtx->size();
             if (ntrk == 2) {
                 ATH_MSG_DEBUG("Could do a V0 search");
  
                 bool isV0 = V0check(getVertexMomenta(vxIter), (&(*vxIter))->position());
                 if (isV0) {
                     ATH_MSG_DEBUG("Labeling as V0");
                     (vxIter)->setVertexType(xAOD::VxType::V0Vtx);
                 }
             }
         }
  
         // delete all TrackToVtxLink objects
         for (Trk::TrackToVtxLink* iterator : myTrackToVtxLinks) { delete iterator; }
  
         if (!theVertexContainer->empty()) {
             xAOD::Vertex* secVtx = theVertexContainer->front();
             if (!secVtx->vxTrackAtVertex().empty()) {
                 secVtx->setVertexType(xAOD::VxType::SecVtx);
                 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(secVtx->position());
                 dummyxAODVertex->setCovariancePosition(secVtx->covariancePosition());
                 dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
                 dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
             } else {
                 secVtx->setVertexType(xAOD::VxType::NoVtx);
             }
         }
  
         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(Amg::Vector3D(0, 0, 0));
             Amg::MatrixX looseConstraintCovariance(3, 3);
             looseConstraintCovariance.setIdentity();
             looseConstraintCovariance = looseConstraintCovariance * 1e+8;
             dummyxAODVertex->setCovariancePosition(looseConstraintCovariance);
             dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
             dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
         }
  
         int noVtx = 0;
         int kinkVtx = 0;
         int notSpec = 0;
         int secVtx = 0;
         int V0vtx = 0;
         for (unsigned int i = 0; i < theVertexContainer->size(); i++) {
             xAOD::VxType::VertexType vtxType;
             vtxType = static_cast<xAOD::VxType::VertexType>((*theVertexContainer)[i]->vertexType());
             switch (vtxType) {
                 case xAOD::VxType::NoVtx: noVtx++; break;
                 case xAOD::VxType::KinkVtx: kinkVtx++; break;
                 case xAOD::VxType::NotSpecified: notSpec++; break;
                 case xAOD::VxType::V0Vtx: V0vtx++; break;
                 case xAOD::VxType::SecVtx: secVtx++; break;
                 default: ATH_MSG_DEBUG("Unfamiliar vertex type");
             }
  
             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() << " #dof = " << (*theVertexContainer)[i]->numberDoF());
         }
  
         ATH_MSG_DEBUG("Done finding " << theVertexContainer->size() << " vertices and cleaning the container.");
         ATH_MSG_DEBUG("Seeds good/bad/all : " << noVtx << "/" << kinkVtx << "/" << notSpec);
         ATH_MSG_DEBUG("'Good' secondaries : " << secVtx << " and V0: " << V0vtx);
  
         return std::make_pair(theVertexContainer, theVertexAuxContainer);
     }
  
     void InDetAdaptiveMultiSecVtxFinderTool::setPrimaryVertexPosition(double vx, double vy, double vz) {
         m_privtx = Amg::Vector3D(vx, vy, vz);
     }
  
     StatusCode InDetAdaptiveMultiSecVtxFinderTool::finalize() { return StatusCode::SUCCESS; }
  

◆ finalize()

StatusCode InDet::InDetAdaptiveMultiSecVtxFinderTool::finalize ( )

override

Definition at line 445 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

◆ findCompatibleTracks()

float InDet::InDetAdaptiveMultiSecVtxFinderTool::findCompatibleTracks	(	Amg::Vector3D &	seedVertex,
		Trk::ITrackLink *	trkIter
	)		const

private

Definition at line 545 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

                                                          {
             ATH_MSG_DEBUG(" ImpactPoint3dEstimator failed to find minimum distance between track and vertex seed: " << err.p);
         }
  
         if (distance < 0) { ATH_MSG_DEBUG(" Distance between track and seed vtx is negative: " << distance); }
  
         const Trk::TrackParameters* myPerigee = ((trkIter)->parameters());
         double doe = 99999999.9;
         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.) {
             ATH_MSG_ERROR(" Error is zero! " << distance);
             error = 1.;
         }
  
         doe = distance / error;
  
         ATH_MSG_VERBOSE("Distance between track and seed vtx: " << distance << " d/s(d) = " << distance / error << " err " << error);
  
         return doe;
     }
  
     void InDetAdaptiveMultiSecVtxFinderTool::removeClosestTrack(Amg::Vector3D& seedVertex, std::vector<Trk::ITrackLink*>& seedTracks,
                                                                 int& nFound) const {
         const Trk::ITrackLink* nearestTrack = nullptr;
         double dist = 1e8;
  
         for (Trk::ITrackLink* trkIter : seedTracks) {

◆ findVertex()

std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > InDet::InDetAdaptiveMultiSecVtxFinderTool::findVertex ( const xAOD::TrackParticleContainer * trackParticles )

override

Definition at line 88 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

                                           : *trackParticles) {
             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) selectionPassed = static_cast<bool>(m_SVtrkFilter->accept(*itr, &null));
  
             if (selectionPassed) {
                 trackPass(*itr) = true;
  
                 Amg::VectorX par = (itr)->definingParameters();
                 par[0] = (itr)->hitPattern();
  
                 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 = doVertexing(selectedTracks);
  
         return returnContainers;
     }
  
     std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*> 
     InDetAdaptiveMultiSecVtxFinderTool::doVertexing( const std::vector<Trk::ITrackLink*>& trackVector) {
         xAOD::VertexContainer* theVertexContainer = new xAOD::VertexContainer;
         xAOD::VertexAuxContainer* theVertexAuxContainer = new xAOD::VertexAuxContainer;
         theVertexContainer->setStore(theVertexAuxContainer);
  

◆ getVertexMomenta()

const std::vector< Amg::Vector3D > InDet::InDetAdaptiveMultiSecVtxFinderTool::getVertexMomenta ( xAOD::Vertex * myxAODVertex ) const

private

Definition at line 462 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

                                                           : *tracksAtVertex) {
             if ((tracksAtVertexIter).weight() <= m_minWghtAtVtx) continue;
             {
                 const Trk::TrackParameters* sv_perigee = (tracksAtVertexIter).perigeeAtVertex();
                 if (!sv_perigee) {
                     ATH_MSG_DEBUG("perigeeAtVertex not available!!");
                     continue;
                 }
  
                 double qp = 1. / (std::fabs(sv_perigee->parameters()[Trk::qOverP]));
                 double theta = sv_perigee->parameters()[Trk::theta];
                 double phi = sv_perigee->parameters()[Trk::phi];
  
                 TrkAtVtxMomenta.emplace_back(qp * sin(theta) * cos(phi), qp * sin(theta) * sin(phi), qp * cos(theta));
             }
         }
  
         return TrkAtVtxMomenta;
     }
  
     bool InDetAdaptiveMultiSecVtxFinderTool::checkFit(xAOD::Vertex* actualCandidate) const {
         int ntracks = 0;
         if (not actualCandidate) return false;
         float ndf = actualCandidate->numberDoF();
  
         static const xAOD::Vertex::Decorator<std::vector<Trk::VxTrackAtVertex*>> VTAV("VTAV");

◆ initialize()

StatusCode InDet::InDetAdaptiveMultiSecVtxFinderTool::initialize ( )

override

Definition at line 67 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

               {
         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 { return first > other.first; }

◆ removeClosestTrack()

void InDet::InDetAdaptiveMultiSecVtxFinderTool::removeClosestTrack	(	Amg::Vector3D &	seedVertex,
		std::vector< Trk::ITrackLink * > &	seedTracks,
		int &	nFound
	)		const

private

Definition at line 578 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

                 {
                 std::unique_ptr<Trk::PlaneSurface> mySurface =
                     m_ImpactPoint3dEstimator->Estimate3dIP((trkIter)->parameters(), &seedVertex, distance);
             } catch (error::ImpactPoint3dEstimatorProblem err) {
                 ATH_MSG_DEBUG(" ImpactPoint3dEstimator failed to find minimum distance between this track and vertex seed: " << err.p);
             }
             ATH_MSG_DEBUG("Seed to track dist: " << distance);
             if (distance < 0) { ATH_MSG_DEBUG("Distance was negative!"); }
  
             if (distance > 0 && !nearestTrack) {
                 dist = distance;
                 nearestTrack = trkIter;
             }
             if (distance > 0 && distance < dist) {
                 dist = distance;
                 nearestTrack = trkIter;
             }
         }
         if (nearestTrack) {
             ATH_MSG_DEBUG("Found closest track to seed and deleting.");
             std::vector<Trk::ITrackLink*>::iterator seedBegin = seedTracks.begin();
             std::vector<Trk::ITrackLink*>::iterator seedEnd = seedTracks.end();
             nFound += 1;
             std::vector<Trk::ITrackLink*>::iterator foundTrack = std::find(seedBegin, seedEnd, nearestTrack);
             if (foundTrack != seedEnd) {
                 seedTracks.erase(foundTrack);
                 seedBegin = seedTracks.begin();
                 seedEnd = seedTracks.end();
             } else {
                 ATH_MSG_DEBUG("The nearest track was not found!");
             }
         } else {
             ATH_MSG_DEBUG("What else can I try?");
         }
     }
  
     bool InDetAdaptiveMultiSecVtxFinderTool::V0check(const std::vector<Amg::Vector3D>& momenta, const Amg::Vector3D& posi) const {
         int ntrk = momenta.size();
  
         if (ntrk < 2) {
             ATH_MSG_DEBUG(" ntrk < 2 , Meaningless to test mass ");
             return false;

◆ removeTracksFromSeeds()

int InDet::InDetAdaptiveMultiSecVtxFinderTool::removeTracksFromSeeds	(	xAOD::Vertex *	actualCandidate,
		std::vector< Trk::ITrackLink * > &	seedTracks
	)		const

private

Definition at line 506 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

                                               : VTAV(*actualCandidate)) {
             // delete the pointer to this vertex if the vertex was bad
             if (!goodVertex) {
           (static_cast<Trk::MVFVxTrackAtVertex*>(trkAtVtxIter))->linkToVertices()->vertices()->pop_back();
         }
  
             std::vector<Trk::ITrackLink*>::iterator foundTrack = seedEnd;
             for (std::vector<Trk::ITrackLink*>::iterator seedtrkiter = seedBegin; seedtrkiter != seedEnd; ++seedtrkiter) {
                 if ((*seedtrkiter)->parameters() == (trkAtVtxIter)->trackOrParticleLink()->parameters() &&
                     (trkAtVtxIter)->weight() > m_minWghtAtVtx) {
                     foundTrack = seedtrkiter;
                 }
             }
  
             if (foundTrack != seedEnd) {
                 seedTracks.erase(foundTrack);
  
                 nFound += 1;
  
                 seedBegin = seedTracks.begin();
                 seedEnd = seedTracks.end();
             }
         }
  
         return nFound;
     }
  
     float InDetAdaptiveMultiSecVtxFinderTool::findCompatibleTracks(Amg::Vector3D& seedVertex, Trk::ITrackLink* trkIter) const {
         double distance = 0.;
  
         try {
             std::unique_ptr<Trk::PlaneSurface> mySurface =
                 m_ImpactPoint3dEstimator->Estimate3dIP((trkIter)->parameters(), &seedVertex, distance);

◆ setPrimaryVertexPosition()

void InDet::InDetAdaptiveMultiSecVtxFinderTool::setPrimaryVertexPosition	(	double	vx,
		double	vy,
		double	vz
	)

override

Definition at line 441 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

444 {

◆ V0check()

bool InDet::InDetAdaptiveMultiSecVtxFinderTool::V0check	(	const std::vector< Amg::Vector3D > &	momenta,
		const Amg::Vector3D &	posi
	)		const

private

Definition at line 621 of file InDetAdaptiveMultiSecVtxFinderTool.cxx.

                                        {
             Amg::Vector3D trk = momenta[t];
  
             vz += trk.z();
             vx += trk.x();
             vy += trk.y();
             Pv[t] = trk.x() * trk.x() + trk.y() * trk.y() + trk.z() * trk.z();
             eK0 += std::sqrt(Pv[t] + pi2);
         }
  
         double mnt2 = vx * vx + vy * vy + vz * vz;
         double mass = eK0 * eK0 - mnt2;
         mass = 0.001 * (std::sqrt(std::abs(mass)));
  
         Amg::Vector3D vdif = posi - m_privtx;
         Amg::Vector3D vmoment = Amg::Vector3D(vx, vy, vz);
  
         double modir = vmoment.dot(vdif) / std::sqrt(mnt2);
  
         // borrowed from InnerDetector/InDetRecAlgs/InDetV0Finder/InDetV0FinderTool
         double a0z = (vdif + vmoment * vmoment.dot(vdif) / (mnt2 + 0.00001)).z();
         double Rxy = vdif.perp();
  
         ATH_MSG_DEBUG(" V0kine : a0z = " << a0z << " Rxy = " << Rxy << " direction  " << modir);
  
         if (ntrk != 2) {
             ATH_MSG_DEBUG(" ntrk != 2 , Meaningless to test V0 ");
             return false;
         }
  
         if (a0z > 15. || Rxy > 500.) { return false; }
  
         // 1 eV^(-1) of time = hbar / eV = 6.582173*10^(-16) second,  for energy-time in natural unit
         //  double planck = 6.582173 ;
  
         double eGam = std::sqrt(Pv[0] + ParticleConstants::electronMassInMeV * ParticleConstants::electronMassInMeV) + std::sqrt(Pv[1] + ParticleConstants::electronMassInMeV * ParticleConstants::electronMassInMeV);
         double mGam = eGam * eGam - mnt2;
  
         double prtn2 = ParticleConstants::protonMassInMeV * ParticleConstants::protonMassInMeV;
         double eLam = Pv[0] > Pv[1] ? std::sqrt(Pv[0] + prtn2) + std::sqrt(Pv[1] + pi2) : std::sqrt(Pv[0] + pi2) + std::sqrt(Pv[1] + prtn2);
         double mLam = eLam * eLam - mnt2;
  
         ATH_MSG_DEBUG(" V0 masses : " << mass << " " << std::sqrt(std::abs(mGam)) << " " << std::sqrt(std::abs(mLam)));
  
         return ((fabs(mass - ParticleConstants::KZeroMassInMeV) < 100.)                                 // K short
                 || (mGam > 0 && std::sqrt(mGam) < 40.)                        // gamma conversion ;
                 || (mLam > 0 && std::abs(std::sqrt(mLam) - ParticleConstants::lambdaMassInMeV) < 200.)  //  Lambda
         );
     }
  
 }  // end namespace InDet

Member Data Documentation

◆ m_ImpactPoint3dEstimator

ToolHandle<Trk::IImpactPoint3dEstimator> InDet::InDetAdaptiveMultiSecVtxFinderTool::m_ImpactPoint3dEstimator {this, "ImpactPoint3dEstimator", "Trk::ImpactPoint3dEstimator", "Impact point estimator"}

private

Definition at line 95 of file InDetAdaptiveMultiSecVtxFinderTool.h.

◆ m_maxIterations

DoubleProperty InDet::InDetAdaptiveMultiSecVtxFinderTool::m_maxIterations {this, "maxVertices", 25, "max iterations"}

private

Definition at line 101 of file InDetAdaptiveMultiSecVtxFinderTool.h.

◆ m_minWghtAtVtx

DoubleProperty InDet::InDetAdaptiveMultiSecVtxFinderTool::m_minWghtAtVtx {this, "minTrackWeightAtVtx", 0., "minTrackWeightAtVtx"}

private

Definition at line 100 of file InDetAdaptiveMultiSecVtxFinderTool.h.

◆ m_privtx

Amg::Vector3D InDet::InDetAdaptiveMultiSecVtxFinderTool::m_privtx

private

Definition at line 102 of file InDetAdaptiveMultiSecVtxFinderTool.h.

◆ m_privtxRef

FloatProperty InDet::InDetAdaptiveMultiSecVtxFinderTool::m_privtxRef {this, "MomentumProjectionOnDirection", -999999.9, "pri vtx ref"}

private

Definition at line 98 of file InDetAdaptiveMultiSecVtxFinderTool.h.

◆ m_SeedFinder

ToolHandle<Trk::IVertexSeedFinder> InDet::InDetAdaptiveMultiSecVtxFinderTool::m_SeedFinder {this, "SeedFinder", "Trk::IndexedCrossDistancesSeedFinder", "Seed finder"}

private

Definition at line 94 of file InDetAdaptiveMultiSecVtxFinderTool.h.

◆ m_significanceCutSeeding

DoubleProperty InDet::InDetAdaptiveMultiSecVtxFinderTool::m_significanceCutSeeding {this, "significanceCutSeeding", 10, "significanceCutSeeding"}

private

Definition at line 99 of file InDetAdaptiveMultiSecVtxFinderTool.h.

◆ m_SVtrkFilter

ToolHandle<InDet::IInDetTrackSelectionTool> InDet::InDetAdaptiveMultiSecVtxFinderTool::m_SVtrkFilter {this, "SecVtxTrackSelector", "InDet::SecVtxTrackSelector", "SV track selection tool"}

private

Definition at line 92 of file InDetAdaptiveMultiSecVtxFinderTool.h.

◆ m_trkFilter

ToolHandle<InDet::IInDetTrackSelectionTool> InDet::InDetAdaptiveMultiSecVtxFinderTool::m_trkFilter {this, "BaseTrackSelector", "InDet::DetailedTrackSelectToolRelax", "Base track selection tool"}

private

Definition at line 91 of file InDetAdaptiveMultiSecVtxFinderTool.h.

◆ m_VertexFitter

ToolHandle<Trk::AdaptiveMultiVertexFitter> InDet::InDetAdaptiveMultiSecVtxFinderTool::m_VertexFitter {this, "VertexFitterTool", "Trk::AdaptiveMultiVertexFitter", "Multi Vertex Fitter"}

private

Definition at line 90 of file InDetAdaptiveMultiSecVtxFinderTool.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ InDetAdaptiveMultiSecVtxFinderTool()

◆ ~InDetAdaptiveMultiSecVtxFinderTool()

Member Function Documentation

◆ checkFit()

◆ countTracksAndNdf()

◆ doVertexing()

◆ finalize()

◆ findCompatibleTracks()

◆ findVertex()

◆ getVertexMomenta()

◆ initialize()

◆ removeClosestTrack()

◆ removeTracksFromSeeds()

◆ setPrimaryVertexPosition()

◆ V0check()

Member Data Documentation

◆ m_ImpactPoint3dEstimator

◆ m_maxIterations

◆ m_minWghtAtVtx

◆ m_privtx

◆ m_privtxRef

◆ m_SeedFinder

◆ m_significanceCutSeeding

◆ m_SVtrkFilter

◆ m_trkFilter

◆ m_VertexFitter