/data/refman/pasoursint/CMSSW_6_1_2_SLHC2/src/RecoVertex/GhostTrackFitter/src/GhostTrackState.cc

Go to the documentation of this file.

#include <cmath>

#include <Math/SMatrix.h>
#include <Math/MatrixFunctions.h>

#include "FWCore/Utilities/interface/Exception.h"

#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h" 

#include "RecoVertex/VertexPrimitives/interface/VertexState.h"
#include "RecoVertex/GhostTrackFitter/interface/GhostTrackPrediction.h"

#include "RecoVertex/GhostTrackFitter/interface/GhostTrackState.h"
#include "RecoVertex/GhostTrackFitter/interface/TrackGhostTrackState.h"
#include "RecoVertex/GhostTrackFitter/interface/VertexGhostTrackState.h"

using namespace reco;

namespace {
        using namespace ROOT::Math;

        typedef SVector<double, 3> Vector3;

        static inline Vector3 conv(const GlobalVector &vec)
        {
                Vector3 result;
                result[0] = vec.x();
                result[1] = vec.y();
                result[2] = vec.z();
                return result;
        }
}

GhostTrackState::GhostTrackState(const TransientTrack &track) :
        Base(new TrackGhostTrackState(track))
{
}

GhostTrackState::GhostTrackState(const GlobalPoint &pos,
                                 const CovarianceMatrix &cov) :
        Base(new VertexGhostTrackState(pos, cov))
{
}

GhostTrackState::GhostTrackState(const GlobalPoint &pos,
                                 const GlobalError &error) :
        Base(new VertexGhostTrackState(pos, error.matrix_new()))
{
}

GhostTrackState::GhostTrackState(const VertexState &state) :
        Base(new VertexGhostTrackState(state.position(),
                                       state.error().matrix_new()))
{
}

bool GhostTrackState::isTrack() const
{
        return dynamic_cast<const TrackGhostTrackState*>(&data()) != 0;
}

bool GhostTrackState::isVertex() const
{
        return dynamic_cast<const VertexGhostTrackState*>(&data()) != 0;
}

static const TrackGhostTrackState *getTrack(const BasicGhostTrackState *basic)
{
        const TrackGhostTrackState *track =
                        dynamic_cast<const TrackGhostTrackState*>(basic);
        if (!track)
                throw cms::Exception("InvalidOperation")
                        << "track requested on non non-track GhostTrackState";
        return track;
}

const TransientTrack &GhostTrackState::track() const
{
        return getTrack(&data())->track();
}

const TrajectoryStateOnSurface &GhostTrackState::tsos() const
{
        return getTrack(&data())->tsos();
}

double GhostTrackState::flightDistance(const GlobalPoint &point,
                                       const GlobalVector &dir) const
{
        return (globalPosition() - point).dot(dir.unit());
}

double GhostTrackState::axisDistance(const GlobalPoint &point,
                                     const GlobalVector &dir) const
{
        return (globalPosition() - point).cross(dir.unit()).mag();
}

double GhostTrackState::axisDistance(const GhostTrackPrediction &pred) const
{
        return axisDistance(pred.origin(), pred.direction());
}

double GhostTrackState::lambdaError(const GhostTrackPrediction &pred,
                                    const GlobalError &pvError) const
{
        if (!isValid())
                return -1.;

        return std::sqrt(
                ROOT::Math::Similarity(
                        conv(pred.direction()),
                        (vertexStateOnGhostTrack(pred).second.matrix_new() +
                         pvError.matrix_new()))
                / pred.rho2());
}