GhostTrackFitter.cc

Go to the documentation of this file.

#include <memory>
#include <vector>

#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h" 
#include "DataFormats/GeometryVector/interface/VectorUtil.h" 
#include "DataFormats/GeometryCommonDetAlgo/interface/GlobalError.h"

#include "TrackingTools/TransientTrack/interface/TransientTrack.h"

#include "RecoVertex/GhostTrackFitter/interface/GhostTrack.h"
#include "RecoVertex/GhostTrackFitter/interface/GhostTrackState.h"
#include "RecoVertex/GhostTrackFitter/interface/GhostTrackPrediction.h"

#include "RecoVertex/GhostTrackFitter/interface/GhostTrackFitter.h"

#include "RecoVertex/GhostTrackFitter/interface/AnnealingGhostTrackFitter.h"
#include "RecoVertex/GhostTrackFitter/interface/PositiveSideGhostTrackFitter.h"
#include "RecoVertex/GhostTrackFitter/interface/KalmanGhostTrackUpdater.h"

using namespace reco;

GhostTrackFitter::GhostTrackFitter()
{
    fitter.reset(new AnnealingGhostTrackFitter);
    updater.reset(new KalmanGhostTrackUpdater);
}

GhostTrackFitter::~GhostTrackFitter()
{
}

GhostTrack GhostTrackFitter::fit(
            const GlobalPoint &priorPosition,
            const GlobalError &priorError,
            const GlobalVector &direction,
            double coneRadius,
            const std::vector<TransientTrack> &tracks) const
{
    GhostTrackPrediction prior(priorPosition, priorError,
                               direction, coneRadius);
    return fit(prior, priorPosition, tracks);
}

GhostTrack GhostTrackFitter::fit(
            const GlobalPoint &priorPosition,
            const GlobalError &priorError,
            const GlobalVector &direction,
            const GlobalError &directionError,
            const std::vector<TransientTrack> &tracks) const
{
    GhostTrackPrediction prior(priorPosition, priorError,
                               direction, directionError);
    return fit(prior, priorPosition, tracks);
}

GhostTrack GhostTrackFitter::fit(
            const GhostTrackPrediction &prior,
            const GlobalPoint &origin,
            const std::vector<TransientTrack> &tracks) const
{
    double offset = prior.lambda(origin);

    std::vector<GhostTrackState> states;
    for(std::vector<TransientTrack>::const_iterator iter = tracks.begin();
        iter != tracks.end(); ++iter) {
        GhostTrackState state(*iter);
        state.linearize(prior, true, offset);
        states.push_back(state);
    }

    PositiveSideGhostTrackFitter actualFitter(origin, *fitter);
    return fit(actualFitter, prior, states);
}

GhostTrack GhostTrackFitter::fit(
            const GhostTrackPrediction &prior,
            const std::vector<TransientTrack> &tracks) const
{
    std::vector<GhostTrackState> states;
    for(std::vector<TransientTrack>::const_iterator iter = tracks.begin();
        iter != tracks.end(); ++iter) {
        GhostTrackState state(*iter);
        state.linearize(prior, true);
        states.push_back(state);
    }

    return fit(*fitter, prior, states);
}

GhostTrack GhostTrackFitter::fit(
            FitterImpl &fitterImpl,
            const GhostTrackPrediction &prior,
            const std::vector<GhostTrackState> &states_) const
{
    std::vector<GhostTrackState> states = states_;

    double ndof, chi2;
    GhostTrackPrediction pred =
            fitterImpl.fit(*updater, prior, states, ndof, chi2);

    GhostTrack result(prior, pred, states, ndof, chi2);

    return result;
}