reco::GhostTrackVertexFinder Class Reference

#include <GhostTrackVertexFinder.h>

Classes
struct	FinderInfo

Public Types
enum	FitType { kAlwaysWithGhostTrack, kSingleTracksWithGhostTrack, kRefitGhostTrackWithVertices }

Public Member Functions
	GhostTrackVertexFinder ()
	GhostTrackVertexFinder (double maxFitChi2, double mergeThreshold, double primcut, double seccut, FitType fitType)
std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const GlobalVector &direction, double coneRadius, const std::vector< TransientTrack > &tracks) const
std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const GlobalVector &direction, double coneRadius, const std::vector< TransientTrack > &tracks) const
std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const GlobalVector &direction, double coneRadius, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &tracks) const
std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const GlobalVector &direction, double coneRadius, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &tracks) const
std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const GlobalVector &direction, double coneRadius, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &primaries, const std::vector< TransientTrack > &tracks) const
std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const GlobalVector &direction, double coneRadius, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &primaries, const std::vector< TransientTrack > &tracks) const
std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const reco::Track &ghostTrack, const std::vector< TransientTrack > &tracks, const std::vector< float > &weights=std::vector< float >()) const
std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const reco::Track &ghostTrack, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &tracks, const std::vector< float > &weights=std::vector< float >()) const
std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const reco::Track &ghostTrack, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &primaries, const std::vector< TransientTrack > &tracks, const std::vector< float > &weights=std::vector< float >()) const
std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const GhostTrack &ghostTrack) const
std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const reco::BeamSpot &beamSpot, const GhostTrack &ghostTrack) const
std::vector< TransientVertex >	vertices (const GlobalPoint &primaryPosition, const GlobalError &primaryError, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &primaries, const GhostTrack &ghostTrack) const
std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const GhostTrack &ghostTrack) const
std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const reco::BeamSpot &beamSpot, const GhostTrack &ghostTrack) const
std::vector< TransientVertex >	vertices (const reco::Vertex &primaryVertex, const reco::BeamSpot &beamSpot, const std::vector< TransientTrack > &primaries, const GhostTrack &ghostTrack) const
std::vector< TransientVertex >	vertices (const GhostTrack &ghostTrack, const CachingVertex< 5 > &primary=CachingVertex< 5 >(), const reco::BeamSpot &beamSpot=reco::BeamSpot(), bool hasBeamSpot=false, bool hasPrimaries=false) const
	~GhostTrackVertexFinder ()

Private Member Functions
GhostTrackFitter &	ghostTrackFitter () const
std::vector< CachingVertex< 5 > >	initialVertices (const FinderInfo &info) const
CachingVertex< 5 >	mergeVertices (const CachingVertex< 5 > &vertex1, const CachingVertex< 5 > &vertex2, const FinderInfo &info, bool isPrimary) const
bool	reassignTracks (std::vector< CachingVertex< 5 > > &vertices, const FinderInfo &info) const
bool	recursiveMerge (std::vector< CachingVertex< 5 > > &vertices, const FinderInfo &info) const
void	refitGhostTrack (std::vector< CachingVertex< 5 > > &vertices, FinderInfo &info) const
VertexFitter< 5 > &	vertexFitter (bool primary) const

Static Private Member Functions
static double	vertexCompat (const CachingVertex< 5 > &vtx1, const CachingVertex< 5 > &vtx2, const FinderInfo &info, double scale1=1.0, double scale2=1.0)

Private Attributes
FitType	fitType_
std::unique_ptr< GhostTrackFitter >	ghostTrackFitter_
double	maxFitChi2_
double	mergeThreshold_
double	primcut_
std::unique_ptr< VertexFitter< 5 > >	primVertexFitter_
double	seccut_
std::unique_ptr< VertexFitter< 5 > >	secVertexFitter_

Detailed Description

Definition at line 29 of file GhostTrackVertexFinder.h.

Member Enumeration Documentation

enum reco::GhostTrackVertexFinder::FitType

Enumerator
kAlwaysWithGhostTrack
kSingleTracksWithGhostTrack
kRefitGhostTrackWithVertices

Definition at line 31 of file GhostTrackVertexFinder.h.

                 {
        kAlwaysWithGhostTrack,
        kSingleTracksWithGhostTrack,
        kRefitGhostTrackWithVertices
    };

Constructor & Destructor Documentation

GhostTrackVertexFinder::GhostTrackVertexFinder

(

)

Definition at line 274 of file GhostTrackVertexFinder.cc.

                                               :
    maxFitChi2_(10.0),
    mergeThreshold_(3.0),
    primcut_(2.0),
    seccut_(5.0),
    fitType_(kAlwaysWithGhostTrack)
{
}

GhostTrackVertexFinder::GhostTrackVertexFinder	(	double	maxFitChi2,
		double	mergeThreshold,
		double	primcut,
		double	seccut,
		FitType	fitType
	)

Definition at line 283 of file GhostTrackVertexFinder.cc.

                                        :
    maxFitChi2_(maxFitChi2),
    mergeThreshold_(mergeThreshold),
    primcut_(primcut),
    seccut_(seccut),
    fitType_(fitType)
{
}

GhostTrackVertexFinder::~GhostTrackVertexFinder

(

)

Definition at line 294 of file GhostTrackVertexFinder.cc.

{
}

Member Function Documentation

GhostTrackFitter & GhostTrackVertexFinder::ghostTrackFitter ( ) const

private

Definition at line 298 of file GhostTrackVertexFinder.cc.

References ghostTrackFitter_.

Referenced by vertices().

{
    if (!ghostTrackFitter_.get())
        ghostTrackFitter_.reset(new GhostTrackFitter);

    return *ghostTrackFitter_;
}

std::vector< CachingVertex< 5 > > GhostTrackVertexFinder::initialVertices ( const FinderInfo &  info ) const

private

Definition at line 750 of file GhostTrackVertexFinder.cc.

References reco::GhostTrackVertexFinder::FinderInfo::ghostTrack, reco::GhostTrackState::isValid(), CachingVertex< N >::isValid(), reco::GhostTrackState::linearize(), reco::GhostTrackVertexFinder::FinderInfo::pred, reco::GhostTrackVertexFinder::FinderInfo::states, vertexAtState(), and vertices().

Referenced by vertices().

{
    std::vector<CachingVertex<5> > vertices;
    for(std::vector<GhostTrackState>::const_iterator iter =
            info.states.begin(); iter != info. states.end(); ++iter) {

        if (!iter->isValid())
            continue;

        GhostTrackState state(*iter);
        state.linearize(info.pred);

        if (!state.isValid())
            continue;

        CachingVertex<5> vtx = vertexAtState(info.ghostTrack,
                                             info.pred, state);

        if (vtx.isValid()) // && fitChi2(vtx) < maxFitChi2_)
            vertices.push_back(vtx);
    }

    return vertices;
}

CachingVertex< 5 > GhostTrackVertexFinder::mergeVertices ( const CachingVertex< 5 > &  vertex1, const CachingVertex< 5 > &  vertex2, const FinderInfo &  info, bool  isPrimary  ) const

private

Definition at line 799 of file GhostTrackVertexFinder.cc.

References reco::GhostTrackVertexFinder::FinderInfo::beamSpot, MillePedeFileConverter_cfg::e, VertexState::error(), fitType_, reco::GhostTrackVertexFinder::FinderInfo::ghostTrack, reco::GhostTrackVertexFinder::FinderInfo::hasBeamSpot, CachingVertex< N >::isValid(), kAlwaysWithGhostTrack, mergeTrackHelper(), VertexState::position(), stateMean(), CachingVertex< N >::tracks(), VertexFitter< N >::vertex(), vertexFitter(), CachingVertex< N >::vertexState(), VertexTrackFactory< N >::vertexTrack(), and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by recursiveMerge().

{
    VertexTrackFactory<5> vertexTrackFactory;

    VertexState state = stateMean(vertex1.vertexState(),
                                  vertex2.vertexState());
    std::vector<RefCountedVertexTrack> linTracks;
    VtxTrackIs isGhostTrack(info.ghostTrack);
    RefCountedVertexTrack vtxGhostTrack;

    mergeTrackHelper(vertex1.tracks(), linTracks, state,
                     isGhostTrack, vtxGhostTrack, vertexTrackFactory);
    mergeTrackHelper(vertex2.tracks(), linTracks, state,
                     isGhostTrack, vtxGhostTrack, vertexTrackFactory);

    if (vtxGhostTrack &&
        (fitType_ == kAlwaysWithGhostTrack || linTracks.size() < 2))
        linTracks.push_back(
            vertexTrackFactory.vertexTrack(
                vtxGhostTrack->linearizedTrack(),
                vtxGhostTrack->vertexState()));

    try {
        CachingVertex<5> vtx;
        if (info.hasBeamSpot && isPrimary)
            vtx = vertexFitter(true).vertex(linTracks,
                                        info.beamSpot.position(),
                        info.beamSpot.error());
        else
            vtx = vertexFitter(isPrimary).vertex(linTracks);
        if (vtx.isValid())
            return vtx;
    } catch(const VertexException &e) {
        // fit failed
    }

    return CachingVertex<5>();
}

bool GhostTrackVertexFinder::reassignTracks ( std::vector< CachingVertex< 5 > > &  vertices, const FinderInfo &  info  ) const

private

Definition at line 932 of file GhostTrackVertexFinder.cc.

References reco::GhostTrackVertexFinder::FinderInfo::beamSpot, MillePedeFileConverter_cfg::e, VertexState::error(), fitType_, reco::GhostTrackVertexFinder::FinderInfo::ghostTrack, reco::GhostTrackVertexFinder::FinderInfo::hasBeamSpot, training_settings::idx, CachingVertex< N >::isValid(), kAlwaysWithGhostTrack, reco::GhostTrackPrediction::lambda(), LinearizedTrackStateFactory::linearizedTrackState(), VertexState::position(), TransientVertex::position(), reco::GhostTrackVertexFinder::FinderInfo::pred, primcut_, relinearizeTrack(), relinearizeTracks(), seccut_, funct::sqr(), reco::GhostTrackVertexFinder::FinderInfo::states, std::swap(), HiIsolationCommonParameters_cff::track, reco::TransientTrack::track(), trackVertexCompat(), VertexFitter< N >::vertex(), vertexAtState(), vertexFitter(), VertexTrackFactory< N >::vertexTrack(), vertices(), and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by vertices().

{
    std::vector<std::pair<RefCountedVertexTrack,
                          std::vector<RefCountedVertexTrack> > >
                    trackBundles(vertices_.size());

    VtxTrackIs isGhostTrack(info.ghostTrack);

    bool assignmentChanged = false;
    for(std::vector<CachingVertex<5> >::const_iterator iter =
            vertices_.begin(); iter != vertices_.end(); ++iter) {
        std::vector<RefCountedVertexTrack> vtxTracks = iter->tracks();

        if (vtxTracks.empty()) {
            LinearizedTrackStateFactory linTrackFactory;
            VertexTrackFactory<5> vertexTrackFactory;

            RefCountedLinearizedTrackState linState =
                linTrackFactory.linearizedTrackState(
                    iter->position(), info.ghostTrack);

            trackBundles[iter - vertices_.begin()].first =
                    vertexTrackFactory.vertexTrack(
                        linState, iter->vertexState());
        }

        for(std::vector<RefCountedVertexTrack>::const_iterator track =
            vtxTracks.begin(); track != vtxTracks.end(); ++track) {

            if (isGhostTrack(*track)) {
                trackBundles[iter - vertices_.begin()]
                            .first = *track;
                continue;
            }

            if ((*track)->weight() < 1e-3) {
                trackBundles[iter - vertices_.begin()]
                        .second.push_back(*track);
                continue;
            }

            unsigned int idx = iter - vertices_.begin();
            double best = 1.0e9;
            for(std::vector<CachingVertex<5> >::const_iterator
                        vtx = vertices_.begin();
                vtx != vertices_.end(); ++vtx) {
                if (info.pred.lambda(vtx->position()) <
                    info.pred.lambda(vertices_[0].position()))
                    continue;

                double compat =
                    sqr(trackVertexCompat(*vtx, *track));

                compat /= (vtx == vertices_.begin()) ?
                            primcut_ : seccut_;

                if (compat < best) {
                    best = compat;
                    idx = vtx - vertices_.begin();
                }
            }

            if ((int)idx != iter - vertices_.begin())
                assignmentChanged = true;

            trackBundles[idx].second.push_back(*track);
        }
    }

    if (!assignmentChanged)
        return false;

    VertexTrackFactory<5> vertexTrackFactory;
    std::vector<CachingVertex<5> > vertices;
    vertices.reserve(vertices_.size());

    for(std::vector<CachingVertex<5> >::const_iterator iter =
            vertices_.begin(); iter != vertices_.end(); ++iter) {
        const std::vector<RefCountedVertexTrack> &tracks =
                trackBundles[iter - vertices_.begin()].second;
        if (tracks.empty())
            continue;

        CachingVertex<5> vtx;

        if (tracks.size() == 1) {
            const TransientTrack &track =
                tracks[0]->linearizedTrack()->track();

            int idx = -1;
            for(std::vector<GhostTrackState>::const_iterator iter =
                            info.states.begin();
                iter != info.states.end(); ++iter) {
                if (iter->isTrack() && iter->track() == track) {
                    idx = iter - info.states.begin();
                    break;
                }
            }
            if (idx < 0)
                continue;

            vtx = vertexAtState(info.ghostTrack, info.pred,
                                info.states[idx]);
            if (!vtx.isValid())
                continue;
        } else {
            std::vector<RefCountedVertexTrack> linTracks =
                relinearizeTracks(tracks, iter->vertexState());

            if (fitType_ == kAlwaysWithGhostTrack)
                linTracks.push_back(relinearizeTrack(
                    trackBundles[iter - vertices_.begin()].first,
                    iter->vertexState(), vertexTrackFactory));

            bool primary = iter == vertices_.begin();
            try {
                if (primary && info.hasBeamSpot)
                    vtx = vertexFitter(true).vertex(
                        linTracks,
                        info.beamSpot.position(),
                        info.beamSpot.error());
                else
                    vtx = vertexFitter(primary).vertex(
                                linTracks);
            } catch(const VertexException &e) {
                // fit failed;
            }
            if (!vtx.isValid())
                return false;
        }

        vertices.push_back(vtx);
    };

    std::swap(vertices_, vertices);
    return true;
}

bool GhostTrackVertexFinder::recursiveMerge ( std::vector< CachingVertex< 5 > > &  vertices, const FinderInfo &  info  ) const

private

Definition at line 842 of file GhostTrackVertexFinder.cc.

References fitChi2(), mps_fire::i, CachingVertex< N >::isValid(), SiStripPI::max, maxFitChi2_, mergeThreshold_, mergeVertices(), min(), gen::n, trackingPlots::other, primcut_, seccut_, std::swap(), vertexCompat(), and vertices().

Referenced by vertices().

{
    typedef std::pair<unsigned int, unsigned int> Indices;

    std::multimap<float, Indices> compatMap;
    unsigned int n = vertices.size();
    for(unsigned int i = 0; i < n; i++) {
        const CachingVertex<5> &v1 = vertices[i];
        for(unsigned int j = i + 1; j < n; j++) {
            const CachingVertex<5> &v2 = vertices[j];

            float compat = vertexCompat(v1, v2, info,
                    i == 0 ? primcut_ : seccut_, seccut_);

            if (compat > mergeThreshold_)
                continue;

            compatMap.insert(
                std::make_pair(compat, Indices(i, j)));
        }
    }

    bool changesMade = false;
    bool repeat = true;
    while(repeat) {
        repeat = false;
        for(std::multimap<float, Indices>::const_iterator iter =
            compatMap.begin(); iter != compatMap.end(); ++iter) {
            unsigned int v1 = iter->second.first;
            unsigned int v2 = iter->second.second;

            CachingVertex<5> newVtx =
                mergeVertices(vertices[v1], vertices[v2],
                              info, v1 == 0);
            if (!newVtx.isValid() ||
                (v1 != 0 && fitChi2(newVtx) > maxFitChi2_))
                continue;

            std::swap(vertices[v1], newVtx);
            vertices.erase(vertices.begin() + v2);
            n--;

            std::multimap<float, Indices> newCompatMap;
            for(++iter; iter != compatMap.end(); ++iter) {
                if (iter->second.first == v1 ||
                    iter->second.first == v2 ||
                    iter->second.second == v1 ||
                    iter->second.second == v2)
                    continue;

                Indices indices = iter->second;
                indices.first -= indices.first > v2;
                indices.second -= indices.second > v2;

                newCompatMap.insert(std::make_pair(
                            iter->first, indices));
            }
            std::swap(compatMap, newCompatMap);

            for(unsigned int i = 0; i < n; i++) {
                if (i == v1)
                    continue;

                const CachingVertex<5> &other = vertices[i];
                float compat = vertexCompat(
                        vertices[v1], other, info,
                        v1 == 0 ? primcut_ : seccut_,
                        i == 0 ? primcut_ : seccut_);

                if (compat > mergeThreshold_)
                    continue;

                compatMap.insert(
                    std::make_pair(
                        compat,
                        Indices(std::min(i, v1),
                                std::max(i, v1))));
            }

            changesMade = true;
            repeat = true;
            break;
        }
    }

    return changesMade;
}

void GhostTrackVertexFinder::refitGhostTrack ( std::vector< CachingVertex< 5 > > &  vertices, FinderInfo &  info  ) const

private

Definition at line 1072 of file GhostTrackVertexFinder.cc.

References reco::GhostTrackVertexFinder::FinderInfo::beamSpot, vertices_cff::chi2, MillePedeFileConverter_cfg::e, VertexState::error(), reco::GhostTrackVertexFinder::FinderInfo::field, reco::SequentialGhostTrackFitter::fit(), reco::GhostTrackVertexFinder::FinderInfo::ghostTrack, reco::GhostTrackVertexFinder::FinderInfo::hasBeamSpot, training_settings::idx, CachingVertex< N >::isValid(), LinearizedTrackStateFactory::linearizedTrackState(), ndof, VertexState::position(), reco::GhostTrackVertexFinder::FinderInfo::pred, reco::GhostTrackVertexFinder::FinderInfo::prior, reco::GhostTrackVertexFinder::FinderInfo::states, std::swap(), HiIsolationCommonParameters_cff::track, transientGhostTrack(), groupFilesInBlocks::tt, VertexFitter< N >::vertex(), vertexAtState(), vertexFitter(), VertexTrackFactory< N >::vertexTrack(), vertices(), and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by vertices().

{
    VtxTrackIs isGhostTrack(info.ghostTrack);

    std::vector<GhostTrackState> states;
    std::vector<unsigned int> oldStates;
    oldStates.reserve(info.states.size());

    for(std::vector<CachingVertex<5> >::const_iterator iter =
            vertices.begin(); iter != vertices.end(); ++iter) {
        std::vector<RefCountedVertexTrack> vtxTracks = iter->tracks();

        oldStates.clear();
        for(std::vector<RefCountedVertexTrack>::const_iterator track =
            vtxTracks.begin(); track != vtxTracks.end(); ++track) {

            if (isGhostTrack(*track) || (*track)->weight() < 1e-3)
                continue;

            const TransientTrack &tt =
                    (*track)->linearizedTrack()->track();

            int idx = -1;
            for(std::vector<GhostTrackState>::const_iterator iter =
                            info.states.begin();
                iter != info.states.end(); ++iter) {
                if (iter->isTrack() && iter->track() == tt) {
                    idx = iter - info.states.begin();
                    break;
                }
            }

            if (idx >= 0)
                oldStates.push_back(idx);
        }

        if (oldStates.size() == 1)
            states.push_back(info.states[oldStates[0]]);
        else
            states.push_back(GhostTrackState(iter->vertexState()));
    }

    KalmanGhostTrackUpdater updater;
    SequentialGhostTrackFitter fitter;
    double ndof, chi2;
    info.pred = fitter.fit(updater, info.prior, states, ndof, chi2);
    TransientTrack ghostTrack = transientGhostTrack(info.pred, info.field);

    std::swap(info.states, states);
    states.clear();

    std::vector<CachingVertex<5> > newVertices;
    for(std::vector<CachingVertex<5> >::const_iterator iter =
            vertices.begin(); iter != vertices.end(); ++iter) {
        std::vector<RefCountedVertexTrack> vtxTracks = iter->tracks();

        int idx = -1;
        bool redo = false;
        for(std::vector<RefCountedVertexTrack>::iterator track =
            vtxTracks.begin(); track != vtxTracks.end(); ++track) {

            if (isGhostTrack(*track)) {
                LinearizedTrackStateFactory linTrackFactory;
                VertexTrackFactory<5> vertexTrackFactory;

                *track = vertexTrackFactory.vertexTrack(
                    linTrackFactory.linearizedTrackState(
                        iter->position(), ghostTrack),
                        iter->vertexState());
                redo = true;
                continue;
            }

            const TransientTrack &tt =
                    (*track)->linearizedTrack()->track();

            if (idx >= 0) {
                idx = -1;
                break;
            }

            for(std::vector<GhostTrackState>::const_iterator it =
                            info.states.begin();
                it != info.states.end(); ++it) {
                if (!it->isTrack())
                    continue;

                if (it->track() == tt) {
                    idx = it - info.states.begin();
                    break;
                }
            }
        }

        if (idx >= 0) {
            CachingVertex<5> vtx =
                vertexAtState(ghostTrack, info.pred,
                              info.states[idx]);
            if (vtx.isValid())
                newVertices.push_back(vtx);
        } else if (redo) {
            bool primary = iter == vertices.begin();
            CachingVertex<5> vtx;
            if (primary && info.hasBeamSpot)
                vtx = vertexFitter(true).vertex(
                        vtxTracks,
                        info.beamSpot.position(),
                        info.beamSpot.error());
            else
                vtx = vertexFitter(primary).vertex(vtxTracks);
            if (vtx.isValid())
                newVertices.push_back(vtx);
        } else
            newVertices.push_back(*iter);
    }

    std::swap(newVertices, vertices);
    info.ghostTrack = ghostTrack;
}

double GhostTrackVertexFinder::vertexCompat ( const CachingVertex< 5 > &  vtx1, const CachingVertex< 5 > &  vtx2, const FinderInfo &  info, double  scale1 = 1.0, double  scale2 = 1.0  )

staticprivate

Definition at line 237 of file GhostTrackVertexFinder.cc.

References conv, diffTreeTool::diff, CachingVertex< N >::error(), GlobalErrorBase< T, ErrorWeightType >::matrix(), CachingVertex< N >::position(), and funct::sqr().

Referenced by recursiveMerge().

{
    Vector3 diff = conv(vtx2.position() - vtx1.position());
    Matrix3S cov = scale1 * vtx1.error().matrix() +
                   scale2 * vtx2.error().matrix();

    return sqr(ROOT::Math::Dot(diff, diff)) / ROOT::Math::Similarity(cov, diff);
}

VertexFitter< 5 > & GhostTrackVertexFinder::vertexFitter ( bool  primary ) const

private

Definition at line 306 of file GhostTrackVertexFinder.cc.

References reco::TrackKinematics::add(), FreeTrajectoryState::charge(), gather_cfg::cout, TransientVertex::degreesOfFreedom(), reco::GhostTrackPrediction::direction(), MillePedeFileConverter_cfg::e, cppFunctionSkipper::exception, reco::TransientTrack::initialFreeState(), reco::GhostTrackPrediction::lambda(), FreeTrajectoryState::momentum(), TransientVertex::originalTracks(), TransientVertex::position(), TransientVertex::positionError(), primcut_, primVertexFitter_, reco::GhostTrackPrediction::rho(), reco::GhostTrackPrediction::rho2(), seccut_, secVertexFitter_, mathSSE::sqrt(), TransientVertex::totalChiSquared(), HiIsolationCommonParameters_cff::track, reco::TransientTrack::trackBaseRef(), l1t::tracks, tracks_, reco::TrackKinematics::vectorSum(), badGlobalMuonTaggersAOD_cff::vtx, and vtxErrorLong().

Referenced by mergeVertices(), reassignTracks(), and refitGhostTrack().

{
    std::unique_ptr<VertexFitter<5> > *ptr =
            primary ? &primVertexFitter_ : &secVertexFitter_;
    if (!ptr->get())
        ptr->reset(new AdaptiveVertexFitter(
                    GeometricAnnealing(primary
                        ? primcut_ : seccut_)));

    return **ptr;
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const GlobalVector &	direction,
		double	coneRadius,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 377 of file GhostTrackVertexFinder.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), reco::Vertex::error(), and reco::Vertex::position().

Referenced by initialVertices(), reassignTracks(), recursiveMerge(), refitGhostTrack(), and vertices().

{
    return vertices(RecoVertex::convertPos(primaryVertex.position()),
                    RecoVertex::convertError(primaryVertex.error()),
                    direction, coneRadius, tracks);
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const GlobalVector &	direction,
		double	coneRadius,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 413 of file GhostTrackVertexFinder.cc.

References reco::GhostTrackFitter::fit(), ghostTrackFitter(), reco::GhostTrack::prediction(), mps_fire::result, and vertices().

{
    GhostTrack ghostTrack =
        ghostTrackFitter().fit(primaryPosition, primaryError,
                               direction, coneRadius, tracks);

    CachingVertex<5> primary(primaryPosition, primaryError,
                             std::vector<RefCountedVertexTrack>(), 0.);

    std::vector<TransientVertex> result = vertices(ghostTrack, primary);

#ifdef DEBUG
    for(std::vector<TransientVertex>::const_iterator iter = result.begin();
        iter != result.end(); ++iter)
        debugVertex(*iter, ghostTrack.prediction());
#endif

    return result;
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const GlobalVector &	direction,
		double	coneRadius,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 388 of file GhostTrackVertexFinder.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), reco::Vertex::error(), reco::Vertex::position(), and vertices().

{
    return vertices(RecoVertex::convertPos(primaryVertex.position()),
                    RecoVertex::convertError(primaryVertex.error()),
                    direction, coneRadius, beamSpot, tracks);
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const GlobalVector &	direction,
		double	coneRadius,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 438 of file GhostTrackVertexFinder.cc.

References reco::GhostTrackFitter::fit(), ghostTrackFitter(), reco::GhostTrack::prediction(), mps_fire::result, and vertices().

{
    GhostTrack ghostTrack =
        ghostTrackFitter().fit(primaryPosition, primaryError,
                               direction, coneRadius, tracks);

    CachingVertex<5> primary(primaryPosition, primaryError,
                             std::vector<RefCountedVertexTrack>(), 0.);

    std::vector<TransientVertex> result =
                vertices(ghostTrack, primary, beamSpot, true);

#ifdef DEBUG
    for(std::vector<TransientVertex>::const_iterator iter = result.begin();
        iter != result.end(); ++iter)
        debugVertex(*iter, ghostTrack.prediction());
#endif

    return result;
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const GlobalVector &	direction,
		double	coneRadius,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	primaries,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 400 of file GhostTrackVertexFinder.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), reco::Vertex::error(), reco::Vertex::position(), and vertices().

{
    return vertices(RecoVertex::convertPos(primaryVertex.position()),
                    RecoVertex::convertError(primaryVertex.error()),
                    direction, coneRadius, beamSpot, primaries, tracks);
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const GlobalVector &	direction,
		double	coneRadius,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	primaries,
		const std::vector< TransientTrack > &	tracks
	)		const

Definition at line 465 of file GhostTrackVertexFinder.cc.

References reco::GhostTrackFitter::fit(), ghostTrackFitter(), LinearizedTrackStateFactory::linearizedTrackState(), reco::GhostTrack::prediction(), mps_fire::result, VertexTrackFactory< N >::vertexTrack(), and vertices().

{
    GhostTrack ghostTrack =
        ghostTrackFitter().fit(primaryPosition, primaryError,
                               direction, coneRadius, tracks);

    std::vector<RefCountedVertexTrack> primaryVertexTracks;
    if (!primaries.empty()) {
        LinearizedTrackStateFactory linTrackFactory;
        VertexTrackFactory<5> vertexTrackFactory;

        VertexState state(primaryPosition, primaryError);

        for(std::vector<TransientTrack>::const_iterator iter =
            primaries.begin(); iter != primaries.end(); ++iter) {

            RefCountedLinearizedTrackState linState =
                linTrackFactory.linearizedTrackState(
                        primaryPosition, *iter);

            primaryVertexTracks.push_back(
                    vertexTrackFactory.vertexTrack(
                            linState, state));
        }
    }

    CachingVertex<5> primary(primaryPosition, primaryError,
                             primaryVertexTracks, 0.);

    std::vector<TransientVertex> result =
            vertices(ghostTrack, primary, beamSpot, true, true);

#ifdef DEBUG
    for(std::vector<TransientVertex>::const_iterator iter = result.begin();
        iter != result.end(); ++iter)
        debugVertex(*iter, ghostTrack.prediction());
#endif

    return result;
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const reco::Track &	ghostTrack,
		const std::vector< TransientTrack > &	tracks,
		const std::vector< float > &	weights = std::vector<float>()
	)		const

Definition at line 636 of file GhostTrackVertexFinder.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), dummyPrediction(), reco::Vertex::error(), reco::Vertex::position(), reco::GhostTrack::prediction(), mps_fire::result, and vertices().

{
    GhostTrack ghostTrack_(ghostTrack, tracks, weights,
                           dummyPrediction(primaryVertex, ghostTrack),
                           RecoVertex::convertPos(
                                    primaryVertex.position()),
                           true);

    CachingVertex<5> primary(
            RecoVertex::convertPos(primaryVertex.position()),
                    RecoVertex::convertError(primaryVertex.error()),
            std::vector<RefCountedVertexTrack>(), 0.);

    std::vector<TransientVertex> result = vertices(ghostTrack_, primary);

#ifdef DEBUG
    for(std::vector<TransientVertex>::const_iterator iter = result.begin();
        iter != result.end(); ++iter)
        debugVertex(*iter, ghostTrack_.prediction());
#endif

    return result;
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const reco::Track &	ghostTrack,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	tracks,
		const std::vector< float > &	weights = std::vector<float>()
	)		const

Definition at line 664 of file GhostTrackVertexFinder.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), dummyPrediction(), reco::Vertex::error(), reco::Vertex::position(), reco::GhostTrack::prediction(), mps_fire::result, and vertices().

{
    GhostTrack ghostTrack_(ghostTrack, tracks, weights,
                           dummyPrediction(primaryVertex, ghostTrack),
                           RecoVertex::convertPos(primaryVertex.position()),
                           true);

    CachingVertex<5> primary(
            RecoVertex::convertPos(primaryVertex.position()),
                    RecoVertex::convertError(primaryVertex.error()),
            std::vector<RefCountedVertexTrack>(), 0.);

    std::vector<TransientVertex> result =
            vertices(ghostTrack_, primary, beamSpot, true);

#ifdef DEBUG
    for(std::vector<TransientVertex>::const_iterator iter = result.begin();
        iter != result.end(); ++iter)
        debugVertex(*iter, ghostTrack_.prediction());
#endif

    return result;
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const reco::Track &	ghostTrack,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	primaries,
		const std::vector< TransientTrack > &	tracks,
		const std::vector< float > &	weights = std::vector<float>()
	)		const

Definition at line 693 of file GhostTrackVertexFinder.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), dummyPrediction(), reco::Vertex::error(), LinearizedTrackStateFactory::linearizedTrackState(), VertexState::position(), reco::Vertex::position(), reco::GhostTrack::prediction(), mps_fire::result, VertexTrackFactory< N >::vertexTrack(), and vertices().

{
    GhostTrack ghostTrack_(ghostTrack, tracks, weights,
                           dummyPrediction(primaryVertex, ghostTrack),
                           RecoVertex::convertPos(primaryVertex.position()),
                           true);

    std::vector<RefCountedVertexTrack> primaryVertexTracks;
    if (!primaries.empty()) {
        LinearizedTrackStateFactory linTrackFactory;
        VertexTrackFactory<5> vertexTrackFactory;

        VertexState state(
                RecoVertex::convertPos(primaryVertex.position()),
                    RecoVertex::convertError(primaryVertex.error()));

        for(std::vector<TransientTrack>::const_iterator iter =
            primaries.begin(); iter != primaries.end(); ++iter) {

            RefCountedLinearizedTrackState linState =
                linTrackFactory.linearizedTrackState(
                        state.position(), *iter);

            primaryVertexTracks.push_back(
                    vertexTrackFactory.vertexTrack(
                            linState, state));
        }
    }

    CachingVertex<5> primary(
            RecoVertex::convertPos(primaryVertex.position()),
                    RecoVertex::convertError(primaryVertex.error()),
            primaryVertexTracks, 0.);

    std::vector<TransientVertex> result =
            vertices(ghostTrack_, primary, beamSpot, true, true);

#ifdef DEBUG
    for(std::vector<TransientVertex>::const_iterator iter = result.begin();
        iter != result.end(); ++iter)
        debugVertex(*iter, ghostTrack_.prediction());
#endif

    return result;
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 513 of file GhostTrackVertexFinder.cc.

References reco::GhostTrack::prediction(), mps_fire::result, and vertices().

{
    CachingVertex<5> primary(primaryPosition, primaryError,
                             std::vector<RefCountedVertexTrack>(), 0.);

    std::vector<TransientVertex> result = vertices(ghostTrack, primary);

#ifdef DEBUG
    for(std::vector<TransientVertex>::const_iterator iter = result.begin();
        iter != result.end(); ++iter)
        debugVertex(*iter, ghostTrack.prediction());
#endif

    return result;
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const reco::BeamSpot &	beamSpot,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 533 of file GhostTrackVertexFinder.cc.

References reco::GhostTrack::prediction(), mps_fire::result, and vertices().

{
    CachingVertex<5> primary(primaryPosition, primaryError,
                             std::vector<RefCountedVertexTrack>(), 0.);

    std::vector<TransientVertex> result =
                vertices(ghostTrack, primary, beamSpot, true);

#ifdef DEBUG
    for(std::vector<TransientVertex>::const_iterator iter = result.begin();
        iter != result.end(); ++iter)
        debugVertex(*iter, ghostTrack.prediction());
#endif

    return result;
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GlobalPoint &	primaryPosition,
		const GlobalError &	primaryError,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	primaries,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 554 of file GhostTrackVertexFinder.cc.

References LinearizedTrackStateFactory::linearizedTrackState(), reco::GhostTrack::prediction(), mps_fire::result, VertexTrackFactory< N >::vertexTrack(), and vertices().

{
    std::vector<RefCountedVertexTrack> primaryVertexTracks;
    if (!primaries.empty()) {
        LinearizedTrackStateFactory linTrackFactory;
        VertexTrackFactory<5> vertexTrackFactory;

        VertexState state(primaryPosition, primaryError);

        for(std::vector<TransientTrack>::const_iterator iter =
            primaries.begin(); iter != primaries.end(); ++iter) {

            RefCountedLinearizedTrackState linState =
                linTrackFactory.linearizedTrackState(
                        primaryPosition, *iter);

            primaryVertexTracks.push_back(
                    vertexTrackFactory.vertexTrack(
                            linState, state));
        }
    }

    CachingVertex<5> primary(primaryPosition, primaryError,
                             primaryVertexTracks, 0.);

    std::vector<TransientVertex> result =
            vertices(ghostTrack, primary, beamSpot, true, true);

#ifdef DEBUG
    for(std::vector<TransientVertex>::const_iterator iter = result.begin();
        iter != result.end(); ++iter)
        debugVertex(*iter, ghostTrack.prediction());
#endif

    return result;
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 596 of file GhostTrackVertexFinder.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), reco::Vertex::error(), reco::Vertex::position(), and vertices().

{
    return vertices(RecoVertex::convertPos(primaryVertex.position()),
                    RecoVertex::convertError(primaryVertex.error()),
                    ghostTrack);
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const reco::BeamSpot &	beamSpot,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 605 of file GhostTrackVertexFinder.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), reco::Vertex::error(), reco::Vertex::position(), and vertices().

{
    return vertices(RecoVertex::convertPos(primaryVertex.position()),
                    RecoVertex::convertError(primaryVertex.error()),
                    beamSpot, ghostTrack);
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const reco::Vertex &	primaryVertex,
		const reco::BeamSpot &	beamSpot,
		const std::vector< TransientTrack > &	primaries,
		const GhostTrack &	ghostTrack
	)		const

Definition at line 615 of file GhostTrackVertexFinder.cc.

References RecoVertex::convertError(), RecoVertex::convertPos(), reco::Vertex::error(), reco::Vertex::position(), and vertices().

{
    return vertices(RecoVertex::convertPos(primaryVertex.position()),
                    RecoVertex::convertError(primaryVertex.error()),
                    beamSpot, primaries, ghostTrack);
}

std::vector< TransientVertex > GhostTrackVertexFinder::vertices	(	const GhostTrack &	ghostTrack,
		const CachingVertex< 5 > &	primary = CachingVertex<5>(),
		const reco::BeamSpot &	beamSpot = reco::BeamSpot(),
		bool	hasBeamSpot = false,
		bool	hasPrimaries = false
	)		const

Definition at line 1196 of file GhostTrackVertexFinder.cc.

References gather_cfg::cout, MillePedeFileConverter_cfg::e, reco::GhostTrackVertexFinder::FinderInfo::field, fitType_, reco::GhostTrackVertexFinder::FinderInfo::ghostTrack, info(), initialVertices(), CachingVertex< N >::isValid(), kRefitGhostTrackWithVertices, reco::GhostTrackVertexFinder::FinderInfo::pred, reco::GhostTrack::prediction(), reassignTracks(), recursiveMerge(), refitGhostTrack(), mps_fire::result, reco::GhostTrackVertexFinder::FinderInfo::states, std::swap(), transientGhostTrack(), vertices(), and badGlobalMuonTaggersAOD_cff::vtx.

{
    FinderInfo info(primary, ghostTrack, beamSpot,
                    hasBeamSpot, hasPrimaries);

    std::vector<TransientVertex> result;
    if (info.states.empty())
        return result;

    info.field = info.states[0].track().field();
    info.ghostTrack = transientGhostTrack(info.pred, info.field);

    std::vector<CachingVertex<5> > vertices = initialVertices(info);
    if (primary.isValid()) {
        vertices.push_back(primary);
        if (vertices.size() > 1)
            std::swap(vertices.front(), vertices.back());
    }

    unsigned int reassigned = 0;
    while(reassigned < 3) {
        if (vertices.size() < 2)
            break;

#ifdef DEBUG
        for(std::vector<CachingVertex<5> >::const_iterator iter =
            vertices.begin(); iter != vertices.end(); ++iter)

            debugVertex(*iter, ghostTrack.prediction());

        std::cout << "----- recursive merging: ---------" << std::endl;
#endif

        bool changed = recursiveMerge(vertices, info);
        if ((!changed && !reassigned) || vertices.size() < 2)
            break;
        if (changed)
            reassigned = 0;

        if (fitType_ == kRefitGhostTrackWithVertices) {
            refitGhostTrack(vertices, info);
            changed = true;
        }

        try {
#ifdef DEBUG
            for(std::vector<CachingVertex<5> >::const_iterator
                        iter = vertices.begin();
                iter != vertices.end(); ++iter)
                debugVertex(*iter, ghostTrack.prediction());
            std::cout << "----- reassignment: ---------" << std::endl;
#endif
            if (reassignTracks(vertices, info)) {
                reassigned++;
                changed = true;
            } else
                reassigned = 0;
        } catch(const VertexException &e) {
            // just keep vertices as they are
        }

        if (!changed)
            break;
    }

    for(std::vector<CachingVertex<5> >::const_iterator iter =
            vertices.begin(); iter != vertices.end(); ++iter) {
        std::vector<RefCountedVertexTrack> tracks = iter->tracks();
        std::vector<RefCountedVertexTrack> newTracks;
        newTracks.reserve(tracks.size());

        std::remove_copy_if(tracks.begin(), tracks.end(),
                            std::back_inserter(newTracks),
                            VtxTrackIs(info.ghostTrack));

        if (newTracks.empty())
            continue;

        CachingVertex<5> vtx(iter->vertexState(), newTracks,
                             iter->totalChiSquared());
        result.push_back(vtx);
    }

    return result;
}

Member Data Documentation

FitType reco::GhostTrackVertexFinder::fitType_

private

Definition at line 180 of file GhostTrackVertexFinder.h.

Referenced by mergeVertices(), reassignTracks(), and vertices().

std::unique_ptr<GhostTrackFitter> reco::GhostTrackVertexFinder::ghostTrackFitter_

mutableprivate

Definition at line 182 of file GhostTrackVertexFinder.h.

Referenced by ghostTrackFitter().

double reco::GhostTrackVertexFinder::maxFitChi2_

private

Definition at line 176 of file GhostTrackVertexFinder.h.

Referenced by recursiveMerge().

double reco::GhostTrackVertexFinder::mergeThreshold_

private

Definition at line 177 of file GhostTrackVertexFinder.h.

Referenced by recursiveMerge().

double reco::GhostTrackVertexFinder::primcut_

private

Definition at line 178 of file GhostTrackVertexFinder.h.

Referenced by reassignTracks(), recursiveMerge(), and vertexFitter().

std::unique_ptr<VertexFitter<5> > reco::GhostTrackVertexFinder::primVertexFitter_

mutableprivate

Definition at line 183 of file GhostTrackVertexFinder.h.

Referenced by vertexFitter().

double reco::GhostTrackVertexFinder::seccut_

private

Definition at line 179 of file GhostTrackVertexFinder.h.

Referenced by reassignTracks(), recursiveMerge(), and vertexFitter().

std::unique_ptr<VertexFitter<5> > reco::GhostTrackVertexFinder::secVertexFitter_

mutableprivate

Definition at line 184 of file GhostTrackVertexFinder.h.

Referenced by vertexFitter().