InDet::InDetAdaptiveMultiSecVtxFinderTool Class Reference

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

                          {

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] + 0.511 * 0.511) + std::sqrt(Pv[1] + 0.511 * 0.511);
        double mGam = eGam * eGam - mnt2;
 
        double prtn2 = 938.27205 * 938.27205;
        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 - 497.614) < 100.)                                 // K short
                || (mGam > 0 && std::sqrt(mGam) < 40.)                        // gamma conversion ;
                || (mLam > 0 && std::abs(std::sqrt(mLam) - 1115.683) < 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:

• InDetAdaptiveMultiSecVtxFinderTool.h
• InDetAdaptiveMultiSecVtxFinderTool.cxx